X-Git-Url: https://git.openssl.org/gitweb/?a=blobdiff_plain;f=Configure;h=5993f9b23778f953e8d16293eeee8c9d7383a8d9;hb=02a36fdae8cb503e2f88eac52eb3053431089397;hp=5e5205c2edf085fb7419d1afb2e77b5f6e4f0440;hpb=7d46b9426f6d40634c6d613ed5ce9247acd7b018;p=openssl.git diff --git a/Configure b/Configure index 5e5205c2ed..5993f9b237 100755 --- a/Configure +++ b/Configure @@ -110,7 +110,7 @@ my $usage="Usage: Configure [no- ...] [enable- ...] [experimenta # Minimum warning options... any contributions to OpenSSL should at least get # past these. -my $gcc_devteam_warn = "-Wall -pedantic -DPEDANTIC -Wno-long-long -Wsign-compare -Wmissing-prototypes -Wshadow -Wformat -Werror -DCRYPTO_MDEBUG_ALL -DCRYPTO_MDEBUG_ABORT -DREF_CHECK"; +my $gcc_devteam_warn = "-Wall -pedantic -DPEDANTIC -Wno-long-long -Wsign-compare -Wmissing-prototypes -Wshadow -Wformat -Werror -DCRYPTO_MDEBUG_ALL -DCRYPTO_MDEBUG_ABORT -DREF_CHECK -DDEBUG_UNUSED"; my $clang_disabled_warnings = "-Wno-language-extension-token -Wno-extended-offsetof -Wno-padded -Wno-shorten-64-to-32 -Wno-format-nonliteral -Wno-missing-noreturn -Wno-unused-parameter -Wno-sign-conversion -Wno-unreachable-code -Wno-conversion -Wno-documentation -Wno-missing-variable-declarations -Wno-cast-align -Wno-incompatible-pointer-types-discards-qualifiers -Wno-missing-variable-declarations -Wno-missing-field-initializers -Wno-unused-macros -Wno-disabled-macro-expansion -Wno-conditional-uninitialized -Wno-switch-enum"; @@ -134,10 +134,13 @@ my $bits1="THIRTY_TWO_BIT "; my $bits2="SIXTY_FOUR_BIT "; my $x86_asm="x86cpuid.o:bn-586.o co-586.o x86-mont.o x86-gf2m.o:ecp_nistz256.o ecp_nistz256-x86.o:des-586.o crypt586.o:aes-586.o vpaes-x86.o aesni-x86.o:bf-586.o:md5-586.o:sha1-586.o sha256-586.o sha512-586.o:cast-586.o:rc4-586.o:rmd-586.o:rc5-586.o:wp_block.o wp-mmx.o:cmll-x86.o:ghash-x86.o:e_padlock-x86.o"; +my $x86_asm_nocast=$x86_asm;$x86_asm_nocast=~s/cast\-586\.o//; my $x86_elf_asm="$x86_asm:elf"; +my $android_x86_elf_asm="$x86_asm:android"; my $x86_64_asm="x86_64cpuid.o:x86_64-gcc.o x86_64-mont.o x86_64-mont5.o x86_64-gf2m.o rsaz_exp.o rsaz-x86_64.o rsaz-avx2.o:ecp_nistz256.o ecp_nistz256-x86_64.o::aes-x86_64.o vpaes-x86_64.o bsaes-x86_64.o aesni-x86_64.o aesni-sha1-x86_64.o aesni-sha256-x86_64.o aesni-mb-x86_64.o::md5-x86_64.o:sha1-x86_64.o sha256-x86_64.o sha512-x86_64.o sha1-mb-x86_64.o sha256-mb-x86_64.o::rc4-x86_64.o rc4-md5-x86_64.o:::wp-x86_64.o:cmll-x86_64.o cmll_misc.o:ghash-x86_64.o aesni-gcm-x86_64.o:e_padlock-x86_64.o"; +my $win_x86_64_asm=$x86_asm;$win_x86_64_asm=~s/x86_64-gcc\.o/bn_asm.o/; my $ia64_asm="ia64cpuid.o:bn-ia64.o ia64-mont.o:::aes_core.o aes_cbc.o aes-ia64.o::md5-ia64.o:sha1-ia64.o sha256-ia64.o sha512-ia64.o::rc4-ia64.o rc4_skey.o:::::ghash-ia64.o::void"; my $sparcv9_asm="sparcv9cap.o sparccpuid.o:bn-sparcv9.o sparcv9-mont.o sparcv9a-mont.o vis3-mont.o sparct4-mont.o sparcv9-gf2m.o::des_enc-sparc.o fcrypt_b.o dest4-sparcv9.o:aes_core.o aes_cbc.o aes-sparcv9.o aest4-sparcv9.o::md5-sparcv9.o:sha1-sparcv9.o sha256-sparcv9.o sha512-sparcv9.o::::::camellia.o cmll_misc.o cmll_cbc.o cmllt4-sparcv9.o:ghash-sparcv9.o::void"; my $sparcv8_asm=":sparcv8.o::des_enc-sparc.o fcrypt_b.o:::::::::::::void"; @@ -145,10 +148,12 @@ my $alpha_asm="alphacpuid.o:bn_asm.o alpha-mont.o::::::sha1-alpha.o:::::::ghash- my $mips64_asm=":bn-mips.o mips-mont.o:::aes_cbc.o aes-mips.o:::sha1-mips.o sha256-mips.o sha512-mips.o::::::::"; my $mips32_asm=$mips64_asm; $mips32_asm =~ s/\s*sha512\-mips\.o//; my $s390x_asm="s390xcap.o s390xcpuid.o:bn-s390x.o s390x-mont.o s390x-gf2m.o:::aes-s390x.o aes-ctr.o aes-xts.o:::sha1-s390x.o sha256-s390x.o sha512-s390x.o::rc4-s390x.o:::::ghash-s390x.o:"; +my $s390x_32_asm=$s390x_asm;$s390x_32_asm=~s/bn\-s390x\.o/bn_asm.o/; my $armv4_asm="armcap.o armv4cpuid.o:bn_asm.o armv4-mont.o armv4-gf2m.o:ecp_nistz256.o ecp_nistz256-armv4.o::aes_cbc.o aes-armv4.o bsaes-armv7.o aesv8-armx.o:::sha1-armv4-large.o sha256-armv4.o sha512-armv4.o:::::::ghash-armv4.o ghashv8-armx.o::void"; my $aarch64_asm="armcap.o arm64cpuid.o mem_clr.o::::aes_core.o aes_cbc.o aesv8-armx.o:::sha1-armv8.o sha256-armv8.o sha512-armv8.o:::::::ghashv8-armx.o:"; my $parisc11_asm="pariscid.o:bn_asm.o parisc-mont.o:::aes_core.o aes_cbc.o aes-parisc.o:::sha1-parisc.o sha256-parisc.o sha512-parisc.o::rc4-parisc.o:::::ghash-parisc.o::32"; -my $parisc20_asm="pariscid.o:pa-risc2W.o parisc-mont.o:::aes_core.o aes_cbc.o aes-parisc.o:::sha1-parisc.o sha256-parisc.o sha512-parisc.o::rc4-parisc.o:::::ghash-parisc.o::64"; +my $parisc20_64_asm="pariscid.o:pa-risc2W.o parisc-mont.o:::aes_core.o aes_cbc.o aes-parisc.o:::sha1-parisc.o sha256-parisc.o sha512-parisc.o::rc4-parisc.o:::::ghash-parisc.o::64"; +my $parisc20_32_asm=$parisc20_64_asm;$parisc20_32_asm=~s/2W\./2\./;$parisc20_32_asm=~s/:64/:32/; my $ppc64_asm="ppccpuid.o ppccap.o:bn-ppc.o ppc-mont.o ppc64-mont.o:::aes_core.o aes_cbc.o aes-ppc.o vpaes-ppc.o aesp8-ppc.o:::sha1-ppc.o sha256-ppc.o sha512-ppc.o sha256p8-ppc.o sha512p8-ppc.o:::::::ghashp8-ppc.o:"; my $ppc32_asm=$ppc64_asm; @@ -161,7 +166,6 @@ my $ppc32_asm=$ppc64_asm; # seems to be sufficient? my $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT"; - # table of known configurations, read in from files # # The content of each entry can take one of two forms: @@ -218,14 +222,14 @@ my $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT"; # { # cc => $cc, # cflags => $cflags, -# "debug-cflags" => $debug_cflags, -# "nodebug-cflags" => $nodebug_cflags, +# debug_cflags => $debug_cflags, +# release_cflags => $release_cflags, # unistd => $unistd, # thread_cflag => $thread_cflag, # sys_id => $sys_id, # lflags => $lflags, -# "debug-lflags" => $debug_lflags, -# "nodebug-lflags" => $nodebug_lflags, +# debug_lflags => $debug_lflags, +# release_lflags => $release_lflags, # bn_ops => $bn_ops, # cpuid_obj => $cpuid_obj, # bn_obj => $bn_obj, @@ -259,48 +263,80 @@ my $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT"; # # The configuration hashes can refer to templates in two different manners: # -# - as part of the hash, one can have a key called 'base_templates' that +# - as part of the hash, one can have a key called 'inherit_from' that # indicate what other configuration hashes to inherit data from. # These are resolved recursively. # +# Inheritance works as a set of default values that can be overriden +# by corresponding attribute values in the inheriting configuration. +# +# If several configurations are given in the 'inherit_from' array, the +# values of same attribute are concatenated with space separation. +# With this, it's possible to have several smaller templates for +# different configuration aspects that can be combined into a complete +# configuration. +# # Example: # +# "foo" => { +# template => 1, +# haha => "haha", +# hoho => "ho" +# }, # "bar" => { -# haha => "haha" +# template => 1, +# hoho => "ho", +# hehe => "hehe" # }, -# "foo" => { -# base_templates => [ "bar" ], -# hoho => "hoho" +# "laughter" => { +# inherit_from => [ "foo", "bar" ], # } # # The entry for "foo" will become as follows after processing: # -# "foo" => { +# "laughter" => { # haha => "haha", -# hoho => "hoho" +# hoho => "ho ho", +# hehe => "hehe" # } # # Note 1: any entry from the table can be used as a template. # Note 2: pure templates have the attribute 'template => 1' and cannot -# be used as targets +# be used as targets. # -# - as part of any string, one can have a template reference wrapped in -# double braces, and when processing templates, this will be replaced -# with the corresponding string from the template. +# - instead of a string, one can have a code block of the form +# 'sub { /* your code here */ }', where the arguments are the list of +# inherited values for that key. In fact, the concatenation of strings +# is really done by using 'sub { join(" ",@_) }' on the list of inherited +# values. # # Example: # +# "foo" => { +# template => 1, +# haha => "ha ha", +# hoho => "ho", +# ignored => "This should not appear in the end result", +# }, # "bar" => { -# haha => "haha" +# template => 1, +# haha => "ah", +# hoho => "haho", +# hehe => "hehe" # }, -# "foo" => { -# haha => "{{bar}} !!!!" +# "laughter" => { +# inherit_from => [ "foo", "bar" ], +# hehe => sub { join(" ",(@_,"!!!")) }, +# ignored => "", # } # # The entry for "foo" will become as follows after processing: # -# "foo" => { -# haha => "haha !!!!" +# "laughter" => { +# haha => "ha ha ah", +# hoho => "ho haho", +# hehe => "hehe !!!", +# ignored => "" # } # @@ -312,28 +348,6 @@ my %table=( # Note: as long as someone might use old style configuration strings, # or we bother supporting that, those variables need to stay - # Filler used for when there are no asm files. - no_asm_filler => { - template => 1, - cpuid_obj => "", - bn_obj => "", - ec_obj => "", - des_obj => "", - aes_obj => "", - bf_obj => "", - md5_obj => "", - sha1_obj => "", - cast_obj => "", - rc4_obj => "", - rmd160_obj => "", - rc5_obj => "", - wp_obj => "", - cmll_obj => "", - modes_obj => "", - engines_obj => "", - perlasm_scheme => "void" - }, - x86_asm => { template => 1, cpuid_obj => "x86cpuid.o", @@ -344,7 +358,6 @@ my %table=( bf_obj => "bf-586.o", md5_obj => "md5-586.o", sha1_obj => "sha1-586.o sha256-586.o sha512-586.o", - cast_obj => "cast-586.o", rc4_obj => "rc4-586.o", rmd160_obj => "rmd-586.o", rc5_obj => "rc5-586.o", @@ -355,10 +368,9 @@ my %table=( }, x86_elf_asm => { template => 1, - base_templates => [ "x86_asm" ], + inherit_from => [ "x86_asm" ], perlasm_scheme => "elf" }, - x86_64_asm => { template => 1, cpuid_obj => "x86_64cpuid.o", @@ -418,9 +430,9 @@ my %table=( sha1_obj => "sha1-mips.o sha256-mips.o", }, mips64_asm => { - base_templates => [ "mips32_asm" ], + inherit_from => [ "mips32_asm" ], template => 1, - sha1_obj => "{{mips32_asm}} sha512-mips.o", + sha1_obj => sub { join(" ", @_, "sha512-mips.o") } }, s390x_asm => { template => 1, @@ -458,15 +470,11 @@ my %table=( modes_obj => "ghash-parisc.o", perlasm_scheme => "32" }, - parisc20_asm => { + parisc20_64_asm => { template => 1, - cpuid_obj => "pariscid.o", - bn_obj => "pa-risc2W.o parisc-mont.o", - aes_obj => "aes_core.o aes_cbc.o aes-parisc.o", - sha1_obj => "sha1-parisc.o sha256-parisc.o sha512-parisc.o", - rc4_obj => "rc4-parisc.o", - modes_obj => "ghash-parisc.o", - perlasm_scheme => "64" + inherit_from => [ "parisc11_asm" ], + bn_obj => sub { my $r=join(" ",@_); $r=~s/bn_asm/pa-risc2W/; $r; }, + perlasm_scheme => "64", }, ppc64_asm => { template => 1, @@ -477,11 +485,17 @@ my %table=( modes_obj => "ghashp8-ppc.o", }, ppc32_asm => { - base_templates => [ "ppc64_asm" ], + inherit_from => [ "ppc64_asm" ], template => 1 }, ); +{ my $no_asm_templates=0; + foreach (@ARGV) { $no_asm_templates=1 if (/^\-?no\-asm$/); } + sub asm { $no_asm_templates?():@_; } +} + + sub stringtohash { my $in = shift @_; if (ref($in) eq "HASH") { @@ -526,32 +540,6 @@ sub stringtohash { return { map { shift @stringsequence => $_ } split /:/, $in }; }; -# Support function to look for and resolve template references. -# It uses breadcrumbs to check for circular template references. -# -# Note: Any configuration value is also a template. -sub lookup_templates { - my $tableref = shift; - my $target = shift; - my @breadcrumbs = @_; - - if (grep { $_ eq $target } @breadcrumbs) { - die "Template loop! target backtrace:\n ",join("\n ", - $target, - @breadcrumbs),"\n"; - } - - foreach my $key (keys %{$tableref->{$target}}) { - my $value = $tableref->{$target}->{$key}; - while ($value =~ /{{([-\w]+)}}/) { - lookup_templates($tableref, $1, $target, @breadcrumbs); - $value = $`.$tableref->{$1}->{$key}.$'; - } - $tableref->{$target}->{$key} = $value; - } -}; - - # Read configuration target stanzas from a file, so that people can have # local files with their own definitions sub read_config { @@ -621,9 +609,9 @@ sub read_config { # First, check that the non-debug variant isn't # already built up with all it should have. if ($nondebug->{debug_cflags} - || $nondebug->{nodebug_cflags} + || $nondebug->{release_cflags} || $nondebug->{debug_lflags} - || $nondebug->{nodebug_lflags}) { + || $nondebug->{release_lflags}) { warn "there's a debug target $debugkey to be merged with a target $nondebugkey, but the latter seems to already have both nodebug and debug information. This requires human intervention. Skipping $debugkey..."; next; } @@ -653,11 +641,11 @@ sub read_config { # becomes the merged variant when we're done. # for each of cflags and lflags, they are # replaced with cflags, debug_cflags, - # nodebug_cflags and similar for lflags. + # release_cflags and similar for lflags. # # The purpose is that 'cflags' should be # used together with 'debug_cflags' or - # 'nodebug_cflags' depending on what the + # 'release_cflags' depending on what the # user asks for. foreach (("cflags", "lflags")) { my @list_d = split /\s+/, $debug->{$_}; @@ -693,57 +681,98 @@ sub read_config { %table = (%table, %targets); - # Go through all new targets and resolve template references. - foreach (keys %targets) { - # Start with resolving the base templates - my @breadcrumbs = (); - while (my @base_templates = - $table{$_}->{base_templates} ? - @{$table{$_}->{base_templates}} : ()) { - my %new_template_data = (); - my %new_base_templates = (); - foreach my $base_template (@base_templates) { - if (grep { $_ eq $base_template } @breadcrumbs) { - die "Base template loop! target backtrace:\n " - ,$base_template,"\n " - ,join("\n ", - map { "[ ".join(", ", @{$_})." ]" } @breadcrumbs) - ,"\n"; + # Local function to resolve inheritance + my $resolve_inheritance; + $resolve_inheritance = + sub { + my $target = shift; + my @breadcrumbs = @_; + + if (grep { $_ eq $target } @breadcrumbs) { + die "inherit_from loop! target backtrace:\n " + ,$target,"\n ",join("\n ", @breadcrumbs),"\n"; + } + + # Recurse through all inheritances. They will be resolved on + # the fly, so when this operation is done, they will all just + # be a bunch of attributes with string values. + # What we get here, though, are keys with references to lists + # of the combined values of them all. We will deal with lists + # after this stage is done. + my %combined_inheritance = (); + if ($table{$target}->{inherit_from}) { + foreach (@{$table{$target}->{inherit_from}}) { + my %inherited_config = + $resolve_inheritance->($_, $target, @breadcrumbs); + + # 'template' is a marker that's considered private to + # the config that had it. + delete $inherited_config{template}; + + map { + if (!$combined_inheritance{$_}) { + $combined_inheritance{$_} = []; + } + push @{$combined_inheritance{$_}}, $inherited_config{$_}; + } keys %inherited_config; + } + } + + # We won't need inherit_from in this target any more, since + # we've resolved all the inheritances that lead to this + delete $table{$target}->{inherit_from}; + + # Now is the time to deal with those lists. Here's the place + # to decide what shall be done with those lists, all based on + # the values of the target we're currently dealing with. + # - If a value is a coderef, it will be executed with the list + # of inherited values as arguments. + # - If the corresponding key doesn't have a value at all or is + # the emoty string, the inherited value list will be run + # through the default combiner (below), and the result + # becomes this target's value. + # - Otherwise, this target's value is assumed to be a string + # that will simply override the inherited list of values. + my $default_combiner = sub { join(' ',@_) }; + + my %all_keys = + map { $_ => 1 } (keys %combined_inheritance, + keys %{$table{$target}}); + foreach (sort keys %all_keys) { + + # Current target doesn't have a value for the current key? + # Assign it the default combiner, the rest of this loop + # body will handle it just like any other coderef. + if (!exists $table{$target}->{$_}) { + $table{$target}->{$_} = $default_combiner; } - if ($table{$base_template}) { - %new_base_templates = - ( - %new_base_templates, - map { $_ => 1 } @{$table{$base_template}->{base_templates}} - ); - %new_template_data = - ( - %new_template_data, - %{$table{$base_template}} - ); - delete $new_template_data{template}; + my $valuetype = ref($table{$target}->{$_}); + if ($valuetype eq "CODE") { + # CODE reference, execute it with the inherited values + # as arguments. + $table{$target}->{$_} = + $table{$target}->{$_}->(@{$combined_inheritance{$_}}); + } elsif ($valuetype eq "") { + # Scalar, just leave it as is. } else { - # There are unresolved base templates. That's no good - warn "Target $_ has unresolved base templates. Removing..."; - delete $table{$_}; - goto NEXT; + # Some other type of reference that we don't handle. + # Better to abort at this point. + die "cannot handle reference type $valuetype," + ," found in target $target -> $_\n"; } } - @breadcrumbs = ( [ @base_templates ], @breadcrumbs ); - # Now, we rebuild the target, using the newly fetched template - # data, overlaying that with the target's original data, and - # overlaying the new base template list on top of that - $table{$_} = { - %new_template_data, - %{$table{$_}}, - base_templates => [ keys %new_base_templates ] - } - } + # Finally done, return the result. + %{$table{$target}}; + }; - lookup_templates(\%table, $_); - NEXT: + # Go through all new targets and resolve inheritance and template + # references. + foreach (keys %targets) { + # We're ignoring the returned values here, they are only valuable + # to the inner recursion of this function. + $resolve_inheritance->($_); } } @@ -853,6 +882,7 @@ my $options; my $symlink; my $make_depend=0; my %withargs=(); +my $build_prefix = "release_"; my @argvcopy=@ARGV; my $argvstring=""; @@ -927,10 +957,18 @@ PROCESS_ARGS: { exit(&test_sanity()); } - elsif (/^--strict-warnings/) + elsif (/^--strict-warnings$/) { $strict_warnings = 1; } + elsif (/^--debug$/) + { + $build_prefix = "debug_"; + } + elsif (/^--release$/) + { + $build_prefix = "release_"; + } elsif (/^reconfigure/ || /^reconf/) { if (open(IN,"<$Makefile")) @@ -1141,21 +1179,26 @@ if ($target =~ m/^CygWin32(-.*)$/) { print "Configuring for $target\n"; +# Support for legacy targets having a name starting with 'debug-' my ($d, $t) = $target =~ m/^(debug-)?(.*)$/; -my $debug_prefix = "nodebug-"; if ($d) { - $debug_prefix = "debug-"; + $build_prefix = "debug_"; # If we do not find debug-foo in the table, the target is set to foo, - # but only if the foo target has a noon-empty debug-cflags or debug-lflags + # but only if the foo target has a noon-empty debug_cflags or debug_lflags # attribute. - if (!$table{$target} && ($table{$t}->{"debug-cflags"} - || $table{$t}->{"debug-lflags"})) { + if (!$table{$target} && ($table{$t}->{debug_cflags} + || $table{$t}->{debug_lflags})) { $target = $t; } } -&usage if (!defined($table{$target}) || $table{$target}->{template}); +&usage if (!defined($table{$target}) + || $table{$target}->{template} + || ($build_prefix eq "debug_" + && $target !~ /^debug-/ + && !($table{$target}->{debug_cflags} + || $table{$target}->{debug_lflags}))); if ($fips) { @@ -1260,47 +1303,47 @@ $openssldir=$prefix . "/" . $openssldir if $openssldir !~ /(^\/|^[a-zA-Z]:[\\\/] print "IsMK1MF=$IsMK1MF\n"; # Allow environment CC to override compiler... -my $cc = $ENV{CC} || $table{$t}->{cc}; +my $cc = $ENV{CC} || $table{$target}->{cc}; -# For cflags and lflags, add the debug- or nodebug- attributes +# For cflags and lflags, add the debug_ or release_ attributes # Do it in such a way that no spurious space is appended (hence the grep). my $cflags = join(" ", - grep { $_ } ($table{$t}->{cflags}, - $table{$t}->{$debug_prefix."cflags"})); + grep { $_ } ($table{$target}->{cflags}, + $table{$target}->{$build_prefix."cflags"})); my $lflags = join(" ", - grep { $_ } ($table{$t}->{lflags}, - $table{$t}->{$debug_prefix."lflags"})); - -my $unistd = $table{$t}->{unistd}; -my $thread_cflag = $table{$t}->{thread_cflag}; -my $sys_id = $table{$t}->{sys_id}; -my $bn_ops = $table{$t}->{bn_ops}; -my $cpuid_obj = $table{$t}->{cpuid_obj}; -my $bn_obj = $table{$t}->{bn_obj}; -my $ec_obj = $table{$t}->{ec_obj}; -my $des_obj = $table{$t}->{des_obj}; -my $aes_obj = $table{$t}->{aes_obj}; -my $bf_obj = $table{$t}->{bf_obj}; -my $md5_obj = $table{$t}->{md5_obj}; -my $sha1_obj = $table{$t}->{sha1_obj}; -my $cast_obj = $table{$t}->{cast_obj}; -my $rc4_obj = $table{$t}->{rc4_obj}; -my $rmd160_obj = $table{$t}->{rmd160_obj}; -my $rc5_obj = $table{$t}->{rc5_obj}; -my $wp_obj = $table{$t}->{wp_obj}; -my $cmll_obj = $table{$t}->{cmll_obj}; -my $modes_obj = $table{$t}->{modes_obj}; -my $engines_obj = $table{$t}->{engines_obj}; -my $perlasm_scheme = $table{$t}->{perlasm_scheme}; -my $dso_scheme = $table{$t}->{dso_scheme}; -my $shared_target = $table{$t}->{shared_target}; -my $shared_cflag = $table{$t}->{shared_cflag}; -my $shared_ldflag = $table{$t}->{shared_ldflag}; -my $shared_extension = $table{$t}->{shared_extension}; -my $ranlib = $ENV{'RANLIB'} || $table{$t}->{ranlib}; + grep { $_ } ($table{$target}->{lflags}, + $table{$target}->{$build_prefix."lflags"})); + +my $unistd = $table{$target}->{unistd}; +my $thread_cflag = $table{$target}->{thread_cflag}; +my $sys_id = $table{$target}->{sys_id}; +my $bn_ops = $table{$target}->{bn_ops}; +my $cpuid_obj = $table{$target}->{cpuid_obj}; +my $bn_obj = $table{$target}->{bn_obj}; +my $ec_obj = $table{$target}->{ec_obj}; +my $des_obj = $table{$target}->{des_obj}; +my $aes_obj = $table{$target}->{aes_obj}; +my $bf_obj = $table{$target}->{bf_obj}; +my $md5_obj = $table{$target}->{md5_obj}; +my $sha1_obj = $table{$target}->{sha1_obj}; +my $cast_obj = $table{$target}->{cast_obj}; +my $rc4_obj = $table{$target}->{rc4_obj}; +my $rmd160_obj = $table{$target}->{rmd160_obj}; +my $rc5_obj = $table{$target}->{rc5_obj}; +my $wp_obj = $table{$target}->{wp_obj}; +my $cmll_obj = $table{$target}->{cmll_obj}; +my $modes_obj = $table{$target}->{modes_obj}; +my $engines_obj = $table{$target}->{engines_obj}; +my $perlasm_scheme = $table{$target}->{perlasm_scheme}; +my $dso_scheme = $table{$target}->{dso_scheme}; +my $shared_target = $table{$target}->{shared_target}; +my $shared_cflag = $table{$target}->{shared_cflag}; +my $shared_ldflag = $table{$target}->{shared_ldflag}; +my $shared_extension = $table{$target}->{shared_extension}; +my $ranlib = $ENV{'RANLIB'} || $table{$target}->{ranlib}; my $ar = $ENV{'AR'} || "ar"; -my $arflags = $table{$t}->{arflags}; -my $multilib = $table{$t}->{multilib}; +my $arflags = $table{$target}->{arflags}; +my $multilib = $table{$target}->{multilib}; # if $prefix/lib$multilib is not an existing directory, then # assume that it's not searched by linker automatically, in @@ -2251,11 +2294,6 @@ sub print_table_entry my $target = shift; my $type = shift; - my $debug_cflags = "debug-cflags"; - my $nodebug_cflags = "nodebug-cflags"; - my $debug_lflags = "debug-lflags"; - my $nodebug_lflags = "nodebug-lflags"; - # Don't print the templates return if $table{$target}->{template}; @@ -2265,14 +2303,14 @@ sub print_table_entry *** $target \$cc = $table{$target}->{cc} \$cflags = $table{$target}->{cflags} -\$debug_cflags = $table{$target}->{$debug_cflags} -\$nodebug_cflags = $table{$target}->{$nodebug_cflags} +\$debug_cflags = $table{$target}->{debug_cflags} +\$release_cflags = $table{$target}->{release_cflags} \$unistd = $table{$target}->{unistd} \$thread_cflag = $table{$target}->{thread_cflag} \$sys_id = $table{$target}->{sys_id} \$lflags = $table{$target}->{lflags} -\$debug_lflags = $table{$target}->{$debug_lflags} -\$nodebug_lflags = $table{$target}->{$nodebug_lflags} +\$debug_lflags = $table{$target}->{debug_lflags} +\$release_lflags = $table{$target}->{release_lflags} \$bn_ops = $table{$target}->{bn_ops} \$cpuid_obj = $table{$target}->{cpuid_obj} \$bn_obj = $table{$target}->{bn_obj} @@ -2304,14 +2342,14 @@ EOF my @sequence = ( "cc", "cflags", - "debug-cflags", - "nodebug-cflags", + "debug_cflags", + "release_cflags", "unistd", "thread_cflag", "sys_id", "lflags", - "debug-lflags", - "nodebug-lflags", + "debug_lflags", + "release_lflags", "bn_ops", "cpuid_obj", "bn_obj",