Bump version to 1.17.8
[dpkg/dpkg.git] / scripts / Dpkg / Shlibs / SymbolFile.pm
1 # Copyright © 2007 Raphaël Hertzog <hertzog@debian.org>
2 # Copyright © 2009-2010 Modestas Vainius <modax@debian.org>
3 #
4 # This program is free software; you can redistribute it and/or modify
5 # it under the terms of the GNU General Public License as published by
6 # the Free Software Foundation; either version 2 of the License, or
7 # (at your option) any later version.
8 #
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 # GNU General Public License for more details.
13 #
14 # You should have received a copy of the GNU General Public License
15 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
16
17 package Dpkg::Shlibs::SymbolFile;
18
19 use strict;
20 use warnings;
21
22 our $VERSION = '0.01';
23
24 use Dpkg::Gettext;
25 use Dpkg::ErrorHandling;
26 use Dpkg::Version;
27 use Dpkg::Control::Fields;
28 use Dpkg::Shlibs::Symbol;
29 use Dpkg::Arch qw(get_host_arch);
30
31 use parent qw(Dpkg::Interface::Storable);
32
33 my %blacklist = (
34     __bss_end__ => 1,                   # arm
35     __bss_end => 1,                     # arm
36     _bss_end__ => 1,                    # arm
37     __bss_start => 1,                   # ALL
38     __bss_start__ => 1,                 # arm
39     __data_start => 1,                  # arm
40     __do_global_ctors_aux => 1,         # ia64
41     __do_global_dtors_aux => 1,         # ia64
42     __do_jv_register_classes => 1,      # ia64
43     _DYNAMIC => 1,                      # ALL
44     _edata => 1,                        # ALL
45     _end => 1,                          # ALL
46     __end__ => 1,                       # arm
47     __exidx_end => 1,                   # armel
48     __exidx_start => 1,                 # armel
49     _fbss => 1,                         # mips, mipsel
50     _fdata => 1,                        # mips, mipsel
51     _fini => 1,                         # ALL
52     _ftext => 1,                        # mips, mipsel
53     _GLOBAL_OFFSET_TABLE_ => 1,         # hppa, mips, mipsel
54     __gmon_start__ => 1,                # hppa
55     __gnu_local_gp => 1,                # mips, mipsel
56     _gp => 1,                           # mips, mipsel
57     _init => 1,                         # ALL
58     _PROCEDURE_LINKAGE_TABLE_ => 1,     # sparc, alpha
59     _SDA2_BASE_ => 1,                   # powerpc
60     _SDA_BASE_ => 1,                    # powerpc
61 );
62
63 for my $i (14 .. 31) {
64     # Many powerpc specific symbols
65     $blacklist{"_restfpr_$i"} = 1;
66     $blacklist{"_restfpr_$i\_x"} = 1;
67     $blacklist{"_restgpr_$i"} = 1;
68     $blacklist{"_restgpr_$i\_x"} = 1;
69     $blacklist{"_savefpr_$i"} = 1;
70     $blacklist{"_savegpr_$i"} = 1;
71 }
72
73 sub symbol_is_blacklisted {
74     my ($symbol, $include_groups) = @_;
75
76     return 1 if exists $blacklist{$symbol};
77
78     # The ARM Embedded ABI spec states symbols under this namespace as
79     # possibly appearing in output objects.
80     return 1 if not ${$include_groups}{aeabi} and $symbol =~ /^__aeabi_/;
81
82     # The GNU implementation of the OpenMP spec, specifies symbols under
83     # this namespace as possibly appearing in output objects.
84     return 1 if not ${$include_groups}{gomp}
85                 and $symbol =~ /^\.gomp_critical_user_/;
86
87     return 0;
88 }
89
90 sub new {
91     my $this = shift;
92     my %opts=@_;
93     my $class = ref($this) || $this;
94     my $self = \%opts;
95     bless $self, $class;
96     $self->{arch} //= get_host_arch();
97     $self->clear();
98     if (exists $self->{file}) {
99         $self->load($self->{file}) if -e $self->{file};
100     }
101     return $self;
102 }
103
104 sub get_arch {
105     my ($self) = @_;
106     return $self->{arch};
107 }
108
109 sub clear {
110     my ($self) = @_;
111     $self->{objects} = {};
112 }
113
114 sub clear_except {
115     my ($self, @ids) = @_;
116     my %has;
117     $has{$_} = 1 foreach (@ids);
118     foreach my $objid (keys %{$self->{objects}}) {
119         delete $self->{objects}{$objid} unless exists $has{$objid};
120     }
121 }
122
123 sub get_sonames {
124     my ($self) = @_;
125     return keys %{$self->{objects}};
126 }
127
128 sub get_symbols {
129     my ($self, $soname) = @_;
130     if (defined $soname) {
131         my $obj = $self->get_object($soname);
132         return (defined $obj) ? values %{$obj->{syms}} : ();
133     } else {
134         my @syms;
135         foreach my $soname ($self->get_sonames()) {
136             push @syms, $self->get_symbols($soname);
137         }
138         return @syms;
139     }
140 }
141
142 sub get_patterns {
143     my ($self, $soname) = @_;
144     my @patterns;
145     if (defined $soname) {
146         my $obj = $self->get_object($soname);
147         foreach my $alias (values %{$obj->{patterns}{aliases}}) {
148             push @patterns, values %$alias;
149         }
150         return (@patterns, @{$obj->{patterns}{generic}});
151     } else {
152         foreach my $soname ($self->get_sonames()) {
153             push @patterns, $self->get_patterns($soname);
154         }
155         return @patterns;
156     }
157 }
158
159 # Create a symbol from the supplied string specification.
160 sub create_symbol {
161     my ($self, $spec, %opts) = @_;
162     my $symbol = (exists $opts{base}) ? $opts{base} :
163         Dpkg::Shlibs::Symbol->new();
164
165     my $ret = $opts{dummy} ? $symbol->parse_symbolspec($spec, default_minver => 0) :
166         $symbol->parse_symbolspec($spec);
167     if ($ret) {
168         $symbol->initialize(arch => $self->get_arch());
169         return $symbol;
170     }
171     return;
172 }
173
174 sub add_symbol {
175     my ($self, $symbol, $soname) = @_;
176     my $object = $self->get_object($soname);
177
178     if ($symbol->is_pattern()) {
179         if (my $alias_type = $symbol->get_alias_type()) {
180             unless (exists $object->{patterns}{aliases}{$alias_type}) {
181                 $object->{patterns}{aliases}{$alias_type} = {};
182             }
183             # Alias hash for matching.
184             my $aliases = $object->{patterns}{aliases}{$alias_type};
185             $aliases->{$symbol->get_symbolname()} = $symbol;
186         } else {
187             # Otherwise assume this is a generic sequential pattern. This
188             # should be always safe.
189             push @{$object->{patterns}{generic}}, $symbol;
190         }
191         return 'pattern';
192     } else {
193         # invalidate the minimum version cache
194         $object->{minver_cache} = [];
195         $object->{syms}{$symbol->get_symbolname()} = $symbol;
196         return 'sym';
197     }
198 }
199
200 sub _new_symbol {
201     my $base = shift || 'Dpkg::Shlibs::Symbol';
202     return (ref $base) ? $base->clone(@_) : $base->new(@_);
203 }
204
205 # Parameter seen is only used for recursive calls
206 sub parse {
207     my ($self, $fh, $file, $seen, $obj_ref, $base_symbol) = @_;
208
209     if (defined($seen)) {
210         return if exists $seen->{$file}; # Avoid include loops
211     } else {
212         $self->{file} = $file;
213         $seen = {};
214     }
215     $seen->{$file} = 1;
216
217     if (not ref($obj_ref)) { # Init ref to name of current object/lib
218         $$obj_ref = undef;
219     }
220
221     while (defined($_ = <$fh>)) {
222         chomp($_);
223
224         if (/^(?:\s+|#(?:DEPRECATED|MISSING): ([^#]+)#\s*)(.*)/) {
225             if (not defined ($$obj_ref)) {
226                 error(_g('symbol information must be preceded by a header (file %s, line %s)'), $file, $.);
227             }
228             # Symbol specification
229             my $deprecated = ($1) ? $1 : 0;
230             my $sym = _new_symbol($base_symbol, deprecated => $deprecated);
231             if ($self->create_symbol($2, base => $sym)) {
232                 $self->add_symbol($sym, $$obj_ref);
233             } else {
234                 warning(_g('failed to parse line in %s: %s'), $file, $_);
235             }
236         } elsif (/^(\(.*\))?#include\s+"([^"]+)"/) {
237             my $tagspec = $1;
238             my $filename = $2;
239             my $dir = $file;
240             my $new_base_symbol;
241             if (defined $tagspec) {
242                 $new_base_symbol = _new_symbol($base_symbol);
243                 $new_base_symbol->parse_tagspec($tagspec);
244             }
245             $dir =~ s{[^/]+$}{}; # Strip filename
246             $self->load("$dir$filename", $seen, $obj_ref, $new_base_symbol);
247         } elsif (/^#|^$/) {
248             # Skip possible comments and empty lines
249         } elsif (/^\|\s*(.*)$/) {
250             # Alternative dependency template
251             push @{$self->{objects}{$$obj_ref}{deps}}, "$1";
252         } elsif (/^\*\s*([^:]+):\s*(.*\S)\s*$/) {
253             # Add meta-fields
254             $self->{objects}{$$obj_ref}{fields}{field_capitalize($1)} = $2;
255         } elsif (/^(\S+)\s+(.*)$/) {
256             # New object and dependency template
257             $$obj_ref = $1;
258             if (exists $self->{objects}{$$obj_ref}) {
259                 # Update/override infos only
260                 $self->{objects}{$$obj_ref}{deps} = [ "$2" ];
261             } else {
262                 # Create a new object
263                 $self->create_object($$obj_ref, "$2");
264             }
265         } else {
266             warning(_g('failed to parse a line in %s: %s'), $file, $_);
267         }
268     }
269     delete $seen->{$file};
270 }
271
272 # Beware: we reuse the data structure of the provided symfile so make
273 # sure to not modify them after having called this function
274 sub merge_object_from_symfile {
275     my ($self, $src, $objid) = @_;
276     if (not $self->has_object($objid)) {
277         $self->{objects}{$objid} = $src->get_object($objid);
278     } else {
279         warning(_g('tried to merge the same object (%s) twice in a symfile'), $objid);
280     }
281 }
282
283 sub output {
284     my ($self, $fh, %opts) = @_;
285     $opts{template_mode} = 0 unless exists $opts{template_mode};
286     $opts{with_deprecated} = 1 unless exists $opts{with_deprecated};
287     $opts{with_pattern_matches} = 0 unless exists $opts{with_pattern_matches};
288     my $res = '';
289     foreach my $soname (sort $self->get_sonames()) {
290         my @deps = $self->get_dependencies($soname);
291         my $dep_first = shift @deps;
292         $dep_first =~ s/#PACKAGE#/$opts{package}/g if exists $opts{package};
293         print { $fh } "$soname $dep_first\n" if defined $fh;
294         $res .= "$soname $dep_first\n" if defined wantarray;
295
296         foreach my $dep_next (@deps) {
297             $dep_next =~ s/#PACKAGE#/$opts{package}/g if exists $opts{package};
298             print { $fh } "| $dep_next\n" if defined $fh;
299             $res .= "| $dep_next\n" if defined wantarray;
300         }
301         my $f = $self->{objects}{$soname}{fields};
302         foreach my $field (sort keys %{$f}) {
303             my $value = $f->{$field};
304             $value =~ s/#PACKAGE#/$opts{package}/g if exists $opts{package};
305             print { $fh } "* $field: $value\n" if defined $fh;
306             $res .= "* $field: $value\n" if defined wantarray;
307         }
308
309         my @symbols;
310         if ($opts{template_mode}) {
311             # Exclude symbols matching a pattern, but include patterns themselves
312             @symbols = grep { not $_->get_pattern() } $self->get_symbols($soname);
313             push @symbols, $self->get_patterns($soname);
314         } else {
315             @symbols = $self->get_symbols($soname);
316         }
317         foreach my $sym (sort { $a->get_symboltempl() cmp
318                                 $b->get_symboltempl() } @symbols) {
319             next if $sym->{deprecated} and not $opts{with_deprecated};
320             # Do not dump symbols from foreign arch unless dumping a template.
321             next if not $opts{template_mode} and
322                     not $sym->arch_is_concerned($self->get_arch());
323             # Dump symbol specification. Dump symbol tags only in template mode.
324             print { $fh } $sym->get_symbolspec($opts{template_mode}), "\n" if defined $fh;
325             $res .= $sym->get_symbolspec($opts{template_mode}) . "\n" if defined wantarray;
326             # Dump pattern matches as comments (if requested)
327             if ($opts{with_pattern_matches} && $sym->is_pattern()) {
328                 for my $match (sort { $a->get_symboltempl() cmp
329                                       $b->get_symboltempl() } $sym->get_pattern_matches())
330                 {
331                     print { $fh } '#MATCH:', $match->get_symbolspec(0), "\n" if defined $fh;
332                     $res .= '#MATCH:' . $match->get_symbolspec(0) . "\n" if defined wantarray;
333                 }
334             }
335         }
336     }
337     return $res;
338 }
339
340 # Tries to match a symbol name and/or version against the patterns defined.
341 # Returns a pattern which matches (if any).
342 sub find_matching_pattern {
343     my ($self, $refsym, $sonames, $inc_deprecated) = @_;
344     $inc_deprecated //= 0;
345     my $name = (ref $refsym) ? $refsym->get_symbolname() : $refsym;
346
347     my $pattern_ok = sub {
348         my $p = shift;
349         return defined $p && ($inc_deprecated || !$p->{deprecated}) &&
350                $p->arch_is_concerned($self->get_arch());
351     };
352
353     foreach my $soname ((ref($sonames) eq 'ARRAY') ? @$sonames : $sonames) {
354         my $obj = $self->get_object($soname);
355         my ($type, $pattern);
356         next unless defined $obj;
357
358         my $all_aliases = $obj->{patterns}{aliases};
359         for my $type (Dpkg::Shlibs::Symbol::ALIAS_TYPES) {
360             if (exists $all_aliases->{$type} && keys(%{$all_aliases->{$type}})) {
361                 my $aliases = $all_aliases->{$type};
362                 my $converter = $aliases->{(keys %$aliases)[0]};
363                 if (my $alias = $converter->convert_to_alias($name)) {
364                     if ($alias && exists $aliases->{$alias}) {
365                         $pattern = $aliases->{$alias};
366                         last if &$pattern_ok($pattern);
367                         $pattern = undef; # otherwise not found yet
368                     }
369                 }
370             }
371         }
372
373         # Now try generic patterns and use the first that matches
374         if (not defined $pattern) {
375             for my $p (@{$obj->{patterns}{generic}}) {
376                 if (&$pattern_ok($p) && $p->matches_rawname($name)) {
377                     $pattern = $p;
378                     last;
379                 }
380             }
381         }
382         if (defined $pattern) {
383             return (wantarray) ?
384                 ( symbol => $pattern, soname => $soname ) : $pattern;
385         }
386     }
387     return;
388 }
389
390 # merge_symbols($object, $minver)
391 # Needs $Objdump->get_object($soname) as parameter
392 # Don't merge blacklisted symbols related to the internal (arch-specific)
393 # machinery
394 sub merge_symbols {
395     my ($self, $object, $minver) = @_;
396
397     my $soname = $object->{SONAME};
398     error(_g('cannot merge symbols from objects without SONAME'))
399         unless $soname;
400
401     my %include_groups = ();
402     my $groups = $self->get_field($soname, 'Ignore-Blacklist-Groups');
403     if (defined $groups) {
404         $include_groups{$_} = 1 foreach (split /\s+/, $groups);
405     }
406
407     my %dynsyms;
408     foreach my $sym ($object->get_exported_dynamic_symbols()) {
409         my $name = $sym->{name} . '@' .
410                    ($sym->{version} ? $sym->{version} : 'Base');
411         my $symobj = $self->lookup_symbol($name, $soname);
412         if (symbol_is_blacklisted($sym->{name}, \%include_groups)) {
413             next unless (defined $symobj and $symobj->has_tag('ignore-blacklist'));
414         }
415         $dynsyms{$name} = $sym;
416     }
417
418     unless ($self->has_object($soname)) {
419         $self->create_object($soname, '');
420     }
421     # Scan all symbols provided by the objects
422     my $obj = $self->get_object($soname);
423     # invalidate the minimum version cache - it is not sufficient to
424     # invalidate in add_symbol, since we might change a minimum
425     # version for a particular symbol without adding it
426     $obj->{minver_cache} = [];
427     foreach my $name (keys %dynsyms) {
428         my $sym;
429         if ($sym = $self->lookup_symbol($name, $obj, 1)) {
430             # If the symbol is already listed in the file
431             $sym->mark_found_in_library($minver, $self->get_arch());
432         } else {
433             # The exact symbol is not present in the file, but it might match a
434             # pattern.
435             my $pattern = $self->find_matching_pattern($name, $obj, 1);
436             if (defined $pattern) {
437                 $pattern->mark_found_in_library($minver, $self->get_arch());
438                 $sym = $pattern->create_pattern_match(symbol => $name);
439             } else {
440                 # Symbol without any special info as no pattern matched
441                 $sym = Dpkg::Shlibs::Symbol->new(symbol => $name,
442                                                  minver => $minver);
443             }
444             $self->add_symbol($sym, $obj);
445         }
446     }
447
448     # Process all symbols which could not be found in the library.
449     foreach my $sym ($self->get_symbols($soname)) {
450         if (not exists $dynsyms{$sym->get_symbolname()}) {
451             $sym->mark_not_found_in_library($minver, $self->get_arch());
452         }
453     }
454
455     # Deprecate patterns which didn't match anything
456     for my $pattern (grep { $_->get_pattern_matches() == 0 }
457                           $self->get_patterns($soname)) {
458         $pattern->mark_not_found_in_library($minver, $self->get_arch());
459     }
460 }
461
462 sub is_empty {
463     my ($self) = @_;
464     return scalar(keys %{$self->{objects}}) ? 0 : 1;
465 }
466
467 sub has_object {
468     my ($self, $soname) = @_;
469     return exists $self->{objects}{$soname};
470 }
471
472 sub get_object {
473     my ($self, $soname) = @_;
474     return ref($soname) ? $soname : $self->{objects}{$soname};
475 }
476
477 sub create_object {
478     my ($self, $soname, @deps) = @_;
479     $self->{objects}{$soname} = {
480         syms => {},
481         fields => {},
482         patterns => {
483             aliases => {},
484             generic => [],
485         },
486         deps => [ @deps ],
487         minver_cache => []
488     };
489 }
490
491 sub get_dependency {
492     my ($self, $soname, $dep_id) = @_;
493     $dep_id //= 0;
494     return $self->get_object($soname)->{deps}[$dep_id];
495 }
496
497 sub get_smallest_version {
498     my ($self, $soname, $dep_id) = @_;
499     $dep_id //= 0;
500     my $so_object = $self->get_object($soname);
501     return $so_object->{minver_cache}[$dep_id]
502         if defined $so_object->{minver_cache}[$dep_id];
503     my $minver;
504     foreach my $sym ($self->get_symbols($so_object)) {
505         next if $dep_id != $sym->{dep_id};
506         $minver //= $sym->{minver};
507         if (version_compare($minver, $sym->{minver}) > 0) {
508             $minver = $sym->{minver};
509         }
510     }
511     $so_object->{minver_cache}[$dep_id] = $minver;
512     return $minver;
513 }
514
515 sub get_dependencies {
516     my ($self, $soname) = @_;
517     return @{$self->get_object($soname)->{deps}};
518 }
519
520 sub get_field {
521     my ($self, $soname, $name) = @_;
522     if (my $obj = $self->get_object($soname)) {
523         if (exists $obj->{fields}{$name}) {
524             return $obj->{fields}{$name};
525         }
526     }
527     return;
528 }
529
530 # Tries to find a symbol like the $refsym and returns its descriptor.
531 # $refsym may also be a symbol name.
532 sub lookup_symbol {
533     my ($self, $refsym, $sonames, $inc_deprecated) = @_;
534     $inc_deprecated //= 0;
535     my $name = (ref $refsym) ? $refsym->get_symbolname() : $refsym;
536
537     foreach my $so ((ref($sonames) eq 'ARRAY') ? @$sonames : $sonames) {
538         if (my $obj = $self->get_object($so)) {
539             my $sym = $obj->{syms}{$name};
540             if ($sym and ($inc_deprecated or not $sym->{deprecated}))
541             {
542                 return (wantarray) ?
543                     ( symbol => $sym, soname => $so ) : $sym;
544             }
545         }
546     }
547     return;
548 }
549
550 # Tries to find a pattern like the $refpat and returns its descriptor.
551 # $refpat may also be a pattern spec.
552 sub lookup_pattern {
553     my ($self, $refpat, $sonames, $inc_deprecated) = @_;
554     $inc_deprecated //= 0;
555     # If $refsym is a string, we need to create a dummy ref symbol.
556     $refpat = $self->create_symbol($refpat, dummy => 1) if ! ref($refpat);
557
558     if ($refpat && $refpat->is_pattern()) {
559         foreach my $soname ((ref($sonames) eq 'ARRAY') ? @$sonames : $sonames) {
560             if (my $obj = $self->get_object($soname)) {
561                 my $pat;
562                 if (my $type = $refpat->get_alias_type()) {
563                     if (exists $obj->{patterns}{aliases}{$type}) {
564                         $pat = $obj->{patterns}{aliases}{$type}{$refpat->get_symbolname()};
565                     }
566                 } elsif ($refpat->get_pattern_type() eq 'generic') {
567                     for my $p (@{$obj->{patterns}{generic}}) {
568                         if (($inc_deprecated || !$p->{deprecated}) &&
569                             $p->equals($refpat, versioning => 0))
570                         {
571                             $pat = $p;
572                             last;
573                         }
574                     }
575                 }
576                 if ($pat && ($inc_deprecated || !$pat->{deprecated})) {
577                     return (wantarray) ?
578                         (symbol => $pat, soname => $soname) : $pat;
579                 }
580             }
581         }
582     }
583     return;
584 }
585
586 # Get symbol object reference either by symbol name or by a reference object.
587 sub get_symbol_object {
588     my ($self, $refsym, $soname) = @_;
589     my $sym = $self->lookup_symbol($refsym, $soname, 1);
590     if (! defined $sym) {
591         $sym = $self->lookup_pattern($refsym, $soname, 1);
592     }
593     return $sym;
594 }
595
596 sub get_new_symbols {
597     my ($self, $ref, %opts) = @_;
598     my $with_optional = (exists $opts{with_optional}) ?
599         $opts{with_optional} : 0;
600     my @res;
601     foreach my $soname ($self->get_sonames()) {
602         next if not $ref->has_object($soname);
603
604         # Scan raw symbols first.
605         foreach my $sym (grep { ($with_optional || ! $_->is_optional())
606                                 && $_->is_legitimate($self->get_arch()) }
607                               $self->get_symbols($soname))
608         {
609             my $refsym = $ref->lookup_symbol($sym, $soname, 1);
610             my $isnew;
611             if (defined $refsym) {
612                 # If the symbol exists in the $ref symbol file, it might
613                 # still be new if $refsym is not legitimate.
614                 $isnew = not $refsym->is_legitimate($self->get_arch());
615             } else {
616                 # If the symbol does not exist in the $ref symbol file, it does
617                 # not mean that it's new. It might still match a pattern in the
618                 # symbol file. However, due to performance reasons, first check
619                 # if the pattern that the symbol matches (if any) exists in the
620                 # ref symbol file as well.
621                 $isnew = not (
622                     ($sym->get_pattern() and $ref->lookup_pattern($sym->get_pattern(), $soname, 1)) or
623                     $ref->find_matching_pattern($sym, $soname, 1)
624                 );
625             }
626             push @res, { symbol => $sym, soname => $soname } if $isnew;
627         }
628
629         # Now scan patterns
630         foreach my $p (grep { ($with_optional || ! $_->is_optional())
631                               && $_->is_legitimate($self->get_arch()) }
632                             $self->get_patterns($soname))
633         {
634             my $refpat = $ref->lookup_pattern($p, $soname, 0);
635             # If reference pattern was not found or it is not legitimate,
636             # considering current one as new.
637             if (not defined $refpat or
638                 not $refpat->is_legitimate($self->get_arch()))
639             {
640                 push @res, { symbol => $p , soname => $soname };
641             }
642         }
643     }
644     return @res;
645 }
646
647 sub get_lost_symbols {
648     my ($self, $ref, %opts) = @_;
649     return $ref->get_new_symbols($self, %opts);
650 }
651
652
653 sub get_new_libs {
654     my ($self, $ref) = @_;
655     my @res;
656     foreach my $soname ($self->get_sonames()) {
657         push @res, $soname if not $ref->get_object($soname);
658     }
659     return @res;
660 }
661
662 sub get_lost_libs {
663     my ($self, $ref) = @_;
664     return $ref->get_new_libs($self);
665 }
666
667 1;