Commit 722c9762 authored by Richard Levitte's avatar Richard Levitte
Browse files

Harmonize the make variables across all known platforms families 



The make variables LIB_CFLAGS, DSO_CFLAGS and so on were used in
addition to CFLAGS and so on.  This works without problem on Unix and
Windows, where options with different purposes (such as -D and -I) can
appear anywhere on the command line and get accumulated as they come.
This is not necessarely so on VMS.  For example, macros must all be
collected and given through one /DEFINE, and the same goes for
inclusion directories (/INCLUDE).

So, to harmonize all platforms, we repurpose make variables starting
with LIB_, DSO_ and BIN_ to be all encompassing variables that
collects the corresponding values from CFLAGS, CPPFLAGS, DEFINES,
INCLUDES and so on together with possible config target values
specific for libraries DSOs and programs, and use them instead of the
general ones everywhere.

This will, for example, allow VMS to use the exact same generators for
generated files that go through cpp as all other platforms, something
that has been impossible to do safely before now.

Reviewed-by: default avatarAndy Polyakov <appro@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/5357)
parent 7c60a968

Configurations/descrip.mms.tmpl

+34 −29
Original line number Diff line number Diff line
@@ -177,25 +177,37 @@ DEFINES={- our $defines = join(",", 
                               '__dummy', # To make comma processing easier

                               @{$config{defines}}) -}

INCLUDES={- our $includes = join(',', @{$config{includes}}) -}

CPPFLAGS={- our $cppflags = join('', @{$config{cppflags}}) -}

CPPFLAGS_Q={- (my $x = $cppflags) =~ s|"|""|g; $defines =~ s|"|""|g;

              $x .= "/DEFINE=($defines)";

CPPFLAGS='qual_includes'{- our $cppflags = join('', @{$config{cppflags}}) -}

CPPFLAGS_Q={- (my $x = $cppflags) =~ s|"|""|g;

              (my $d = $defines) =~ s|"|""|g;

              $x .= "/INCLUDE=($includes)" if $includes;

              $x .= "/DEFINE=($d)";

              $x; -}

CFLAGS={- join('', @{$config{cflags}}) -}

LDFLAGS= {- join('', @{$config{lflags}}) -}

EX_LIBS= {- join('', map { ','.$_ } @{$config{ex_libs}}) -}

LIB_DEFINES={- join("",

                    (map { ",$_" }



LIB_DEFINES=$(DEFINES){- join("", (map { ",$_" }

                                   @{$target{shared_defines}},

                                   'OPENSSLDIR="""$(OPENSSLDIR_C)"""',

                                   'ENGINESDIR="""$(ENGINESDIR_C)"""')) -}

LIB_CFLAGS={- $target{lib_cflags} // "" -}

DSO_CFLAGS={- $target{dso_cflags} // "" -}

BIN_CFLAGS={- $target{bin_cflags} // "" -}

NO_INST_LIB_CFLAGS={- $target{no_inst_lib_cflags} // '$(LIB_CFLAGS)' -}

NO_INST_DSO_CFLAGS={- $target{no_inst_dso_cflags} // '$(DSO_CFLAGS)' -}

NO_INST_BIN_CFLAGS={- $target{no_inst_bin_cflags} // '$(BIN_CFLAGS)' -}

LIB_CPPFLAGS=$(CPPFLAGS)/DEFINE=($(LIB_DEFINES))

LIB_CFLAGS=$(CFLAGS){- $target{lib_cflags} // "" -}

DSO_DEFINES=$(DEFINES){- join("", (map { ",$_" } @{$target{dso_defines}})) -}

DSO_CPPFLAGS=$(CPPFLAGS)/DEFINE=($(DSO_DEFINES))

DSO_CFLAGS=$(CFLAGS){- $target{dso_cflags} // "" -}

BIN_DEFINES=$(DEFINES){- join("", (map { ",$_" } @{$target{bin_defines}})) -}

BIN_CPPFLAGS=$(CPPFLAGS)/DEFINE=($(BIN_DEFINES))

BIN_CFLAGS=$(CFLAGS){- $target{bin_cflags} // "" -}

NO_INST_LIB_CFLAGS=$(CFLAGS){- $target{no_inst_lib_cflags}

                               // $target{lib_cflags}

                               // "" -}

NO_INST_DSO_CFLAGS=$(CFLAGS){- $target{no_inst_dso_cflags}

                               // $target{dso_cflags}

                               // "" -}

NO_INST_BIN_CFLAGS=$(CFLAGS){- $target{no_inst_bin_cflags}

                               // $target{bin_cflags}

                               // "" -}



PERL={- $config{perl} -}
@@ -622,24 +634,17 @@ EOF 
               map { abs2rel(rel2abs($_), rel2abs($forward)) } @{$args{srcs}});

      my $cflags = '$(CFLAGS)';

      if ($args{installed}) {

          $cflags .= { lib => '$(LIB_CFLAGS)',

          $cflags = { lib => '$(LIB_CFLAGS)',

                      dso => '$(DSO_CFLAGS)',

                      bin => '$(BIN_CFLAGS)' } -> {$args{intent}};

      } else {

          $cflags .= { lib => '$(NO_INST_LIB_CFLAGS)',

          $cflags = { lib => '$(NO_INST_LIB_CFLAGS)',

                      dso => '$(NO_INST_DSO_CFLAGS)',

                      bin => '$(NO_INST_BIN_CFLAGS)' } -> {$args{intent}};

      }

      $cflags .= '$(CPPFLAGS)';

      $cflags .= { lib => '$(LIB_CPPFLAGS)',

		   dso => '$(DSO_CPPFLAGS)',

		   bin => '$(BIN_CPPFLAGS)' } -> {$args{intent}};

      my $defines = '$(DEFINES)';

      $defines .= { lib => '$(LIB_DEFINES)',

		    dso => '$(DSO_DEFINES)',

		    bin => '$(BIN_DEFINES)' } -> {$args{intent}};

      $cflags .= '/DEFINE=('.$defines.')';

      $cflags .= "/INCLUDE=('tmp_includes')";

      

      # We create a logical name TMP_INCLUDES: to hold the list of internal

      # includes.  However, we cannot use it directly, as logical names can't
@@ -682,9 +687,9 @@ EOF 
$obj.OBJ : $deps

        ${before}

        SET DEFAULT $forward

        $incs_on

        \@ $incs_on

        \$(CC) ${cflags}${depbuild} /OBJECT=${objd}${objn}.OBJ /REPOSITORY=$backward $srcs

        $incs_off

        \@ $incs_off

        SET DEFAULT $backward

        ${after}

        - PURGE $obj.OBJ

Configurations/unix-Makefile.tmpl

+43 −39
Original line number Diff line number Diff line
@@ -196,22 +196,23 @@ CXXFLAGS={- join(' ', @{$config{cxxflags}}) -} 
LDFLAGS= {- join(' ', @{$config{lflags}}) -}

PLIB_LDFLAGS= {- join(' ', @{$config{plib_lflags}}) -}

EX_LIBS= {- join(' ', @{$config{ex_libs}}) -}

LIB_CPPFLAGS={- join(' ',



LIB_CPPFLAGS={- join(' ', '$(CPPFLAGS)',

                          $target{shared_cppflag} || (),

                          (map { '-D'.$_ }

                               ('OPENSSLDIR="\"$(OPENSSLDIR)\""',

                           'ENGINESDIR="\"$(ENGINESDIR)\""')),

                     $target{shared_cppflag}) || "" -}

LIB_CFLAGS={- $target{shared_cflag} || "" -}

LIB_CXXFLAGS={- $target{shared_cxxflag} || "" -}

LIB_LDFLAGS={- $target{shared_ldflag}." ".$config{shared_ldflag} -}

DSO_CPPFLAGS={- $target{dso_cppflags} || "" -}

DSO_CFLAGS={- $target{dso_cflags} || "" -}

DSO_CXXFLAGS={- $target{dso_cxxflags} || "" -}

DSO_LDFLAGS={- $target{dso_lflags} || "" -}

BIN_CPPFLAGS={- $target{bin_cppflags} || "" -}

BIN_CFLAGS={- $target{bin_cflags} || "" -}

BIN_CXXFLAGS={- $target{bin_cxxflags} || "" -}

BIN_LDFLAGS={- $target{bin_lflags} || "" -}

                                'ENGINESDIR="\"$(ENGINESDIR)\""'))) -}

LIB_CFLAGS={- join(' ', '$(CFLAGS)', $target{shared_cflag} || ()) -}

LIB_CXXFLAGS={- join(' ', '$(CXXFLAGS)', $target{shared_cxxflag} || ()) -}

LIB_LDFLAGS={- join(' ', '$(LDFLAGS)', $target{shared_ldflag} || (), $config{shared_ldflag} || ()) -}

DSO_CPPFLAGS={- join(' ', '$(CPPFLAGS)', $target{dso_cppflags} || ()) -}

DSO_CFLAGS={- join(' ', '$(CFLAGS)', $target{dso_cflags} || ()) -}

DSO_CXXFLAGS={- join(' ', '$(CXXFLAGS)', $target{dso_cxxflags} || ()) -}

DSO_LDFLAGS={- join(' ', '$(LDFLAGS)', $target{dso_lflags} || ()) -}

BIN_CPPFLAGS={- join(' ', '$(CPPFLAGS)', $target{bin_cppflags} || ()) -}

BIN_CFLAGS={- join(' ', '$(CFLAGS)', $target{bin_cflags} || ()) -}

BIN_CXXFLAGS={- join(' ', '$(CXXFLAGS)', $target{bin_cxxflags} || ()) -}

BIN_LDFLAGS={- join(' ', '$(LDFLAGS)', $target{bin_lflags} || ()) -}



PERL={- $config{perl} -}
@@ -848,6 +849,11 @@ EOF 
              die "Generator type for $args{src} unknown: $generator\n";

          }



          my $cppflags = {

              lib => '$(LIB_CPPFLAGS)',

              dso => '$(DSO_CPPFLAGS)',

              bin => '$(BIN_CPPFLAGS)'

          } -> {$args{intent}};

          if (defined($generator)) {

              # If the target is named foo.S in build.info, we want to

              # end up generating foo.s in two steps.
@@ -891,9 +897,9 @@ EOF 
      my $srcs = join(" ",  @srcs);

      my $deps = join(" ", @srcs, @{$args{deps}});

      my $incs = join("", map { " -I".$_ } @{$args{incs}});

      my $cmd = '$(CC)';

      my $cmdflags = '$(CFLAGS)';

      my $cmdcompile = ' -c';

      my $cmd;

      my $cmdflags;

      my $cmdcompile;

      my $makedepprog = $disabled{makedepend} ? undef : $config{makedepprog};

      if (grep /\.rc$/, @srcs) {

          $cmd = '$(RC)';
@@ -902,22 +908,20 @@ EOF 
          $makedepprog = undef;

      } elsif (grep /\.(cc|cpp)$/, @srcs) {

          $cmd = '$(CXX)';

          $cmdflags = '$(CXXFLAGS)';

          $cmdflags .= ' ' . { lib => '$(LIB_CXXFLAGS)',

                               dso => '$(DSO_CXXFLAGS)',

                               bin => '$(BIN_CXXFLAGS)' } -> {$args{intent}};

          $cmdflags .= ' $(CPPFLAGS)';

          $cmdflags .= ' ' . { lib => '$(LIB_CPPFLAGS)',

                               dso => '$(DSO_CPPFLAGS)',

                               bin => '$(BIN_CPPFLAGS)' } -> {$args{intent}};

          $cmdcompile = ' -c';

          $cmdflags = {

              lib => '$(LIB_CXXFLAGS) $(LIB_CPPFLAGS)',

              dso => '$(DSO_CXXFLAGS) $(DSO_CPPFLAGS)',

              bin => '$(BIN_CXXFLAGS) $(BIN_CPPFLAGS)'

          } -> {$args{intent}};

      } else {

          $cmdflags .= ' ' . { lib => '$(LIB_CFLAGS)',

                               dso => '$(DSO_CFLAGS)',

                               bin => '$(BIN_CFLAGS)' } -> {$args{intent}};

          $cmdflags .= ' $(CPPFLAGS)';

          $cmdflags .= ' ' . { lib => '$(LIB_CPPFLAGS)',

                               dso => '$(DSO_CPPFLAGS)',

                               bin => '$(BIN_CPPFLAGS)' } -> {$args{intent}};

          $cmd = '$(CC)';

          $cmdcompile = ' -c';

          $cmdflags = {

              lib => '$(LIB_CFLAGS) $(LIB_CPPFLAGS)',

              dso => '$(DSO_CFLAGS) $(DSO_CPPFLAGS)',

              bin => '$(BIN_CFLAGS) $(BIN_CPPFLAGS)'

          } -> {$args{intent}};

      }

      $cmdflags .= $cmdcompile;

      my $recipe = <<"EOF";
@@ -997,7 +1001,7 @@ EOF 
# simplest, {libname}\$(SHLIB_EXT_IMPORT) for Windows POSIX layers and

# {libname}\$(SHLIB_EXT_SIMPLE) for the Unix platforms.

$target: $deps

	\$(CC) \$(CFLAGS) \$(LIB_CFLAGS) $linkflags\$(LIB_LDFLAGS)$shared_soname$shared_imp \\

	\$(CC) \$(LIB_CFLAGS) $linkflags\$(LIB_LDFLAGS)$shared_soname$shared_imp \\

		-o $target_full$shared_def $objs \\

                \$(PLIB_LDFLAGS) $linklibs \$(EX_LIBS)

EOF
@@ -1040,7 +1044,7 @@ EOF 
      my $target = dso($dso);

      return <<"EOF";

$target: $objs $deps

	\$(CC) \$(CFLAGS) \$(DSO_CFLAGS) $linkflags\$(DSO_LDFLAGS) \\

	\$(CC) \$(DSO_CFLAGS) $linkflags\$(DSO_LDFLAGS) \\

		-o $target $objs \\

                \$(PLIB_LDFLAGS) $linklibs \$(EX_LIBS)

EOF
@@ -1080,15 +1084,15 @@ EOF 
                                    }

                                  } @{$args{deps}});

      my $cmd = '$(CC)';

      my $cmdflags = '$(CFLAGS) $(BIN_CFLAGS)';

      my $cmdflags = '$(BIN_CFLAGS)';

      if (grep /_cc\.o$/, @{$args{objs}}) {

          $cmd = '$(CXX)';

          $cmdflags = '$(CXXFLAGS) $(BIN_CXXFLAGS)';

          $cmdflags = '$(BIN_CXXFLAGS)';

      }

      return <<"EOF";

$bin$exeext: $objs $deps

	rm -f $bin$exeext

	\$\${LDCMD:-$cmd} $cmdflags $linkflags\$(LDFLAGS) \$(BIN_LDFLAGS) \\

	\$\${LDCMD:-$cmd} $cmdflags $linkflags\$(BIN_LDFLAGS) \\

		-o $bin$exeext $objs \\

		\$(PLIB_LDFLAGS) $linklibs \$(EX_LIBS)

EOF

Configurations/windows-makefile.tmpl

+21 −18
Original line number Diff line number Diff line
@@ -174,19 +174,20 @@ LD={- $config{ld} -} 
LDFLAGS={- join(' ', @{$config{lflags}}) -}

LDOUTFLAG={- $target{loutflag} || "/out:" -}$(OSSL_EMPTY)

EX_LIBS={- join(' ', @{$config{ex_libs}}) -}

LIB_CPPFLAGS={- join(" ",

                     $target{shared_cppflag} || "",



LIB_CPPFLAGS={- join(' ', '$(CPPFLAGS)',

                          $target{shared_cppflag} || (),

                          (map { quotify_l("-D".$_) }

                           "OPENSSLDIR=\"$openssldir\"",

                           "ENGINESDIR=\"$enginesdir\"")) -}

LIB_CFLAGS={- join(" ", $target{lib_cflags}, $target{shared_cflag}) -}

LIB_LDFLAGS={- join(' ', $target{shared_ldflag}, $config{shared_ldflag}) -}

DSO_CPPFLAGS={- $target{dso_cppflags} || "" -}

DSO_CFLAGS={- $target{dso_cflags} || "" -}

DSO_LDFLAGS={- $target{dso_ldflag} || "" -}

BIN_CPPFLAGS={- $target{dso_cppflags} || "" -}

BIN_CFLAGS={- $target{bin_cflags} -}

BIN_LDFLAGS={- $target{bin_lflags} -}

LIB_CFLAGS={- join(' ', '$(CFLAGS)', $target{lib_cflags} || (), $target{shared_cflag} || ()) -}

LIB_LDFLAGS={- join(' ', '$(LDFLAGS)', $target{shared_ldflag} || (), $config{shared_ldflag} || ()) -}

DSO_CPPFLAGS={- join(' ', '$(CPPFLAGS)', $target{dso_cppflags} || ()) -}

DSO_CFLAGS={- join(' ', '$(CFLAGS)', $target{dso_cflags} || ()) -}

DSO_LDFLAGS={- join(' ', '$(LDFLAGS)', $target{dso_ldflag} || ()) -}

BIN_CPPFLAGS={- join(' ', '$(CPPFLAGS)', $target{dso_cppflags} || ()) -}

BIN_CFLAGS={- join(' ', '$(CFLAGS)', $target{bin_cflags} || ()) -}

BIN_LDFLAGS={- join(' ', '$(LDFLAGS)', $target{bin_lflags} || ()) -}



PERL={- $config{perl} -}
@@ -434,6 +435,10 @@ EOF 
              die "Generator type for $src unknown: $generator\n";

          }



          my $cppflags = $incs;

          $cppflags .= { lib => '$(LIB_CPPFLAGS)',

                         dso => '$(DSO_CPPFLAGS)',

                         bin => '$(BIN_CPPFLAGS)' } -> {$args{intent}};

          if (defined($generator)) {

              # If the target is named foo.S in build.info, we want to

              # end up generating foo.s in two steps.
@@ -467,12 +472,10 @@ EOF 
     my $srcs = '"'.join('" "',  @srcs).'"';

     my $deps = '"'.join('" "', @srcs, @{$args{deps}}).'"';

     my $incs = join("", map { ' /I "'.$_.'"' } @{$args{incs}});

     my $cflags = '$(CFLAGS)';

     $cflags .= { lib => ' $(LIB_CFLAGS)',

     my $cflags = { lib => ' $(LIB_CFLAGS)',

		    dso => ' $(DSO_CFLAGS)',

		    bin => ' $(BIN_CFLAGS)' } -> {$args{intent}};

     $cflags .= $incs;

     $cflags .= ' $(CPPFLAGS)';

     $cflags .= { lib => ' $(LIB_CPPFLAGS)',

		  dso => ' $(DSO_CPPFLAGS)',

		  bin => ' $(BIN_CPPFLAGS)' } -> {$args{intent}};

crypto/aes/build.info

+3 −6
Original line number Diff line number Diff line
@@ -6,16 +6,13 @@ SOURCE[../../libcrypto]=\ 
GENERATE[aes-ia64.s]=asm/aes-ia64.S



GENERATE[aes-586.s]=asm/aes-586.pl \

        $(PERLASM_SCHEME) $(CFLAGS) $(LIB_CFLAGS) $(CPPFLAGS) $(LIB_CPPFLAGS) \

        $(PROCESSOR)

        $(PERLASM_SCHEME) $(LIB_CFLAGS) $(LIB_CPPFLAGS) $(PROCESSOR)

DEPEND[aes-586.s]=../perlasm/x86asm.pl

GENERATE[vpaes-x86.s]=asm/vpaes-x86.pl \

        $(PERLASM_SCHEME) $(CFLAGS) $(LIB_CFLAGS) $(CPPFLAGS) $(LIB_CPPFLAGS) \

        $(PROCESSOR)

        $(PERLASM_SCHEME) $(LIB_CFLAGS) $(LIB_CPPFLAGS) $(PROCESSOR)

DEPEND[vpaes-586.s]=../perlasm/x86asm.pl

GENERATE[aesni-x86.s]=asm/aesni-x86.pl \

        $(PERLASM_SCHEME) $(CFLAGS) $(LIB_CFLAGS) $(CPPFLAGS) $(LIB_CPPFLAGS) \

        $(PROCESSOR)

        $(PERLASM_SCHEME) $(LIB_CFLAGS) $(LIB_CPPFLAGS) $(PROCESSOR)

DEPEND[aesni-586.s]=../perlasm/x86asm.pl



GENERATE[aes-x86_64.s]=asm/aes-x86_64.pl $(PERLASM_SCHEME)

crypto/bf/build.info

+1 −2
Original line number Diff line number Diff line
@@ -3,6 +3,5 @@ SOURCE[../../libcrypto]=bf_skey.c bf_ecb.c bf_cfb64.c bf_ofb64.c \ 
        {- $target{bf_asm_src} -}



GENERATE[bf-586.s]=asm/bf-586.pl \

        $(PERLASM_SCHEME) $(CFLAGS) $(LIB_CFLAGS) $(CPPFLAGS) $(LIB_CPPFLAGS) \

        $(PROCESSOR)

        $(PERLASM_SCHEME) $(LIB_CFLAGS) $(LIB_CPPFLAGS) $(PROCESSOR)

DEPEND[bf-586.s]=../perlasm/x86asm.pl ../perlasm/cbc.pl