Configurations/gentemplate.pm

   1 package gentemplate;
   2
   3 use strict;
   4 use warnings;
   5 use Carp;
   6
   7 use Exporter;
   8 use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
   9 @ISA = qw(Exporter);
  10 @EXPORT = qw(gentemplate);
  11
  12 use File::Basename;
  13
  14 sub gentemplate {
  15     my %opts = @_;
  16
  17     my $generator = OpenSSL::GenTemplate->new(%opts);
  18
  19     # Build mandatory header file generators
  20     foreach (@{$generator->{info}->{depends}->{""}}) { $generator->dogenerate($_); }
  21
  22     # Build all known targets, libraries, modules, programs and scripts.
  23     # Everything else will be handled as a consequence.
  24     foreach (@{$generator->{info}->{targets}})   { $generator->dotarget($_); }
  25     foreach (@{$generator->{info}->{libraries}}) { $generator->dolib($_);    }
  26     foreach (@{$generator->{info}->{modules}})   { $generator->domodule($_); }
  27     foreach (@{$generator->{info}->{programs}})  { $generator->dobin($_);    }
  28     foreach (@{$generator->{info}->{scripts}})   { $generator->doscript($_); }
  29     foreach (sort keys %{$generator->{info}->{htmldocs}}) { $generator->dodocs('html', $_); }
  30     foreach (sort keys %{$generator->{info}->{mandocs}})  { $generator->dodocs('man', $_); }
  31     foreach (sort keys %{$generator->{info}->{dirinfo}})  { $generator->dodir($_); }
  32 }
  33
  34 package OpenSSL::GenTemplate;
  35
  36 use OpenSSL::Util;
  37
  38 sub new {
  39     my $class = shift;
  40     my %opts = @_;
  41
  42     my $data = {
  43         output   => $opts{output},
  44         config   => $opts{config} // {},
  45         disabled => $opts{disabled} // {},
  46         info     => $opts{unified_info} // {},
  47     };
  48
  49     return bless $data, $class;
  50 };
  51
  52 sub emit {
  53     my $self = shift;
  54     my $name = shift;
  55     my %opts = @_;
  56     my $fh = $self->{output};
  57
  58     die "No name?" unless $name;
  59     print $fh "{-\n ", $name, '(', dump_data(\%opts), ');', " \n-}";
  60 }
  61
  62 my $debug_resolvedepends = $ENV{BUILDFILE_DEBUG_DEPENDS};
  63 my $debug_rules = $ENV{BUILDFILE_DEBUG_RULES};
  64
  65 # A cache of objects for which a recipe has already been generated
  66 our %cache;
  67
  68 # collectdepends, expanddepends and reducedepends work together to make
  69 # sure there are no duplicate or weak dependencies and that they are in
  70 # the right order.  This is used to sort the list of libraries  that a
  71 # build depends on.
  72 sub extensionlesslib {
  73     my @result = map { $_ =~ /(\.a)?$/; $` } @_;
  74     return @result if wantarray;
  75     return $result[0];
  76 }
  77
  78 # collectdepends dives into the tree of dependencies and returns
  79 # a list of all the non-weak ones.
  80 sub collectdepends {
  81     my $self = shift;
  82     return () unless @_;
  83
  84     my $thing = shift;
  85     my $extensionlessthing = extensionlesslib($thing);
  86     my @listsofar = @_;    # to check if we're looping
  87     my @list = @{ $self->{info}->{depends}->{$thing} //
  88                   $self->{info}->{depends}->{$extensionlessthing}
  89                   // [] };
  90     my @newlist = ();
  91
  92     print STDERR "DEBUG[collectdepends] $thing > ", join(' ', @listsofar), "\n"
  93         if $debug_resolvedepends;
  94     foreach my $item (@list) {
  95         my $extensionlessitem = extensionlesslib($item);
  96         # It's time to break off when the dependency list starts looping
  97         next if grep { extensionlesslib($_) eq $extensionlessitem } @listsofar;
  98         # Don't add anything here if the dependency is weak
  99         next if defined $self->{info}->{attributes}->{depends}->{$thing}->{$item}->{'weak'};
 100         my @resolved = $self->collectdepends($item, @listsofar, $item);
 101         push @newlist, $item, @resolved;
 102     }
 103     print STDERR "DEBUG[collectdepends] $thing < ", join(' ', @newlist), "\n"
 104         if $debug_resolvedepends;
 105     @newlist;
 106 }
 107
 108 # expanddepends goes through a list of stuff, checks if they have any
 109 # dependencies, and adds them at the end of the current position if
 110 # they aren't already present later on.
 111 sub expanddepends {
 112     my $self = shift;
 113     my @after = ( @_ );
 114     print STDERR "DEBUG[expanddepends]> ", join(' ', @after), "\n"
 115         if $debug_resolvedepends;
 116     my @before = ();
 117     while (@after) {
 118         my $item = shift @after;
 119         print STDERR "DEBUG[expanddepends]\\  ", join(' ', @before), "\n"
 120             if $debug_resolvedepends;
 121         print STDERR "DEBUG[expanddepends] - ", $item, "\n"
 122             if $debug_resolvedepends;
 123         my @middle = (
 124             $item,
 125             map {
 126                 my $x = $_;
 127                 my $extlessx = extensionlesslib($x);
 128                 if (grep { $extlessx eq extensionlesslib($_) } @before
 129                     and
 130                     !grep { $extlessx eq extensionlesslib($_) } @after) {
 131                     print STDERR "DEBUG[expanddepends] + ", $x, "\n"
 132                         if $debug_resolvedepends;
 133                     ( $x )
 134                 } else {
 135                     print STDERR "DEBUG[expanddepends] ! ", $x, "\n"
 136                         if $debug_resolvedepends;
 137                     ()
 138                 }
 139             } @{$self->{info}->{depends}->{$item} // []}
 140             );
 141         print STDERR "DEBUG[expanddepends] = ", join(' ', @middle), "\n"
 142             if $debug_resolvedepends;
 143         print STDERR "DEBUG[expanddepends]/  ", join(' ', @after), "\n"
 144             if $debug_resolvedepends;
 145         push @before, @middle;
 146     }
 147     print STDERR "DEBUG[expanddepends]< ", join(' ', @before), "\n"
 148         if $debug_resolvedepends;
 149     @before;
 150 }
 151
 152 # reducedepends looks through a list, and checks if each item is
 153 # repeated later on.  If it is, the earlier copy is dropped.
 154 sub reducedepends {
 155     my @list = @_;
 156     print STDERR "DEBUG[reducedepends]> ", join(' ', @list), "\n"
 157         if $debug_resolvedepends;
 158     my @newlist = ();
 159     my %replace = ();
 160     while (@list) {
 161         my $item = shift @list;
 162         my $extensionlessitem = extensionlesslib($item);
 163         if (grep { $extensionlessitem eq extensionlesslib($_) } @list) {
 164             if ($item ne $extensionlessitem) {
 165                 # If this instance of the library is explicitly static, we
 166                 # prefer that to any shared library name, since it must have
 167                 # been done on purpose.
 168                 $replace{$extensionlessitem} = $item;
 169             }
 170         } else {
 171             push @newlist, $item;
 172         }
 173     }
 174     @newlist = map { $replace{$_} // $_; } @newlist;
 175     print STDERR "DEBUG[reducedepends]< ", join(' ', @newlist), "\n"
 176         if $debug_resolvedepends;
 177     @newlist;
 178 }
 179
 180 # Do it all
 181 # This takes multiple inputs and combine them into a single list of
 182 # interdependent things.  The returned value will include all the input.
 183 # Callers are responsible for taking away the things they are building.
 184 sub resolvedepends {
 185     my $self = shift;
 186     print STDERR "DEBUG[resolvedepends] START (", join(', ', @_), ")\n"
 187         if $debug_resolvedepends;
 188     my @all =
 189         reducedepends($self->expanddepends(map { ( $_, $self->collectdepends($_) ) } @_));
 190     print STDERR "DEBUG[resolvedepends] END (", join(', ', @_), ") : ",
 191         join(',', map { "\n    $_" } @all), "\n"
 192         if $debug_resolvedepends;
 193     @all;
 194 }
 195
 196 # dogenerate is responsible for producing all the recipes that build
 197 # generated source files.  It recurses in case a dependency is also a
 198 # generated source file.
 199 sub dogenerate {
 200     my $self = shift;
 201     my $src = shift;
 202     # Safety measure
 203     return "" unless defined $self->{info}->{generate}->{$_};
 204     return "" if $cache{$src};
 205     my $obj = shift;
 206     my $bin = shift;
 207     my %opts = @_;
 208     if ($self->{info}->{generate}->{$src}) {
 209         die "$src is generated by Configure, should not appear in build file\n"
 210             if ref $self->{info}->{generate}->{$src} eq "";
 211         my $script = $self->{info}->{generate}->{$src}->[0];
 212         $self->emit('generatesrc',
 213              src => $src,
 214              product => $bin,
 215              generator => $self->{info}->{generate}->{$src},
 216              generator_incs => $self->{info}->{includes}->{$script} // [],
 217              generator_deps => $self->{info}->{depends}->{$script} // [],
 218              deps => $self->{info}->{depends}->{$src} // [],
 219              incs => [ defined $obj ? @{$self->{info}->{includes}->{$obj} // []} : (),
 220                        defined $bin ? @{$self->{info}->{includes}->{$bin} // []} : () ],
 221              defs => [ defined $obj ? @{$self->{info}->{defines}->{$obj} // []} : (),
 222                        defined $bin ? @{$self->{info}->{defines}->{$bin} // []} : () ],
 223              %opts);
 224         foreach (@{$self->{info}->{depends}->{$src} // []}) {
 225             $self->dogenerate($_, $obj, $bin, %opts);
 226         }
 227     }
 228     $cache{$src} = 1;
 229 }
 230
 231 sub dotarget {
 232     my $self = shift;
 233     my $target = shift;
 234     return "" if $cache{$target};
 235     $self->emit('generatetarget',
 236          target => $target,
 237          deps => $self->{info}->{depends}->{$target} // []);
 238     foreach (@{$self->{info}->{depends}->{$target} // []}) {
 239         $self->dogenerate($_);
 240     }
 241     $cache{$target} = 1;
 242 }
 243
 244 # doobj is responsible for producing all the recipes that build
 245 # object files as well as dependency files.
 246 sub doobj {
 247     my $self = shift;
 248     my $obj = shift;
 249     return "" if $cache{$obj};
 250     my $bin = shift;
 251     my %opts = @_;
 252     if (@{$self->{info}->{sources}->{$obj} // []}) {
 253         my @srcs = @{$self->{info}->{sources}->{$obj}};
 254         my @deps = @{$self->{info}->{depends}->{$obj} // []};
 255         my @incs = ( @{$self->{info}->{includes}->{$obj} // []},
 256                      @{$self->{info}->{includes}->{$bin} // []} );
 257         my @defs = ( @{$self->{info}->{defines}->{$obj} // []},
 258                      @{$self->{info}->{defines}->{$bin} // []} );
 259         print STDERR "DEBUG[doobj] \@srcs for $obj ($bin) : ",
 260             join(",", map { "\n    $_" } @srcs), "\n"
 261             if $debug_rules;
 262         print STDERR "DEBUG[doobj] \@deps for $obj ($bin) : ",
 263             join(",", map { "\n    $_" } @deps), "\n"
 264             if $debug_rules;
 265         print STDERR "DEBUG[doobj] \@incs for $obj ($bin) : ",
 266             join(",", map { "\n    $_" } @incs), "\n"
 267             if $debug_rules;
 268         print STDERR "DEBUG[doobj] \@defs for $obj ($bin) : ",
 269             join(",", map { "\n    $_" } @defs), "\n"
 270             if $debug_rules;
 271         print STDERR "DEBUG[doobj] \%opts for $obj ($bin) : ", ,
 272             join(",", map { "\n    $_ = $opts{$_}" } sort keys %opts), "\n"
 273             if $debug_rules;
 274         $self->emit('src2obj',
 275              obj => $obj, product => $bin,
 276              srcs => [ @srcs ], deps => [ @deps ],
 277              incs => [ @incs ], defs => [ @defs ],
 278              %opts);
 279         foreach ((@{$self->{info}->{sources}->{$obj}},
 280                   @{$self->{info}->{depends}->{$obj} // []})) {
 281             $self->dogenerate($_, $obj, $bin, %opts);
 282         }
 283     }
 284     $cache{$obj} = 1;
 285 }
 286
 287 # Helper functions to grab all applicable intermediary files.
 288 # This is particularly useful when a library is given as source
 289 # rather than a dependency.  In that case, we consider it to be a
 290 # container with object file references, or possibly references
 291 # to further libraries to pilfer in the same way.
 292 sub getsrclibs {
 293     my $self = shift;
 294     my $section = shift;
 295
 296     # For all input, see if it sources static libraries.  If it does,
 297     # return them together with the result of a recursive call.
 298     map { ( $_, getsrclibs($section, $_) ) }
 299     grep { $_ =~ m|\.a$| }
 300     map { @{$self->{info}->{$section}->{$_} // []} }
 301     @_;
 302 }
 303
 304 sub getlibobjs {
 305     my $self = shift;
 306     my $section = shift;
 307
 308     # For all input, see if it's an intermediary file (library or object).
 309     # If it is, collect the result of a recursive call, or if that returns
 310     # an empty list, the element itself.  Return the result.
 311     map {
 312         my @x = $self->getlibobjs($section, @{$self->{info}->{$section}->{$_}});
 313         @x ? @x : ( $_ );
 314     }
 315     grep { defined $self->{info}->{$section}->{$_} }
 316     @_;
 317 }
 318
 319 # dolib is responsible for building libraries.  It will call
 320 # obj2shlib if shared libraries are produced, and obj2lib in all
 321 # cases.  It also makes sure all object files for the library are
 322 # built.
 323 sub dolib {
 324     my $self = shift;
 325     my $lib = shift;
 326     return "" if $cache{$lib};
 327
 328     my %attrs = %{$self->{info}->{attributes}->{libraries}->{$lib} // {}};
 329
 330     my @deps = ( $self->resolvedepends(getsrclibs('sources', $lib)) );
 331
 332     # We support two types of objs, those who are specific to this library
 333     # (they end up in @objs) and those that we get indirectly, via other
 334     # libraries (they end up in @foreign_objs).  We get the latter any time
 335     # someone has done something like this in build.info:
 336     #     SOURCE[libfoo.a]=libbar.a
 337     # The indirect object files must be kept in a separate array so they
 338     # don't get rebuilt unnecessarily (and with incorrect auxiliary
 339     # information).
 340     #
 341     # Object files can't be collected commonly for shared and static
 342     # libraries, because we contain their respective object files in
 343     # {shared_sources} and {sources}, and because the implications are
 344     # slightly different for each library form.
 345     #
 346     # We grab all these "foreign" object files recursively with getlibobjs().
 347
 348     unless ($self->{disabled}->{shared} || $lib =~ /\.a$/) {
 349         # If this library sources other static libraries and those
 350         # libraries are marked {noinst}, there's no need to include
 351         # all of their object files.  Instead, we treat those static
 352         # libraries as dependents alongside any other library this
 353         # one depends on, and let symbol resolution do its job.
 354         my @sourced_libs = ();
 355         my @objs = ();
 356         my @foreign_objs = ();
 357         my @deps = ();
 358         foreach (@{$self->{info}->{shared_sources}->{$lib} // []}) {
 359             if ($_ !~ m|\.a$|) {
 360                 push @objs, $_;
 361             } elsif ($self->{info}->{attributes}->{libraries}->{$_}->{noinst}) {
 362                 push @deps, $_;
 363             } else {
 364                 push @deps, $self->getsrclibs('sources', $_);
 365                 push @foreign_objs, $self->getlibobjs('sources', $_);
 366             }
 367         }
 368         @deps = ( grep { $_ ne $lib } $self->resolvedepends($lib, @deps) );
 369         print STDERR "DEBUG[dolib:shlib] \%attrs for $lib : ", ,
 370             join(",", map { "\n    $_ = $attrs{$_}" } sort keys %attrs), "\n"
 371             if %attrs && $debug_rules;
 372         print STDERR "DEBUG[dolib:shlib] \@deps for $lib : ",
 373             join(",", map { "\n    $_" } @deps), "\n"
 374             if @deps && $debug_rules;
 375         print STDERR "DEBUG[dolib:shlib] \@objs for $lib : ",
 376             join(",", map { "\n    $_" } @objs), "\n"
 377             if @objs && $debug_rules;
 378         print STDERR "DEBUG[dolib:shlib] \@foreign_objs for $lib : ",
 379             join(",", map { "\n    $_" } @foreign_objs), "\n"
 380             if @foreign_objs && $debug_rules;
 381         $self->emit('obj2shlib',
 382              lib => $lib,
 383              attrs => { %attrs },
 384              objs => [ @objs, @foreign_objs ],
 385              deps => [ @deps ]);
 386         foreach (@objs) {
 387             # If this is somehow a compiled object, take care of it that way
 388             # Otherwise, it might simply be generated
 389             if (defined $self->{info}->{sources}->{$_}) {
 390                 if($_ =~ /\.a$/) {
 391                     $self->dolib($_);
 392                 } else {
 393                     $self->doobj($_, $lib, intent => "shlib", attrs => { %attrs });
 394                 }
 395             } else {
 396                 $self->dogenerate($_, undef, undef, intent => "lib");
 397             }
 398         }
 399     }
 400     {
 401         # When putting static libraries together, we cannot rely on any
 402         # symbol resolution, so for all static libraries used as source for
 403         # this one, as well as other libraries they depend on, we simply
 404         # grab all their object files unconditionally,
 405         # Symbol resolution will happen when any program, module or shared
 406         # library is linked with this one.
 407         my @objs = ();
 408         my @sourcedeps = ();
 409         my @foreign_objs = ();
 410         foreach (@{$self->{info}->{sources}->{$lib}}) {
 411             if ($_ !~ m|\.a$|) {
 412                 push @objs, $_;
 413             } else {
 414                 push @sourcedeps, $_;
 415             }
 416         }
 417         @sourcedeps = ( grep { $_ ne $lib } $self->resolvedepends(@sourcedeps) );
 418         print STDERR "DEBUG[dolib:lib] : \@sourcedeps for $_ : ",
 419             join(",", map { "\n    $_" } @sourcedeps), "\n"
 420             if @sourcedeps && $debug_rules;
 421         @foreign_objs = $self->getlibobjs('sources', @sourcedeps);
 422         print STDERR "DEBUG[dolib:lib] \%attrs for $lib : ", ,
 423             join(",", map { "\n    $_ = $attrs{$_}" } sort keys %attrs), "\n"
 424             if %attrs && $debug_rules;
 425         print STDERR "DEBUG[dolib:lib] \@objs for $lib : ",
 426             join(",", map { "\n    $_" } @objs), "\n"
 427             if @objs && $debug_rules;
 428         print STDERR "DEBUG[dolib:lib] \@foreign_objs for $lib : ",
 429             join(",", map { "\n    $_" } @foreign_objs), "\n"
 430             if @foreign_objs && $debug_rules;
 431         $self->emit('obj2lib',
 432              lib => $lib, attrs => { %attrs },
 433              objs => [ @objs, @foreign_objs ]);
 434         foreach (@objs) {
 435             $self->doobj($_, $lib, intent => "lib", attrs => { %attrs });
 436         }
 437     }
 438     $cache{$lib} = 1;
 439 }
 440
 441 # domodule is responsible for building modules.  It will call
 442 # obj2dso, and also makes sure all object files for the library
 443 # are built.
 444 sub domodule {
 445     my $self = shift;
 446     my $module = shift;
 447     return "" if $cache{$module};
 448     my %attrs = %{$self->{info}->{attributes}->{modules}->{$module} // {}};
 449     my @objs = @{$self->{info}->{sources}->{$module}};
 450     my @deps = ( grep { $_ ne $module }
 451                  $self->resolvedepends($module) );
 452     print STDERR "DEBUG[domodule] \%attrs for $module :",
 453         join(",", map { "\n    $_ = $attrs{$_}" } sort keys %attrs), "\n"
 454         if $debug_rules;
 455     print STDERR "DEBUG[domodule] \@objs for $module : ",
 456         join(",", map { "\n    $_" } @objs), "\n"
 457         if $debug_rules;
 458     print STDERR "DEBUG[domodule] \@deps for $module : ",
 459         join(",", map { "\n    $_" } @deps), "\n"
 460         if $debug_rules;
 461     $self->emit('obj2dso',
 462          module => $module,
 463          attrs => { %attrs },
 464          objs => [ @objs ],
 465          deps => [ @deps ]);
 466     foreach (@{$self->{info}->{sources}->{$module}}) {
 467         # If this is somehow a compiled object, take care of it that way
 468         # Otherwise, it might simply be generated
 469         if (defined $self->{info}->{sources}->{$_}) {
 470             $self->doobj($_, $module, intent => "dso", attrs => { %attrs });
 471         } else {
 472             $self->dogenerate($_, undef, $module, intent => "dso");
 473         }
 474     }
 475     $cache{$module} = 1;
 476 }
 477
 478 # dobin is responsible for building programs.  It will call obj2bin,
 479 # and also makes sure all object files for the library are built.
 480 sub dobin {
 481     my $self = shift;
 482     my $bin = shift;
 483     return "" if $cache{$bin};
 484     my %attrs = %{$self->{info}->{attributes}->{programs}->{$bin} // {}};
 485     my @objs = @{$self->{info}->{sources}->{$bin}};
 486     my @deps = ( grep { $_ ne $bin } $self->resolvedepends($bin) );
 487     print STDERR "DEBUG[dobin] \%attrs for $bin : ",
 488         join(",", map { "\n    $_ = $attrs{$_}" } sort keys %attrs), "\n"
 489         if %attrs && $debug_rules;
 490     print STDERR "DEBUG[dobin] \@objs for $bin : ",
 491         join(",", map { "\n    $_" } @objs), "\n"
 492         if @objs && $debug_rules;
 493     print STDERR "DEBUG[dobin] \@deps for $bin : ",
 494         join(",", map { "\n    $_" } @deps), "\n"
 495         if @deps && $debug_rules;
 496     $self->emit('obj2bin',
 497          bin => $bin,
 498          attrs => { %attrs },
 499          objs => [ @objs ],
 500          deps => [ @deps ]);
 501     foreach (@objs) {
 502         $self->doobj($_, $bin, intent => "bin", attrs => { %attrs });
 503     }
 504     $cache{$bin} = 1;
 505 }
 506
 507 # doscript is responsible for building scripts from templates.  It will
 508 # call in2script.
 509 sub doscript {
 510     my $self = shift;
 511     my $script = shift;
 512     return "" if $cache{$script};
 513     $self->emit('in2script',
 514          script => $script,
 515          attrs => $self->{info}->{attributes}->{scripts}->{$script} // {},
 516          sources => $self->{info}->{sources}->{$script});
 517     $cache{$script} = 1;
 518 }
 519
 520 sub dodir {
 521     my $self = shift;
 522     my $dir = shift;
 523     return "" if !exists(&generatedir) or $cache{$dir};
 524     $self->emit('generatedir',
 525          dir => $dir,
 526          deps => $self->{info}->{dirinfo}->{$dir}->{deps} // [],
 527          %{$self->{info}->{dirinfo}->{$_}->{products}});
 528     $cache{$dir} = 1;
 529 }
 530
 531 # dodocs is responsible for building documentation from .pods.
 532 # It will call generatesrc.
 533 sub dodocs {
 534     my $self = shift;
 535     my $type = shift;
 536     my $section = shift;
 537     foreach my $doc (@{$self->{info}->{"${type}docs"}->{$section}}) {
 538         next if $cache{$doc};
 539         $self->emit('generatesrc',
 540              src => $doc,
 541              generator => $self->{info}->{generate}->{$doc});
 542         foreach ((@{$self->{info}->{depends}->{$doc} // []})) {
 543             $self->dogenerate($_, undef, undef);
 544         }
 545         $cache{$doc} = 1;
 546     }
 547 }
 548
 549 1;