4999a3660419128c226de2e77764e92ce086aece
[openssl.git] / Configurations / common.tmpl
1 {- # -*- Mode: perl -*-
2
3  use File::Basename;
4
5  my $debug_resolvedepends = $ENV{BUILDFILE_DEBUG_DEPENDS};
6  my $debug_rules = $ENV{BUILDFILE_DEBUG_RULES};
7
8  # A cache of objects for which a recipe has already been generated
9  my %cache;
10
11  # collectdepends, expanddepends and reducedepends work together to make
12  # sure there are no duplicate or weak dependencies and that they are in
13  # the right order.  This is used to sort the list of libraries  that a
14  # build depends on.
15  sub extensionlesslib {
16      my @result = map { $_ =~ /(\.a)?$/; $` } @_;
17      return @result if wantarray;
18      return $result[0];
19  }
20
21  # collectdepends dives into the tree of dependencies and returns
22  # a list of all the non-weak ones.
23  sub collectdepends {
24      return () unless @_;
25
26      my $thing = shift;
27      my $extensionlessthing = extensionlesslib($thing);
28      my @listsofar = @_;    # to check if we're looping
29      my @list = @{$unified_info{depends}->{$thing} //
30                       $unified_info{depends}->{$extensionlessthing}};
31      my @newlist = ();
32
33      print STDERR "DEBUG[collectdepends] $thing > ", join(' ', @listsofar), "\n"
34          if $debug_resolvedepends;
35      foreach my $item (@list) {
36          my $extensionlessitem = extensionlesslib($item);
37          # It's time to break off when the dependency list starts looping
38          next if grep { extensionlesslib($_) eq $extensionlessitem } @listsofar;
39          # Don't add anything here if the dependency is weak
40          next if defined $unified_info{attributes}->{depends}->{$thing}->{$item}->{'weak'};
41          my @resolved = collectdepends($item, @listsofar, $item);
42          push @newlist, $item, @resolved;
43      }
44      print STDERR "DEBUG[collectdepends] $thing < ", join(' ', @newlist), "\n"
45          if $debug_resolvedepends;
46      @newlist;
47  }
48
49  # expanddepends goes through a list of stuff, checks if they have any
50  # dependencies, and adds them at the end of the current position if
51  # they aren't already present later on.
52  sub expanddepends {
53      my @after = ( @_ );
54      print STDERR "DEBUG[expanddepends]> ", join(' ', @after), "\n"
55          if $debug_resolvedepends;
56      my @before = ();
57      while (@after) {
58          my $item = shift @after;
59          print STDERR "DEBUG[expanddepends]\\  ", join(' ', @before), "\n"
60              if $debug_resolvedepends;
61          print STDERR "DEBUG[expanddepends] - ", $item, "\n"
62              if $debug_resolvedepends;
63          my @middle = (
64              $item,
65              map {
66                  my $x = $_;
67                  my $extlessx = extensionlesslib($x);
68                  if (grep { $extlessx eq extensionlesslib($_) } @before
69                      and
70                      !grep { $extlessx eq extensionlesslib($_) } @after) {
71                      print STDERR "DEBUG[expanddepends] + ", $x, "\n"
72                          if $debug_resolvedepends;
73                      ( $x )
74                  } else {
75                      print STDERR "DEBUG[expanddepends] ! ", $x, "\n"
76                          if $debug_resolvedepends;
77                      ()
78                  }
79              } @{$unified_info{depends}->{$item} // []}
80          );
81          print STDERR "DEBUG[expanddepends] = ", join(' ', @middle), "\n"
82              if $debug_resolvedepends;
83          print STDERR "DEBUG[expanddepends]/  ", join(' ', @after), "\n"
84              if $debug_resolvedepends;
85          push @before, @middle;
86      }
87      print STDERR "DEBUG[expanddepends]< ", join(' ', @before), "\n"
88          if $debug_resolvedepends;
89      @before;
90  }
91
92  # reducedepends looks through a list, and checks if each item is
93  # repeated later on.  If it is, the earlier copy is dropped.
94  sub reducedepends {
95      my @list = @_;
96      print STDERR "DEBUG[reducedepends]> ", join(' ', @list), "\n"
97          if $debug_resolvedepends;
98      my @newlist = ();
99      my %replace = ();
100      while (@list) {
101          my $item = shift @list;
102          my $extensionlessitem = extensionlesslib($item);
103          if (grep { $extensionlessitem eq extensionlesslib($_) } @list) {
104              if ($item ne $extensionlessitem) {
105                  # If this instance of the library is explicitly static, we
106                  # prefer that to any shared library name, since it must have
107                  # been done on purpose.
108                  $replace{$extensionlessitem} = $item;
109              }
110          } else {
111              push @newlist, $item;
112          }
113      }
114      @newlist = map { $replace{$_} // $_; } @newlist;
115      print STDERR "DEBUG[reducedepends]< ", join(' ', @newlist), "\n"
116          if $debug_resolvedepends;
117      @newlist;
118  }
119
120  # Do it all
121  # This takes multiple inputs and combine them into a single list of
122  # interdependent things.  The returned value will include all the input.
123  # Callers are responsible for taking away the things they are building.
124  sub resolvedepends {
125      print STDERR "DEBUG[resolvedepends] START (", join(', ', @_), ")\n"
126          if $debug_resolvedepends;
127      my @all =
128          reducedepends(expanddepends(map { ( $_, collectdepends($_) ) } @_));
129      print STDERR "DEBUG[resolvedepends] END (", join(', ', @_), ") : ",
130          join(',', map { "\n    $_" } @all), "\n"
131          if $debug_resolvedepends;
132      @all;
133  }
134
135  # dogenerate is responsible for producing all the recipes that build
136  # generated source files.  It recurses in case a dependency is also a
137  # generated source file.
138  sub dogenerate {
139      my $src = shift;
140      return "" if $cache{$src};
141      my $obj = shift;
142      my $bin = shift;
143      my %opts = @_;
144      if ($unified_info{generate}->{$src}) {
145          die "$src is generated by Configure, should not appear in build file\n"
146              if ref $unified_info{generate}->{$src} eq "";
147          my $script = $unified_info{generate}->{$src}->[0];
148          $OUT .= generatesrc(src => $src,
149                              product => $bin,
150                              generator => $unified_info{generate}->{$src},
151                              generator_incs => $unified_info{includes}->{$script},
152                              generator_deps => $unified_info{depends}->{$script},
153                              deps => $unified_info{depends}->{$src},
154                              incs => [ @{$unified_info{includes}->{$obj}},
155                                        @{$unified_info{includes}->{$bin}} ],
156                              defs => [ @{$unified_info{defines}->{$obj}},
157                                        @{$unified_info{defines}->{$bin}} ],
158                              %opts);
159          foreach (@{$unified_info{depends}->{$src}}) {
160              dogenerate($_, $obj, $bin, %opts);
161          }
162      }
163      $cache{$src} = 1;
164  }
165
166  # doobj is responsible for producing all the recipes that build
167  # object files as well as dependency files.
168  sub doobj {
169      my $obj = shift;
170      return "" if $cache{$obj};
171      my $bin = shift;
172      my %opts = @_;
173      if (@{$unified_info{sources}->{$obj}}) {
174          $OUT .= src2obj(obj => $obj,
175                          product => $bin,
176                          srcs => $unified_info{sources}->{$obj},
177                          deps => $unified_info{depends}->{$obj},
178                          incs => [ @{$unified_info{includes}->{$obj}},
179                                    @{$unified_info{includes}->{$bin}} ],
180                          defs => [ @{$unified_info{defines}->{$obj}},
181                                    @{$unified_info{defines}->{$bin}} ],
182                          %opts);
183          foreach ((@{$unified_info{sources}->{$obj}},
184                    @{$unified_info{depends}->{$obj}})) {
185              dogenerate($_, $obj, $bin, %opts);
186          }
187      }
188      $cache{$obj} = 1;
189  }
190
191  # dolib is responsible for building libraries.  It will call
192  # obj2shlib is shared libraries are produced, and obj2lib in all
193  # cases.  It also makes sure all object files for the library are
194  # built.
195  sub dolib {
196      my $lib = shift;
197      return "" if $cache{$lib};
198      unless ($disabled{shared} || $lib =~ /\.a$/) {
199          my $obj2shlib = defined &obj2shlib ? \&obj2shlib : \&libobj2shlib;
200          $OUT .= $obj2shlib->(lib => $lib,
201                               attrs => $unified_info{attributes}->{libraries}->{$lib},
202                               objs => $unified_info{shared_sources}->{$lib},
203                               deps => [ grep { $_ ne $lib } resolvedepends($lib) ]);
204          foreach ((@{$unified_info{shared_sources}->{$lib}},
205                    @{$unified_info{sources}->{$lib}})) {
206              # If this is somehow a compiled object, take care of it that way
207              # Otherwise, it might simply be generated
208              if (defined $unified_info{sources}->{$_}) {
209                  doobj($_, $lib, intent => "shlib",
210                        attrs => $unified_info{attributes}->{libraries}->{$lib});
211              } else {
212                  dogenerate($_, undef, undef, intent => "lib");
213              }
214          }
215      }
216      $OUT .= obj2lib(lib => $lib,
217                      attrs => $unified_info{attributes}->{libraries}->{$lib},
218                      objs => [ @{$unified_info{sources}->{$lib}} ]);
219      foreach (@{$unified_info{sources}->{$lib}}) {
220          doobj($_, $lib, intent => "lib",
221                attrs => $unified_info{attributes}->{libraries}->{$lib});
222      }
223      $cache{$lib} = 1;
224  }
225
226  # domodule is responsible for building modules.  It will call
227  # obj2dso, and also makes sure all object files for the library
228  # are built.
229  sub domodule {
230      my $module = shift;
231      return "" if $cache{$module};
232      $OUT .= obj2dso(module => $module,
233                      attrs => $unified_info{attributes}->{modules}->{$module},
234                      objs => $unified_info{sources}->{$module},
235                      deps => [ grep { $_ ne $module }
236                                resolvedepends($module) ]);
237      foreach (@{$unified_info{sources}->{$module}}) {
238          # If this is somehow a compiled object, take care of it that way
239          # Otherwise, it might simply be generated
240          if (defined $unified_info{sources}->{$_}) {
241              doobj($_, $module, intent => "dso",
242                    attrs => $unified_info{attributes}->{modules}->{$module});
243          } else {
244              dogenerate($_, undef, $module, intent => "dso");
245          }
246      }
247      $cache{$module} = 1;
248  }
249
250  # dobin is responsible for building programs.  It will call obj2bin,
251  # and also makes sure all object files for the library are built.
252  sub dobin {
253      my $bin = shift;
254      return "" if $cache{$bin};
255      $OUT .= obj2bin(bin => $bin,
256                      attrs => $unified_info{attributes}->{programs}->{$bin},
257                      objs => [ @{$unified_info{sources}->{$bin}} ],
258                      deps => [ grep { $_ ne $bin } resolvedepends($bin) ]);
259      foreach (@{$unified_info{sources}->{$bin}}) {
260          doobj($_, $bin, intent => "bin",
261                attrs => $unified_info{attributes}->{$bin});
262      }
263      $cache{$bin} = 1;
264  }
265
266  # dobin is responsible for building scripts from templates.  It will
267  # call in2script.
268  sub doscript {
269      my $script = shift;
270      return "" if $cache{$script};
271      $OUT .= in2script(script => $script,
272                        attrs => $unified_info{attributes}->{$script},
273                        sources => $unified_info{sources}->{$script});
274      $cache{$script} = 1;
275  }
276
277  sub dodir {
278      my $dir = shift;
279      return "" if !exists(&generatedir) or $cache{$dir};
280      $OUT .= generatedir(dir => $dir,
281                          deps => $unified_info{dirinfo}->{$dir}->{deps},
282                          %{$unified_info{dirinfo}->{$_}->{products}});
283      $cache{$dir} = 1;
284  }
285
286  # Start with populating the cache with all the overrides
287  %cache = map { $_ => 1 } @{$unified_info{overrides}};
288
289  # Build mandatory generated headers
290  foreach (@{$unified_info{depends}->{""}}) { dogenerate($_); }
291
292  # Build all known libraries, modules, programs and scripts.
293  # Everything else will be handled as a consequence.
294  foreach (@{$unified_info{libraries}}) { dolib($_);    }
295  foreach (@{$unified_info{modules}})   { domodule($_); }
296  foreach (@{$unified_info{programs}})  { dobin($_);    }
297  foreach (@{$unified_info{scripts}})   { doscript($_); }
298
299  foreach (sort keys %{$unified_info{dirinfo}})  { dodir($_); }
300 -}