summaryrefslogtreecommitdiffstats
path: root/scripts/Dpkg/Shlibs
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--scripts/Dpkg/Shlibs.pm184
-rw-r--r--scripts/Dpkg/Shlibs/Cppfilt.pm120
-rw-r--r--scripts/Dpkg/Shlibs/Objdump.pm582
-rw-r--r--scripts/Dpkg/Shlibs/Symbol.pm531
-rw-r--r--scripts/Dpkg/Shlibs/SymbolFile.pm697
5 files changed, 2114 insertions, 0 deletions
diff --git a/scripts/Dpkg/Shlibs.pm b/scripts/Dpkg/Shlibs.pm
new file mode 100644
index 0000000..22fecc4
--- /dev/null
+++ b/scripts/Dpkg/Shlibs.pm
@@ -0,0 +1,184 @@
+# Copyright © 2007, 2016 Raphaël Hertzog <hertzog@debian.org>
+# Copyright © 2007-2008, 2012-2015 Guillem Jover <guillem@debian.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+package Dpkg::Shlibs;
+
+use strict;
+use warnings;
+use feature qw(state);
+
+our $VERSION = '0.03';
+our @EXPORT_OK = qw(
+ blank_library_paths
+ setup_library_paths
+ get_library_paths
+ add_library_dir
+ find_library
+);
+
+use Exporter qw(import);
+use List::Util qw(none);
+use File::Spec;
+
+use Dpkg::Gettext;
+use Dpkg::ErrorHandling;
+use Dpkg::Shlibs::Objdump;
+use Dpkg::Path qw(resolve_symlink canonpath);
+use Dpkg::Arch qw(get_build_arch get_host_arch :mappers);
+
+use constant DEFAULT_LIBRARY_PATH =>
+ qw(/lib /usr/lib);
+# XXX: Deprecated multilib paths.
+use constant DEFAULT_MULTILIB_PATH =>
+ qw(/lib32 /usr/lib32 /lib64 /usr/lib64);
+
+# Library paths set by the user.
+my @custom_librarypaths;
+# Library paths from the system.
+my @system_librarypaths;
+my $librarypaths_init;
+
+sub parse_ldso_conf {
+ my $file = shift;
+ state %visited;
+ local $_;
+
+ open my $fh, '<', $file or syserr(g_('cannot open %s'), $file);
+ $visited{$file}++;
+ while (<$fh>) {
+ next if /^\s*$/;
+ chomp;
+ s{/+$}{};
+ if (/^include\s+(\S.*\S)\s*$/) {
+ foreach my $include (glob($1)) {
+ parse_ldso_conf($include) if -e $include
+ && !$visited{$include};
+ }
+ } elsif (m{^\s*/}) {
+ s/^\s+//;
+ my $libdir = $_;
+ if (none { $_ eq $libdir } (@custom_librarypaths, @system_librarypaths)) {
+ push @system_librarypaths, $libdir;
+ }
+ }
+ }
+ close $fh;
+}
+
+sub blank_library_paths {
+ @custom_librarypaths = ();
+ @system_librarypaths = ();
+ $librarypaths_init = 1;
+}
+
+sub setup_library_paths {
+ @custom_librarypaths = ();
+ @system_librarypaths = ();
+
+ # XXX: Deprecated. Update library paths with LD_LIBRARY_PATH.
+ if ($ENV{LD_LIBRARY_PATH}) {
+ require Cwd;
+ my $cwd = Cwd::getcwd;
+
+ foreach my $path (split /:/, $ENV{LD_LIBRARY_PATH}) {
+ $path =~ s{/+$}{};
+
+ my $realpath = Cwd::realpath($path);
+ next unless defined $realpath;
+ if ($realpath =~ m/^\Q$cwd\E/) {
+ warning(g_('deprecated use of LD_LIBRARY_PATH with private ' .
+ 'library directory which interferes with ' .
+ 'cross-building, please use -l option instead'));
+ }
+
+ # XXX: This should be added to @custom_librarypaths, but as this
+ # is deprecated we do not care as the code will go away.
+ push @system_librarypaths, $path;
+ }
+ }
+
+ # Adjust set of directories to consider when we're in a situation of a
+ # cross-build or a build of a cross-compiler.
+ my $multiarch;
+
+ # Detect cross compiler builds.
+ if ($ENV{DEB_TARGET_GNU_TYPE} and
+ ($ENV{DEB_TARGET_GNU_TYPE} ne $ENV{DEB_BUILD_GNU_TYPE}))
+ {
+ $multiarch = gnutriplet_to_multiarch($ENV{DEB_TARGET_GNU_TYPE});
+ }
+ # Host for normal cross builds.
+ if (get_build_arch() ne get_host_arch()) {
+ $multiarch = debarch_to_multiarch(get_host_arch());
+ }
+ # Define list of directories containing crossbuilt libraries.
+ if ($multiarch) {
+ push @system_librarypaths, "/lib/$multiarch", "/usr/lib/$multiarch";
+ }
+
+ push @system_librarypaths, DEFAULT_LIBRARY_PATH;
+
+ # Update library paths with ld.so config.
+ parse_ldso_conf('/etc/ld.so.conf') if -e '/etc/ld.so.conf';
+
+ push @system_librarypaths, DEFAULT_MULTILIB_PATH;
+
+ $librarypaths_init = 1;
+}
+
+sub add_library_dir {
+ my $dir = shift;
+
+ setup_library_paths() if not $librarypaths_init;
+
+ push @custom_librarypaths, $dir;
+}
+
+sub get_library_paths {
+ setup_library_paths() if not $librarypaths_init;
+
+ return (@custom_librarypaths, @system_librarypaths);
+}
+
+# find_library ($soname, \@rpath, $format, $root)
+sub find_library {
+ my ($lib, $rpath, $format, $root) = @_;
+
+ setup_library_paths() if not $librarypaths_init;
+
+ my @librarypaths = (@{$rpath}, @custom_librarypaths, @system_librarypaths);
+ my @libs;
+
+ $root //= '';
+ $root =~ s{/+$}{};
+ foreach my $dir (@librarypaths) {
+ my $checkdir = "$root$dir";
+ if (-e "$checkdir/$lib") {
+ my $libformat = Dpkg::Shlibs::Objdump::get_format("$checkdir/$lib");
+ if (not defined $libformat) {
+ warning(g_("unknown executable format in file '%s'"), "$checkdir/$lib");
+ } elsif ($format eq $libformat) {
+ push @libs, canonpath("$checkdir/$lib");
+ } else {
+ debug(1, "Skipping lib $checkdir/$lib, libabi=0x%s != objabi=0x%s",
+ unpack('H*', $libformat), unpack('H*', $format));
+ }
+ }
+ }
+ return @libs;
+}
+
+1;
diff --git a/scripts/Dpkg/Shlibs/Cppfilt.pm b/scripts/Dpkg/Shlibs/Cppfilt.pm
new file mode 100644
index 0000000..c2a4756
--- /dev/null
+++ b/scripts/Dpkg/Shlibs/Cppfilt.pm
@@ -0,0 +1,120 @@
+# Copyright © 2009-2010 Modestas Vainius <modax@debian.org>
+# Copyright © 2010, 2012-2015 Guillem Jover <guillem@debian.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+package Dpkg::Shlibs::Cppfilt;
+
+use strict;
+use warnings;
+
+our $VERSION = '0.01';
+our @EXPORT = qw(
+ cppfilt_demangle_cpp
+);
+our @EXPORT_OK = qw(
+ cppfilt_demangle
+);
+
+use Exporter qw(import);
+
+use Dpkg::ErrorHandling;
+use Dpkg::IPC;
+
+# A hash of 'objects' referring to preforked c++filt processes for the distinct
+# demangling types.
+my %cppfilts;
+
+sub get_cppfilt {
+ my $type = shift || 'auto';
+
+ # Fork c++filt process for demangling $type unless it is forked already.
+ # Keeping c++filt running improves performance a lot.
+ my $filt;
+ if (exists $cppfilts{$type}) {
+ $filt = $cppfilts{$type};
+ } else {
+ $filt = {
+ from => undef,
+ to => undef,
+ last_symbol => '',
+ last_result => '',
+ };
+ $filt->{pid} = spawn(exec => [ 'c++filt', "--format=$type" ],
+ from_pipe => \$filt->{from},
+ to_pipe => \$filt->{to});
+ syserr(g_('unable to execute %s'), 'c++filt')
+ unless defined $filt->{from};
+ $filt->{from}->autoflush(1);
+
+ $cppfilts{$type} = $filt;
+ }
+ return $filt;
+}
+
+# Demangle the given $symbol using demangler for the specified $type (defaults
+# to 'auto') . Extraneous characters trailing after a mangled name are kept
+# intact. If neither whole $symbol nor portion of it could be demangled, undef
+# is returned.
+sub cppfilt_demangle {
+ my ($symbol, $type) = @_;
+
+ # Start or get c++filt 'object' for the requested type.
+ my $filt = get_cppfilt($type);
+
+ # Remember the last result. Such a local optimization is cheap and useful
+ # when sequential pattern matching is performed.
+ if ($filt->{last_symbol} ne $symbol) {
+ # This write/read operation should not deadlock because c++filt flushes
+ # output buffer on LF or each invalid character.
+ print { $filt->{from} } $symbol, "\n";
+ my $demangled = readline($filt->{to});
+ chop $demangled;
+
+ # If the symbol was not demangled, return undef
+ $demangled = undef if $symbol eq $demangled;
+
+ # Remember the last result
+ $filt->{last_symbol} = $symbol;
+ $filt->{last_result} = $demangled;
+ }
+ return $filt->{last_result};
+}
+
+sub cppfilt_demangle_cpp {
+ my $symbol = shift;
+ return cppfilt_demangle($symbol, 'auto');
+}
+
+sub terminate_cppfilts {
+ foreach my $type (keys %cppfilts) {
+ next if not defined $cppfilts{$type}{pid};
+ close $cppfilts{$type}{from};
+ close $cppfilts{$type}{to};
+ wait_child($cppfilts{$type}{pid}, cmdline => 'c++filt',
+ nocheck => 1,
+ timeout => 5);
+ delete $cppfilts{$type};
+ }
+}
+
+# Close/terminate running c++filt process(es)
+END {
+ # Make sure exitcode is not changed (by wait_child)
+ my $exitcode = $?;
+ terminate_cppfilts();
+ $? = $exitcode;
+}
+
+1;
diff --git a/scripts/Dpkg/Shlibs/Objdump.pm b/scripts/Dpkg/Shlibs/Objdump.pm
new file mode 100644
index 0000000..c9af965
--- /dev/null
+++ b/scripts/Dpkg/Shlibs/Objdump.pm
@@ -0,0 +1,582 @@
+# Copyright © 2007-2010 Raphaël Hertzog <hertzog@debian.org>
+# Copyright © 2007-2009,2012-2015,2017-2018 Guillem Jover <guillem@debian.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+package Dpkg::Shlibs::Objdump;
+
+use strict;
+use warnings;
+use feature qw(state);
+
+our $VERSION = '0.01';
+
+use Dpkg::Gettext;
+use Dpkg::ErrorHandling;
+
+sub new {
+ my $this = shift;
+ my $class = ref($this) || $this;
+ my $self = { objects => {} };
+ bless $self, $class;
+ return $self;
+}
+
+sub add_object {
+ my ($self, $obj) = @_;
+ my $id = $obj->get_id;
+ if ($id) {
+ $self->{objects}{$id} = $obj;
+ }
+ return $id;
+}
+
+sub analyze {
+ my ($self, $file) = @_;
+ my $obj = Dpkg::Shlibs::Objdump::Object->new($file);
+
+ return $self->add_object($obj);
+}
+
+sub locate_symbol {
+ my ($self, $name) = @_;
+ foreach my $obj (values %{$self->{objects}}) {
+ my $sym = $obj->get_symbol($name);
+ if (defined($sym) && $sym->{defined}) {
+ return $sym;
+ }
+ }
+ return;
+}
+
+sub get_object {
+ my ($self, $objid) = @_;
+ if ($self->has_object($objid)) {
+ return $self->{objects}{$objid};
+ }
+ return;
+}
+
+sub has_object {
+ my ($self, $objid) = @_;
+ return exists $self->{objects}{$objid};
+}
+
+use constant {
+ # ELF Class.
+ ELF_BITS_NONE => 0,
+ ELF_BITS_32 => 1,
+ ELF_BITS_64 => 2,
+
+ # ELF Data encoding.
+ ELF_ORDER_NONE => 0,
+ ELF_ORDER_2LSB => 1,
+ ELF_ORDER_2MSB => 2,
+
+ # ELF Machine.
+ EM_SPARC => 2,
+ EM_MIPS => 8,
+ EM_SPARC64_OLD => 11,
+ EM_SPARC32PLUS => 18,
+ EM_PPC64 => 21,
+ EM_S390 => 22,
+ EM_ARM => 40,
+ EM_ALPHA_OLD => 41,
+ EM_SH => 42,
+ EM_SPARC64 => 43,
+ EM_IA64 => 50,
+ EM_AVR => 83,
+ EM_M32R => 88,
+ EM_MN10300 => 89,
+ EM_MN10200 => 90,
+ EM_OR1K => 92,
+ EM_XTENSA => 94,
+ EM_MICROBLAZE => 189,
+ EM_ARCV2 => 195,
+ EM_LOONGARCH => 258,
+ EM_AVR_OLD => 0x1057,
+ EM_OR1K_OLD => 0x8472,
+ EM_ALPHA => 0x9026,
+ EM_M32R_CYGNUS => 0x9041,
+ EM_S390_OLD => 0xa390,
+ EM_XTENSA_OLD => 0xabc7,
+ EM_MICROBLAZE_OLD => 0xbaab,
+ EM_MN10300_CYGNUS => 0xbeef,
+ EM_MN10200_CYGNUS => 0xdead,
+
+ # ELF Version.
+ EV_NONE => 0,
+ EV_CURRENT => 1,
+
+ # ELF Flags (might influence the ABI).
+ EF_ARM_ALIGN8 => 0x00000040,
+ EF_ARM_NEW_ABI => 0x00000080,
+ EF_ARM_OLD_ABI => 0x00000100,
+ EF_ARM_SOFT_FLOAT => 0x00000200,
+ EF_ARM_HARD_FLOAT => 0x00000400,
+ EF_ARM_EABI_MASK => 0xff000000,
+
+ EF_IA64_ABI64 => 0x00000010,
+
+ EF_LOONGARCH_SOFT_FLOAT => 0x00000001,
+ EF_LOONGARCH_SINGLE_FLOAT => 0x00000002,
+ EF_LOONGARCH_DOUBLE_FLOAT => 0x00000003,
+ EF_LOONGARCH_ABI_MASK => 0x00000007,
+
+ EF_MIPS_ABI2 => 0x00000020,
+ EF_MIPS_32BIT => 0x00000100,
+ EF_MIPS_FP64 => 0x00000200,
+ EF_MIPS_NAN2008 => 0x00000400,
+ EF_MIPS_ABI_MASK => 0x0000f000,
+ EF_MIPS_ARCH_MASK => 0xf0000000,
+
+ EF_PPC64_ABI64 => 0x00000003,
+
+ EF_SH_MACH_MASK => 0x0000001f,
+};
+
+# These map alternative or old machine IDs to their canonical form.
+my %elf_mach_map = (
+ EM_ALPHA_OLD() => EM_ALPHA,
+ EM_AVR_OLD() => EM_AVR,
+ EM_M32R_CYGNUS() => EM_M32R,
+ EM_MICROBLAZE_OLD() => EM_MICROBLAZE,
+ EM_MN10200_CYGNUS() => EM_MN10200,
+ EM_MN10300_CYGNUS() => EM_MN10300,
+ EM_OR1K_OLD() => EM_OR1K,
+ EM_S390_OLD() => EM_S390,
+ EM_SPARC32PLUS() => EM_SPARC,
+ EM_SPARC64_OLD() => EM_SPARC64,
+ EM_XTENSA_OLD() => EM_XTENSA,
+);
+
+# These masks will try to expose processor flags that are ABI incompatible,
+# and as such are part of defining the architecture ABI. If uncertain it is
+# always better to not mask a flag, because that preserves the historical
+# behavior, and we do not drop dependencies.
+my %elf_flags_mask = (
+ EM_IA64() => EF_IA64_ABI64,
+ EM_LOONGARCH() => EF_LOONGARCH_ABI_MASK,
+ EM_MIPS() => EF_MIPS_ABI_MASK | EF_MIPS_ABI2,
+ EM_PPC64() => EF_PPC64_ABI64,
+);
+
+sub get_format {
+ my ($file) = @_;
+ state %format;
+
+ return $format{$file} if exists $format{$file};
+
+ my $header;
+
+ open my $fh, '<', $file or syserr(g_('cannot read %s'), $file);
+ my $rc = read $fh, $header, 64;
+ if (not defined $rc) {
+ syserr(g_('cannot read %s'), $file);
+ } elsif ($rc != 64) {
+ return;
+ }
+ close $fh;
+
+ my %elf;
+
+ # Unpack the identifier field.
+ @elf{qw(magic bits endian vertype osabi verabi)} = unpack 'a4C5', $header;
+
+ return unless $elf{magic} eq "\x7fELF";
+ return unless $elf{vertype} == EV_CURRENT;
+
+ my ($elf_word, $elf_endian);
+ if ($elf{bits} == ELF_BITS_32) {
+ $elf_word = 'L';
+ } elsif ($elf{bits} == ELF_BITS_64) {
+ $elf_word = 'Q';
+ } else {
+ return;
+ }
+ if ($elf{endian} == ELF_ORDER_2LSB) {
+ $elf_endian = '<';
+ } elsif ($elf{endian} == ELF_ORDER_2MSB) {
+ $elf_endian = '>';
+ } else {
+ return;
+ }
+
+ # Unpack the endianness and size dependent fields.
+ my $tmpl = "x16(S2Lx[${elf_word}3]L)${elf_endian}";
+ @elf{qw(type mach version flags)} = unpack $tmpl, $header;
+
+ # Canonicalize the machine ID.
+ $elf{mach} = $elf_mach_map{$elf{mach}} // $elf{mach};
+
+ # Mask any processor flags that might not change the architecture ABI.
+ $elf{flags} &= $elf_flags_mask{$elf{mach}} // 0;
+
+ # Repack for easy comparison, as a big-endian byte stream, so that
+ # unpacking for output gives meaningful results.
+ $format{$file} = pack 'C2(SL)>', @elf{qw(bits endian mach flags)};
+
+ return $format{$file};
+}
+
+sub is_elf {
+ my $file = shift;
+ open(my $file_fh, '<', $file) or syserr(g_('cannot read %s'), $file);
+ my ($header, $result) = ('', 0);
+ if (read($file_fh, $header, 4) == 4) {
+ $result = 1 if ($header =~ /^\177ELF$/);
+ }
+ close($file_fh);
+ return $result;
+}
+
+package Dpkg::Shlibs::Objdump::Object;
+
+use strict;
+use warnings;
+use feature qw(state);
+
+use Dpkg::Gettext;
+use Dpkg::ErrorHandling;
+use Dpkg::Path qw(find_command);
+use Dpkg::Arch qw(debarch_to_gnutriplet get_build_arch get_host_arch);
+
+sub new {
+ my $this = shift;
+ my $file = shift // '';
+ my $class = ref($this) || $this;
+ my $self = {};
+ bless $self, $class;
+
+ $self->reset;
+ if ($file) {
+ $self->analyze($file);
+ }
+
+ return $self;
+}
+
+sub reset {
+ my $self = shift;
+
+ $self->{file} = '';
+ $self->{id} = '';
+ $self->{HASH} = '';
+ $self->{GNU_HASH} = '';
+ $self->{INTERP} = 0;
+ $self->{SONAME} = '';
+ $self->{NEEDED} = [];
+ $self->{RPATH} = [];
+ $self->{dynsyms} = {};
+ $self->{flags} = {};
+ $self->{dynrelocs} = {};
+
+ return $self;
+}
+
+sub _select_objdump {
+ # Decide which objdump to call
+ if (get_build_arch() ne get_host_arch()) {
+ my $od = debarch_to_gnutriplet(get_host_arch()) . '-objdump';
+ return $od if find_command($od);
+ }
+ return 'objdump';
+}
+
+sub analyze {
+ my ($self, $file) = @_;
+
+ $file ||= $self->{file};
+ return unless $file;
+
+ $self->reset;
+ $self->{file} = $file;
+
+ $self->{exec_abi} = Dpkg::Shlibs::Objdump::get_format($file);
+
+ if (not defined $self->{exec_abi}) {
+ warning(g_("unknown executable format in file '%s'"), $file);
+ return;
+ }
+
+ state $OBJDUMP = _select_objdump();
+ local $ENV{LC_ALL} = 'C';
+ open(my $objdump, '-|', $OBJDUMP, '-w', '-f', '-p', '-T', '-R', $file)
+ or syserr(g_('cannot fork for %s'), $OBJDUMP);
+ my $ret = $self->parse_objdump_output($objdump);
+ close($objdump);
+ return $ret;
+}
+
+sub parse_objdump_output {
+ my ($self, $fh) = @_;
+
+ my $section = 'none';
+ while (<$fh>) {
+ s/\s*$//;
+ next if length == 0;
+
+ if (/^DYNAMIC SYMBOL TABLE:/) {
+ $section = 'dynsym';
+ next;
+ } elsif (/^DYNAMIC RELOCATION RECORDS/) {
+ $section = 'dynreloc';
+ $_ = <$fh>; # Skip header
+ next;
+ } elsif (/^Dynamic Section:/) {
+ $section = 'dyninfo';
+ next;
+ } elsif (/^Program Header:/) {
+ $section = 'program';
+ next;
+ } elsif (/^Version definitions:/) {
+ $section = 'verdef';
+ next;
+ } elsif (/^Version References:/) {
+ $section = 'verref';
+ next;
+ }
+
+ if ($section eq 'dynsym') {
+ $self->parse_dynamic_symbol($_);
+ } elsif ($section eq 'dynreloc') {
+ if (/^\S+\s+(\S+)\s+(.+)$/) {
+ $self->{dynrelocs}{$2} = $1;
+ } else {
+ warning(g_("couldn't parse dynamic relocation record: %s"), $_);
+ }
+ } elsif ($section eq 'dyninfo') {
+ if (/^\s*NEEDED\s+(\S+)/) {
+ push @{$self->{NEEDED}}, $1;
+ } elsif (/^\s*SONAME\s+(\S+)/) {
+ $self->{SONAME} = $1;
+ } elsif (/^\s*HASH\s+(\S+)/) {
+ $self->{HASH} = $1;
+ } elsif (/^\s*GNU_HASH\s+(\S+)/) {
+ $self->{GNU_HASH} = $1;
+ } elsif (/^\s*RUNPATH\s+(\S+)/) {
+ # RUNPATH takes precedence over RPATH but is
+ # considered after LD_LIBRARY_PATH while RPATH
+ # is considered before (if RUNPATH is not set).
+ my $runpath = $1;
+ $self->{RPATH} = [ split /:/, $runpath ];
+ } elsif (/^\s*RPATH\s+(\S+)/) {
+ my $rpath = $1;
+ unless (scalar(@{$self->{RPATH}})) {
+ $self->{RPATH} = [ split /:/, $rpath ];
+ }
+ }
+ } elsif ($section eq 'program') {
+ if (/^\s*INTERP\s+/) {
+ $self->{INTERP} = 1;
+ }
+ } elsif ($section eq 'none') {
+ if (/^\s*.+:\s*file\s+format\s+(\S+)$/) {
+ $self->{format} = $1;
+ } elsif (/^architecture:\s*\S+,\s*flags\s*\S+:$/) {
+ # Parse 2 lines of "-f"
+ # architecture: i386, flags 0x00000112:
+ # EXEC_P, HAS_SYMS, D_PAGED
+ # start address 0x08049b50
+ $_ = <$fh>;
+ chomp;
+ $self->{flags}{$_} = 1 foreach (split(/,\s*/));
+ }
+ }
+ }
+ # Update status of dynamic symbols given the relocations that have
+ # been parsed after the symbols...
+ $self->apply_relocations();
+
+ return $section ne 'none';
+}
+
+# Output format of objdump -w -T
+#
+# /lib/libc.so.6: file format elf32-i386
+#
+# DYNAMIC SYMBOL TABLE:
+# 00056ef0 g DF .text 000000db GLIBC_2.2 getwchar
+# 00000000 g DO *ABS* 00000000 GCC_3.0 GCC_3.0
+# 00069960 w DF .text 0000001e GLIBC_2.0 bcmp
+# 00000000 w D *UND* 00000000 _pthread_cleanup_pop_restore
+# 0000b788 g DF .text 0000008e Base .protected xine_close
+# 0000b788 g DF .text 0000008e .hidden IA__g_free
+# | ||||||| | | | |
+# | ||||||| | | Version str (.visibility) + Symbol name
+# | ||||||| | Alignment
+# | ||||||| Section name (or *UND* for an undefined symbol)
+# | ||||||F=Function,f=file,O=object
+# | |||||d=debugging,D=dynamic
+# | ||||I=Indirect
+# | |||W=warning
+# | ||C=constructor
+# | |w=weak
+# | g=global,l=local,!=both global/local
+# Size of the symbol
+#
+# GLIBC_2.2 is the version string associated to the symbol
+# (GLIBC_2.2) is the same but the symbol is hidden, a newer version of the
+# symbol exist
+
+my $vis_re = qr/(\.protected|\.hidden|\.internal|0x\S+)/;
+my $dynsym_re = qr<
+ ^
+ [0-9a-f]+ # Symbol size
+ \ (.{7}) # Flags
+ \s+(\S+) # Section name
+ \s+[0-9a-f]+ # Alignment
+ (?:\s+(\S+))? # Version string
+ (?:\s+$vis_re)? # Visibility
+ \s+(.+) # Symbol name
+>x;
+
+sub parse_dynamic_symbol {
+ my ($self, $line) = @_;
+ if ($line =~ $dynsym_re) {
+ my ($flags, $sect, $ver, $vis, $name) = ($1, $2, $3, $4, $5);
+
+ # Special case if version is missing but extra visibility
+ # attribute replaces it in the match
+ if (defined($ver) and $ver =~ /^$vis_re$/) {
+ $vis = $ver;
+ $ver = '';
+ }
+
+ # Cleanup visibility field
+ $vis =~ s/^\.// if defined($vis);
+
+ my $symbol = {
+ name => $name,
+ version => $ver // '',
+ section => $sect,
+ dynamic => substr($flags, 5, 1) eq 'D',
+ debug => substr($flags, 5, 1) eq 'd',
+ type => substr($flags, 6, 1),
+ weak => substr($flags, 1, 1) eq 'w',
+ local => substr($flags, 0, 1) eq 'l',
+ global => substr($flags, 0, 1) eq 'g',
+ visibility => $vis // '',
+ hidden => '',
+ defined => $sect ne '*UND*'
+ };
+
+ # Handle hidden symbols
+ if (defined($ver) and $ver =~ /^\((.*)\)$/) {
+ $ver = $1;
+ $symbol->{version} = $1;
+ $symbol->{hidden} = 1;
+ }
+
+ # Register symbol
+ $self->add_dynamic_symbol($symbol);
+ } elsif ($line =~ /^[0-9a-f]+ (.{7})\s+(\S+)\s+[0-9a-f]+/) {
+ # Same start but no version and no symbol ... just ignore
+ } elsif ($line =~ /^REG_G\d+\s+/) {
+ # Ignore some s390-specific output like
+ # REG_G6 g R *UND* 0000000000000000 #scratch
+ } else {
+ warning(g_("couldn't parse dynamic symbol definition: %s"), $line);
+ }
+}
+
+sub apply_relocations {
+ my $self = shift;
+ foreach my $sym (values %{$self->{dynsyms}}) {
+ # We want to mark as undefined symbols those which are currently
+ # defined but that depend on a copy relocation
+ next if not $sym->{defined};
+
+ my @relocs;
+
+ # When objdump qualifies the symbol with a version it will use @ when
+ # the symbol is in an undefined section (which we discarded above, or
+ # @@ otherwise.
+ push @relocs, $sym->{name} . '@@' . $sym->{version} if $sym->{version};
+
+ # Symbols that are not versioned, or versioned but shown with objdump
+ # from binutils < 2.26, do not have a version appended.
+ push @relocs, $sym->{name};
+
+ foreach my $reloc (@relocs) {
+ next if not exists $self->{dynrelocs}{$reloc};
+ next if not $self->{dynrelocs}{$reloc} =~ /^R_.*_COPY$/;
+
+ $sym->{defined} = 0;
+ last;
+ }
+ }
+}
+
+sub add_dynamic_symbol {
+ my ($self, $symbol) = @_;
+ $symbol->{objid} = $symbol->{soname} = $self->get_id();
+ $symbol->{soname} =~ s{^.*/}{} unless $self->{SONAME};
+ if ($symbol->{version}) {
+ $self->{dynsyms}{$symbol->{name} . '@' . $symbol->{version}} = $symbol;
+ } else {
+ $self->{dynsyms}{$symbol->{name} . '@Base'} = $symbol;
+ }
+}
+
+sub get_id {
+ my $self = shift;
+ return $self->{SONAME} || $self->{file};
+}
+
+sub get_symbol {
+ my ($self, $name) = @_;
+ if (exists $self->{dynsyms}{$name}) {
+ return $self->{dynsyms}{$name};
+ }
+ if ($name !~ /@/) {
+ if (exists $self->{dynsyms}{$name . '@Base'}) {
+ return $self->{dynsyms}{$name . '@Base'};
+ }
+ }
+ return;
+}
+
+sub get_exported_dynamic_symbols {
+ my $self = shift;
+ return grep {
+ $_->{defined} && $_->{dynamic} && !$_->{local}
+ } values %{$self->{dynsyms}};
+}
+
+sub get_undefined_dynamic_symbols {
+ my $self = shift;
+ return grep {
+ (!$_->{defined}) && $_->{dynamic}
+ } values %{$self->{dynsyms}};
+}
+
+sub get_needed_libraries {
+ my $self = shift;
+ return @{$self->{NEEDED}};
+}
+
+sub is_executable {
+ my $self = shift;
+ return (exists $self->{flags}{EXEC_P} && $self->{flags}{EXEC_P}) ||
+ (exists $self->{INTERP} && $self->{INTERP});
+}
+
+sub is_public_library {
+ my $self = shift;
+ return exists $self->{flags}{DYNAMIC} && $self->{flags}{DYNAMIC}
+ && exists $self->{SONAME} && $self->{SONAME};
+}
+
+1;
diff --git a/scripts/Dpkg/Shlibs/Symbol.pm b/scripts/Dpkg/Shlibs/Symbol.pm
new file mode 100644
index 0000000..e6460ce
--- /dev/null
+++ b/scripts/Dpkg/Shlibs/Symbol.pm
@@ -0,0 +1,531 @@
+# Copyright © 2007 Raphaël Hertzog <hertzog@debian.org>
+# Copyright © 2009-2010 Modestas Vainius <modax@debian.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+package Dpkg::Shlibs::Symbol;
+
+use strict;
+use warnings;
+
+our $VERSION = '0.01';
+
+use Storable ();
+use List::Util qw(any);
+
+use Dpkg::Gettext;
+use Dpkg::ErrorHandling;
+use Dpkg::Arch qw(debarch_is_concerned debarch_to_abiattrs);
+use Dpkg::Version;
+use Dpkg::Shlibs::Cppfilt;
+
+# Supported alias types in the order of matching preference
+use constant ALIAS_TYPES => qw(
+ c++
+ symver
+);
+
+# Needed by the deprecated key, which is a correct use.
+no if $Dpkg::Version::VERSION ge '1.02',
+ warnings => qw(Dpkg::Version::semantic_change::overload::bool);
+
+sub new {
+ my ($this, %args) = @_;
+ my $class = ref($this) || $this;
+ my $self = bless {
+ symbol => undef,
+ symbol_templ => undef,
+ minver => undef,
+ dep_id => 0,
+ deprecated => 0,
+ tags => {},
+ tagorder => [],
+ }, $class;
+ $self->{$_} = $args{$_} foreach keys %args;
+ return $self;
+}
+
+# Deep clone
+sub clone {
+ my ($self, %args) = @_;
+ my $clone = Storable::dclone($self);
+ $clone->{$_} = $args{$_} foreach keys %args;
+ return $clone;
+}
+
+sub parse_tagspec {
+ my ($self, $tagspec) = @_;
+
+ if ($tagspec =~ /^\s*\((.*?)\)(.*)$/ && $1) {
+ # (tag1=t1 value|tag2|...|tagN=tNp)
+ # Symbols ()|= cannot appear in the tag names and values
+ my $tagspec = $1;
+ my $rest = ($2) ? $2 : '';
+ my @tags = split(/\|/, $tagspec);
+
+ # Parse each tag
+ for my $tag (@tags) {
+ if ($tag =~ /^(.*)=(.*)$/) {
+ # Tag with value
+ $self->add_tag($1, $2);
+ } else {
+ # Tag without value
+ $self->add_tag($tag, undef);
+ }
+ }
+ return $rest;
+ }
+ return;
+}
+
+sub parse_symbolspec {
+ my ($self, $symbolspec, %opts) = @_;
+ my $symbol;
+ my $symbol_templ;
+ my $symbol_quoted;
+ my $rest;
+
+ if (defined($symbol = $self->parse_tagspec($symbolspec))) {
+ # (tag1=t1 value|tag2|...|tagN=tNp)"Foo::Bar::foobar()"@Base 1.0 1
+ # Symbols ()|= cannot appear in the tag names and values
+
+ # If the tag specification exists symbol name template might be quoted too
+ if ($symbol =~ /^(['"])/ && $symbol =~ /^($1)(.*?)$1(.*)$/) {
+ $symbol_quoted = $1;
+ $symbol_templ = $2;
+ $symbol = $2;
+ $rest = $3;
+ } else {
+ if ($symbol =~ m/^(\S+)(.*)$/) {
+ $symbol_templ = $1;
+ $symbol = $1;
+ $rest = $2;
+ }
+ }
+ error(g_('symbol name unspecified: %s'), $symbolspec) if (!$symbol);
+ } else {
+ # No tag specification. Symbol name is up to the first space
+ # foobarsymbol@Base 1.0 1
+ if ($symbolspec =~ m/^(\S+)(.*)$/) {
+ $symbol = $1;
+ $rest = $2;
+ } else {
+ return 0;
+ }
+ }
+ $self->{symbol} = $symbol;
+ $self->{symbol_templ} = $symbol_templ;
+ $self->{symbol_quoted} = $symbol_quoted if ($symbol_quoted);
+
+ # Now parse "the rest" (minver and dep_id)
+ if ($rest =~ /^\s(\S+)(?:\s(\d+))?/) {
+ $self->{minver} = $1;
+ $self->{dep_id} = $2 // 0;
+ } elsif (defined $opts{default_minver}) {
+ $self->{minver} = $opts{default_minver};
+ $self->{dep_id} = 0;
+ } else {
+ return 0;
+ }
+ return 1;
+}
+
+# A hook for symbol initialization (typically processing of tags). The code
+# here may even change symbol name. Called from
+# Dpkg::Shlibs::SymbolFile::create_symbol().
+sub initialize {
+ my $self = shift;
+
+ # Look for tags marking symbol patterns. The pattern may match multiple
+ # real symbols.
+ my $type;
+ if ($self->has_tag('c++')) {
+ # Raw symbol name is always demangled to the same alias while demangled
+ # symbol name cannot be reliably converted back to raw symbol name.
+ # Therefore, we can use hash for mapping.
+ $type = 'alias-c++';
+ }
+
+ # Support old style wildcard syntax. That's basically a symver
+ # with an optional tag.
+ if ($self->get_symbolname() =~ /^\*@(.*)$/) {
+ $self->add_tag('symver') unless $self->has_tag('symver');
+ $self->add_tag('optional') unless $self->has_tag('optional');
+ $self->{symbol} = $1;
+ }
+
+ if ($self->has_tag('symver')) {
+ # Each symbol is matched against its version rather than full
+ # name@version string.
+ $type = (defined $type) ? 'generic' : 'alias-symver';
+ if ($self->get_symbolname() =~ /@/) {
+ warning(g_('symver tag with versioned symbol will not match: %s'),
+ $self->get_symbolspec(1));
+ }
+ if ($self->get_symbolname() eq 'Base') {
+ error(g_("you can't use symver tag to catch unversioned symbols: %s"),
+ $self->get_symbolspec(1));
+ }
+ }
+
+ # As soon as regex is involved, we need to match each real
+ # symbol against each pattern (aka 'generic' pattern).
+ if ($self->has_tag('regex')) {
+ $type = 'generic';
+ # Pre-compile regular expression for better performance.
+ my $regex = $self->get_symbolname();
+ $self->{pattern}{regex} = qr/$regex/;
+ }
+ if (defined $type) {
+ $self->init_pattern($type);
+ }
+}
+
+sub get_symbolname {
+ my $self = shift;
+
+ return $self->{symbol};
+}
+
+sub get_symboltempl {
+ my $self = shift;
+
+ return $self->{symbol_templ} || $self->{symbol};
+}
+
+sub set_symbolname {
+ my ($self, $name, $templ, $quoted) = @_;
+
+ $name //= $self->{symbol};
+ if (!defined $templ && $name =~ /\s/) {
+ $templ = $name;
+ }
+ if (!defined $quoted && defined $templ && $templ =~ /\s/) {
+ $quoted = '"';
+ }
+ $self->{symbol} = $name;
+ $self->{symbol_templ} = $templ;
+ if ($quoted) {
+ $self->{symbol_quoted} = $quoted;
+ } else {
+ delete $self->{symbol_quoted};
+ }
+}
+
+sub has_tags {
+ my $self = shift;
+ return scalar (@{$self->{tagorder}});
+}
+
+sub add_tag {
+ my ($self, $tagname, $tagval) = @_;
+ if (exists $self->{tags}{$tagname}) {
+ $self->{tags}{$tagname} = $tagval;
+ return 0;
+ } else {
+ $self->{tags}{$tagname} = $tagval;
+ push @{$self->{tagorder}}, $tagname;
+ }
+ return 1;
+}
+
+sub delete_tag {
+ my ($self, $tagname) = @_;
+ if (exists $self->{tags}{$tagname}) {
+ delete $self->{tags}{$tagname};
+ $self->{tagorder} = [ grep { $_ ne $tagname } @{$self->{tagorder}} ];
+ return 1;
+ }
+ return 0;
+}
+
+sub has_tag {
+ my ($self, $tag) = @_;
+ return exists $self->{tags}{$tag};
+}
+
+sub get_tag_value {
+ my ($self, $tag) = @_;
+ return $self->{tags}{$tag};
+}
+
+# Checks if the symbol is equal to another one (by name and optionally,
+# tag sets, versioning info (minver and depid))
+sub equals {
+ my ($self, $other, %opts) = @_;
+ $opts{versioning} //= 1;
+ $opts{tags} //= 1;
+
+ return 0 if $self->{symbol} ne $other->{symbol};
+
+ if ($opts{versioning}) {
+ return 0 if $self->{minver} ne $other->{minver};
+ return 0 if $self->{dep_id} ne $other->{dep_id};
+ }
+
+ if ($opts{tags}) {
+ return 0 if scalar(@{$self->{tagorder}}) != scalar(@{$other->{tagorder}});
+
+ for my $i (0 .. scalar(@{$self->{tagorder}}) - 1) {
+ my $tag = $self->{tagorder}->[$i];
+ return 0 if $tag ne $other->{tagorder}->[$i];
+ if (defined $self->{tags}{$tag} && defined $other->{tags}{$tag}) {
+ return 0 if $self->{tags}{$tag} ne $other->{tags}{$tag};
+ } elsif (defined $self->{tags}{$tag} || defined $other->{tags}{$tag}) {
+ return 0;
+ }
+ }
+ }
+
+ return 1;
+}
+
+
+sub is_optional {
+ my $self = shift;
+ return $self->has_tag('optional');
+}
+
+sub is_arch_specific {
+ my $self = shift;
+ return $self->has_tag('arch');
+}
+
+sub arch_is_concerned {
+ my ($self, $arch) = @_;
+ my $arches = $self->{tags}{arch};
+
+ return 0 if defined $arch && defined $arches &&
+ !debarch_is_concerned($arch, split /[\s,]+/, $arches);
+
+ my ($bits, $endian) = debarch_to_abiattrs($arch);
+ return 0 if defined $bits && defined $self->{tags}{'arch-bits'} &&
+ $bits ne $self->{tags}{'arch-bits'};
+ return 0 if defined $endian && defined $self->{tags}{'arch-endian'} &&
+ $endian ne $self->{tags}{'arch-endian'};
+
+ return 1;
+}
+
+# Get reference to the pattern the symbol matches (if any)
+sub get_pattern {
+ my $self = shift;
+
+ return $self->{matching_pattern};
+}
+
+### NOTE: subroutines below require (or initialize) $self to be a pattern ###
+
+# Initializes this symbol as a pattern of the specified type.
+sub init_pattern {
+ my ($self, $type) = @_;
+
+ $self->{pattern}{type} = $type;
+ # To be filled with references to symbols matching this pattern.
+ $self->{pattern}{matches} = [];
+}
+
+# Is this symbol a pattern or not?
+sub is_pattern {
+ my $self = shift;
+
+ return exists $self->{pattern};
+}
+
+# Get pattern type if this symbol is a pattern.
+sub get_pattern_type {
+ my $self = shift;
+
+ return $self->{pattern}{type} // '';
+}
+
+# Get (sub)type of the alias pattern. Returns empty string if current
+# pattern is not alias.
+sub get_alias_type {
+ my $self = shift;
+
+ return ($self->get_pattern_type() =~ /^alias-(.+)/ && $1) || '';
+}
+
+# Get a list of symbols matching this pattern if this symbol is a pattern
+sub get_pattern_matches {
+ my $self = shift;
+
+ return @{$self->{pattern}{matches}};
+}
+
+# Create a new symbol based on the pattern (i.e. $self)
+# and add it to the pattern matches list.
+sub create_pattern_match {
+ my $self = shift;
+ return unless $self->is_pattern();
+
+ # Leave out 'pattern' subfield while deep-cloning
+ my $pattern_stuff = $self->{pattern};
+ delete $self->{pattern};
+ my $newsym = $self->clone(@_);
+ $self->{pattern} = $pattern_stuff;
+
+ # Clean up symbol name related internal fields
+ $newsym->set_symbolname();
+
+ # Set newsym pattern reference, add to pattern matches list
+ $newsym->{matching_pattern} = $self;
+ push @{$self->{pattern}{matches}}, $newsym;
+ return $newsym;
+}
+
+### END of pattern subroutines ###
+
+# Given a raw symbol name the call returns its alias according to the rules of
+# the current pattern ($self). Returns undef if the supplied raw name is not
+# transformable to alias.
+sub convert_to_alias {
+ my ($self, $rawname, $type) = @_;
+ $type = $self->get_alias_type() unless $type;
+
+ if ($type) {
+ if ($type eq 'symver') {
+ # In case of symver, alias is symbol version. Extract it from the
+ # rawname.
+ return "$1" if ($rawname =~ /\@([^@]+)$/);
+ } elsif ($rawname =~ /^_Z/ && $type eq 'c++') {
+ return cppfilt_demangle_cpp($rawname);
+ }
+ }
+ return;
+}
+
+sub get_tagspec {
+ my $self = shift;
+ if ($self->has_tags()) {
+ my @tags;
+ for my $tagname (@{$self->{tagorder}}) {
+ my $tagval = $self->{tags}{$tagname};
+ if (defined $tagval) {
+ push @tags, $tagname . '=' . $tagval;
+ } else {
+ push @tags, $tagname;
+ }
+ }
+ return '(' . join('|', @tags) . ')';
+ }
+ return '';
+}
+
+sub get_symbolspec {
+ my $self = shift;
+ my $template_mode = shift;
+ my $spec = '';
+ $spec .= "#MISSING: $self->{deprecated}#" if $self->{deprecated};
+ $spec .= ' ';
+ if ($template_mode) {
+ if ($self->has_tags()) {
+ $spec .= sprintf('%s%3$s%s%3$s', $self->get_tagspec(),
+ $self->get_symboltempl(), $self->{symbol_quoted} // '');
+ } else {
+ $spec .= $self->get_symboltempl();
+ }
+ } else {
+ $spec .= $self->get_symbolname();
+ }
+ $spec .= " $self->{minver}";
+ $spec .= " $self->{dep_id}" if $self->{dep_id};
+ return $spec;
+}
+
+# Sanitize the symbol when it is confirmed to be found in
+# the respective library.
+sub mark_found_in_library {
+ my ($self, $minver, $arch) = @_;
+
+ if ($self->{deprecated}) {
+ # Symbol reappeared somehow
+ $self->{deprecated} = 0;
+ $self->{minver} = $minver if (not $self->is_optional());
+ } else {
+ # We assume that the right dependency information is already
+ # there.
+ if (version_compare($minver, $self->{minver}) < 0) {
+ $self->{minver} = $minver;
+ }
+ }
+ # Never remove arch tags from patterns
+ if (not $self->is_pattern()) {
+ if (not $self->arch_is_concerned($arch)) {
+ # Remove arch tags because they are incorrect.
+ $self->delete_tag('arch');
+ $self->delete_tag('arch-bits');
+ $self->delete_tag('arch-endian');
+ }
+ }
+}
+
+# Sanitize the symbol when it is confirmed to be NOT found in
+# the respective library.
+# Mark as deprecated those that are no more provided (only if the
+# minver is later than the version where the symbol was introduced)
+sub mark_not_found_in_library {
+ my ($self, $minver, $arch) = @_;
+
+ # Ignore symbols from foreign arch
+ return if not $self->arch_is_concerned($arch);
+
+ if ($self->{deprecated}) {
+ # Bump deprecated if the symbol is optional so that it
+ # keeps reappearing in the diff while it's missing
+ $self->{deprecated} = $minver if $self->is_optional();
+ } elsif (version_compare($minver, $self->{minver}) > 0) {
+ $self->{deprecated} = $minver;
+ }
+}
+
+# Checks if the symbol (or pattern) is legitimate as a real symbol for the
+# specified architecture.
+sub is_legitimate {
+ my ($self, $arch) = @_;
+ return ! $self->{deprecated} &&
+ $self->arch_is_concerned($arch);
+}
+
+# Determine whether a supplied raw symbol name matches against current ($self)
+# symbol or pattern.
+sub matches_rawname {
+ my ($self, $rawname) = @_;
+ my $target = $rawname;
+ my $ok = 1;
+ my $do_eq_match = 1;
+
+ if ($self->is_pattern()) {
+ # Process pattern tags in the order they were specified.
+ for my $tag (@{$self->{tagorder}}) {
+ if (any { $tag eq $_ } ALIAS_TYPES) {
+ $ok = not not ($target = $self->convert_to_alias($target, $tag));
+ } elsif ($tag eq 'regex') {
+ # Symbol name is a regex. Match it against the target
+ $do_eq_match = 0;
+ $ok = ($target =~ $self->{pattern}{regex});
+ }
+ last if not $ok;
+ }
+ }
+
+ # Equality match by default
+ if ($ok && $do_eq_match) {
+ $ok = $target eq $self->get_symbolname();
+ }
+ return $ok;
+}
+
+1;
diff --git a/scripts/Dpkg/Shlibs/SymbolFile.pm b/scripts/Dpkg/Shlibs/SymbolFile.pm
new file mode 100644
index 0000000..d492055
--- /dev/null
+++ b/scripts/Dpkg/Shlibs/SymbolFile.pm
@@ -0,0 +1,697 @@
+# Copyright © 2007 Raphaël Hertzog <hertzog@debian.org>
+# Copyright © 2009-2010 Modestas Vainius <modax@debian.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+package Dpkg::Shlibs::SymbolFile;
+
+use strict;
+use warnings;
+
+our $VERSION = '0.01';
+
+use Dpkg::Gettext;
+use Dpkg::ErrorHandling;
+use Dpkg::Version;
+use Dpkg::Control::Fields;
+use Dpkg::Shlibs::Symbol;
+use Dpkg::Arch qw(get_host_arch);
+
+use parent qw(Dpkg::Interface::Storable);
+
+# Needed by the deprecated key, which is a correct use.
+no if $Dpkg::Version::VERSION ge '1.02',
+ warnings => qw(Dpkg::Version::semantic_change::overload::bool);
+
+my %internal_symbol = (
+ __bss_end__ => 1, # arm
+ __bss_end => 1, # arm
+ _bss_end__ => 1, # arm
+ __bss_start => 1, # ALL
+ __bss_start__ => 1, # arm
+ __data_start => 1, # arm
+ __do_global_ctors_aux => 1, # ia64
+ __do_global_dtors_aux => 1, # ia64
+ __do_jv_register_classes => 1, # ia64
+ _DYNAMIC => 1, # ALL
+ _edata => 1, # ALL
+ _end => 1, # ALL
+ __end__ => 1, # arm
+ __exidx_end => 1, # armel
+ __exidx_start => 1, # armel
+ _fbss => 1, # mips, mipsel
+ _fdata => 1, # mips, mipsel
+ _fini => 1, # ALL
+ _ftext => 1, # mips, mipsel
+ _GLOBAL_OFFSET_TABLE_ => 1, # hppa, mips, mipsel
+ __gmon_start__ => 1, # hppa
+ __gnu_local_gp => 1, # mips, mipsel
+ _gp => 1, # mips, mipsel
+ _init => 1, # ALL
+ _PROCEDURE_LINKAGE_TABLE_ => 1, # sparc, alpha
+ _SDA2_BASE_ => 1, # powerpc
+ _SDA_BASE_ => 1, # powerpc
+);
+
+for my $i (14 .. 31) {
+ # Many powerpc specific symbols
+ $internal_symbol{"_restfpr_$i"} = 1;
+ $internal_symbol{"_restfpr_$i\_x"} = 1;
+ $internal_symbol{"_restgpr_$i"} = 1;
+ $internal_symbol{"_restgpr_$i\_x"} = 1;
+ $internal_symbol{"_savefpr_$i"} = 1;
+ $internal_symbol{"_savegpr_$i"} = 1;
+}
+
+sub symbol_is_internal {
+ my ($symbol, $include_groups) = @_;
+
+ return 1 if exists $internal_symbol{$symbol};
+
+ # The ARM Embedded ABI spec states symbols under this namespace as
+ # possibly appearing in output objects.
+ return 1 if not ${$include_groups}{aeabi} and $symbol =~ /^__aeabi_/;
+
+ # The GNU implementation of the OpenMP spec, specifies symbols under
+ # this namespace as possibly appearing in output objects.
+ return 1 if not ${$include_groups}{gomp}
+ and $symbol =~ /^\.gomp_critical_user_/;
+
+ return 0;
+}
+
+sub new {
+ my ($this, %opts) = @_;
+ my $class = ref($this) || $this;
+ my $self = \%opts;
+ bless $self, $class;
+ $self->{arch} //= get_host_arch();
+ $self->clear();
+ if (exists $self->{file}) {
+ $self->load($self->{file}) if -e $self->{file};
+ }
+ return $self;
+}
+
+sub get_arch {
+ my $self = shift;
+ return $self->{arch};
+}
+
+sub clear {
+ my $self = shift;
+ $self->{objects} = {};
+}
+
+sub clear_except {
+ my ($self, @ids) = @_;
+
+ my %has = map { $_ => 1 } @ids;
+ foreach my $objid (keys %{$self->{objects}}) {
+ delete $self->{objects}{$objid} unless exists $has{$objid};
+ }
+}
+
+sub get_sonames {
+ my $self = shift;
+ return keys %{$self->{objects}};
+}
+
+sub get_symbols {
+ my ($self, $soname) = @_;
+ if (defined $soname) {
+ my $obj = $self->get_object($soname);
+ return (defined $obj) ? values %{$obj->{syms}} : ();
+ } else {
+ my @syms;
+ foreach my $soname ($self->get_sonames()) {
+ push @syms, $self->get_symbols($soname);
+ }
+ return @syms;
+ }
+}
+
+sub get_patterns {
+ my ($self, $soname) = @_;
+ my @patterns;
+ if (defined $soname) {
+ my $obj = $self->get_object($soname);
+ foreach my $alias (values %{$obj->{patterns}{aliases}}) {
+ push @patterns, values %$alias;
+ }
+ return (@patterns, @{$obj->{patterns}{generic}});
+ } else {
+ foreach my $soname ($self->get_sonames()) {
+ push @patterns, $self->get_patterns($soname);
+ }
+ return @patterns;
+ }
+}
+
+# Create a symbol from the supplied string specification.
+sub create_symbol {
+ my ($self, $spec, %opts) = @_;
+ my $symbol = (exists $opts{base}) ? $opts{base} :
+ Dpkg::Shlibs::Symbol->new();
+
+ my $ret = $opts{dummy} ? $symbol->parse_symbolspec($spec, default_minver => 0) :
+ $symbol->parse_symbolspec($spec);
+ if ($ret) {
+ $symbol->initialize(arch => $self->get_arch());
+ return $symbol;
+ }
+ return;
+}
+
+sub add_symbol {
+ my ($self, $symbol, $soname) = @_;
+ my $object = $self->get_object($soname);
+
+ if ($symbol->is_pattern()) {
+ if (my $alias_type = $symbol->get_alias_type()) {
+ $object->{patterns}{aliases}{$alias_type} //= {};
+ # Alias hash for matching.
+ my $aliases = $object->{patterns}{aliases}{$alias_type};
+ $aliases->{$symbol->get_symbolname()} = $symbol;
+ } else {
+ # Otherwise assume this is a generic sequential pattern. This
+ # should be always safe.
+ push @{$object->{patterns}{generic}}, $symbol;
+ }
+ return 'pattern';
+ } else {
+ # invalidate the minimum version cache
+ $object->{minver_cache} = [];
+ $object->{syms}{$symbol->get_symbolname()} = $symbol;
+ return 'sym';
+ }
+}
+
+sub _new_symbol {
+ my $base = shift || 'Dpkg::Shlibs::Symbol';
+ return (ref $base) ? $base->clone(@_) : $base->new(@_);
+}
+
+# Option state is only used for recursive calls.
+sub parse {
+ my ($self, $fh, $file, %opts) = @_;
+ my $state = $opts{state} //= {};
+
+ if (exists $state->{seen}) {
+ return if exists $state->{seen}{$file}; # Avoid include loops
+ } else {
+ $self->{file} = $file;
+ $state->{seen} = {};
+ }
+ $state->{seen}{$file} = 1;
+
+ if (not ref $state->{obj_ref}) { # Init ref to name of current object/lib
+ ${$state->{obj_ref}} = undef;
+ }
+
+ while (<$fh>) {
+ chomp;
+
+ if (/^(?:\s+|#(?:DEPRECATED|MISSING): ([^#]+)#\s*)(.*)/) {
+ if (not defined ${$state->{obj_ref}}) {
+ error(g_('symbol information must be preceded by a header (file %s, line %s)'), $file, $.);
+ }
+ # Symbol specification
+ my $deprecated = ($1) ? Dpkg::Version->new($1) : 0;
+ my $sym = _new_symbol($state->{base_symbol}, deprecated => $deprecated);
+ if ($self->create_symbol($2, base => $sym)) {
+ $self->add_symbol($sym, ${$state->{obj_ref}});
+ } else {
+ warning(g_('failed to parse line in %s: %s'), $file, $_);
+ }
+ } elsif (/^(\(.*\))?#include\s+"([^"]+)"/) {
+ my $tagspec = $1;
+ my $filename = $2;
+ my $dir = $file;
+ my $old_base_symbol = $state->{base_symbol};
+ my $new_base_symbol;
+ if (defined $tagspec) {
+ $new_base_symbol = _new_symbol($old_base_symbol);
+ $new_base_symbol->parse_tagspec($tagspec);
+ }
+ $state->{base_symbol} = $new_base_symbol;
+ $dir =~ s{[^/]+$}{}; # Strip filename
+ $self->load("$dir$filename", %opts);
+ $state->{base_symbol} = $old_base_symbol;
+ } elsif (/^#|^$/) {
+ # Skip possible comments and empty lines
+ } elsif (/^\|\s*(.*)$/) {
+ # Alternative dependency template
+ push @{$self->{objects}{${$state->{obj_ref}}}{deps}}, "$1";
+ } elsif (/^\*\s*([^:]+):\s*(.*\S)\s*$/) {
+ # Add meta-fields
+ $self->{objects}{${$state->{obj_ref}}}{fields}{field_capitalize($1)} = $2;
+ } elsif (/^(\S+)\s+(.*)$/) {
+ # New object and dependency template
+ ${$state->{obj_ref}} = $1;
+ if (exists $self->{objects}{${$state->{obj_ref}}}) {
+ # Update/override infos only
+ $self->{objects}{${$state->{obj_ref}}}{deps} = [ "$2" ];
+ } else {
+ # Create a new object
+ $self->create_object(${$state->{obj_ref}}, "$2");
+ }
+ } else {
+ warning(g_('failed to parse a line in %s: %s'), $file, $_);
+ }
+ }
+ delete $state->{seen}{$file};
+}
+
+# Beware: we reuse the data structure of the provided symfile so make
+# sure to not modify them after having called this function
+sub merge_object_from_symfile {
+ my ($self, $src, $objid) = @_;
+ if (not $self->has_object($objid)) {
+ $self->{objects}{$objid} = $src->get_object($objid);
+ } else {
+ warning(g_('tried to merge the same object (%s) twice in a symfile'), $objid);
+ }
+}
+
+sub output {
+ my ($self, $fh, %opts) = @_;
+ $opts{template_mode} //= 0;
+ $opts{with_deprecated} //= 1;
+ $opts{with_pattern_matches} //= 0;
+ my $res = '';
+ foreach my $soname (sort $self->get_sonames()) {
+ my @deps = $self->get_dependencies($soname);
+ my $dep_first = shift @deps;
+ if (exists $opts{package} and not $opts{template_mode}) {
+ $dep_first =~ s/#PACKAGE#/$opts{package}/g;
+ }
+ print { $fh } "$soname $dep_first\n" if defined $fh;
+ $res .= "$soname $dep_first\n" if defined wantarray;
+
+ foreach my $dep_next (@deps) {
+ if (exists $opts{package} and not $opts{template_mode}) {
+ $dep_next =~ s/#PACKAGE#/$opts{package}/g;
+ }
+ print { $fh } "| $dep_next\n" if defined $fh;
+ $res .= "| $dep_next\n" if defined wantarray;
+ }
+ my $f = $self->{objects}{$soname}{fields};
+ foreach my $field (sort keys %{$f}) {
+ my $value = $f->{$field};
+ if (exists $opts{package} and not $opts{template_mode}) {
+ $value =~ s/#PACKAGE#/$opts{package}/g;
+ }
+ print { $fh } "* $field: $value\n" if defined $fh;
+ $res .= "* $field: $value\n" if defined wantarray;
+ }
+
+ my @symbols;
+ if ($opts{template_mode}) {
+ # Exclude symbols matching a pattern, but include patterns themselves
+ @symbols = grep { not $_->get_pattern() } $self->get_symbols($soname);
+ push @symbols, $self->get_patterns($soname);
+ } else {
+ @symbols = $self->get_symbols($soname);
+ }
+ foreach my $sym (sort { $a->get_symboltempl() cmp
+ $b->get_symboltempl() } @symbols) {
+ next if $sym->{deprecated} and not $opts{with_deprecated};
+ # Do not dump symbols from foreign arch unless dumping a template.
+ next if not $opts{template_mode} and
+ not $sym->arch_is_concerned($self->get_arch());
+ # Dump symbol specification. Dump symbol tags only in template mode.
+ print { $fh } $sym->get_symbolspec($opts{template_mode}), "\n" if defined $fh;
+ $res .= $sym->get_symbolspec($opts{template_mode}) . "\n" if defined wantarray;
+ # Dump pattern matches as comments (if requested)
+ if ($opts{with_pattern_matches} && $sym->is_pattern()) {
+ for my $match (sort { $a->get_symboltempl() cmp
+ $b->get_symboltempl() } $sym->get_pattern_matches())
+ {
+ print { $fh } '#MATCH:', $match->get_symbolspec(0), "\n" if defined $fh;
+ $res .= '#MATCH:' . $match->get_symbolspec(0) . "\n" if defined wantarray;
+ }
+ }
+ }
+ }
+ return $res;
+}
+
+# Tries to match a symbol name and/or version against the patterns defined.
+# Returns a pattern which matches (if any).
+sub find_matching_pattern {
+ my ($self, $refsym, $sonames, $inc_deprecated) = @_;
+ $inc_deprecated //= 0;
+ my $name = (ref $refsym) ? $refsym->get_symbolname() : $refsym;
+
+ my $pattern_ok = sub {
+ my $p = shift;
+ return defined $p && ($inc_deprecated || !$p->{deprecated}) &&
+ $p->arch_is_concerned($self->get_arch());
+ };
+
+ foreach my $soname ((ref($sonames) eq 'ARRAY') ? @$sonames : $sonames) {
+ my $obj = $self->get_object($soname);
+ my ($type, $pattern);
+ next unless defined $obj;
+
+ my $all_aliases = $obj->{patterns}{aliases};
+ for my $type (Dpkg::Shlibs::Symbol::ALIAS_TYPES) {
+ if (exists $all_aliases->{$type} && keys(%{$all_aliases->{$type}})) {
+ my $aliases = $all_aliases->{$type};
+ my $converter = $aliases->{(keys %$aliases)[0]};
+ if (my $alias = $converter->convert_to_alias($name)) {
+ if ($alias && exists $aliases->{$alias}) {
+ $pattern = $aliases->{$alias};
+ last if $pattern_ok->($pattern);
+ $pattern = undef; # otherwise not found yet
+ }
+ }
+ }
+ }
+
+ # Now try generic patterns and use the first that matches
+ if (not defined $pattern) {
+ for my $p (@{$obj->{patterns}{generic}}) {
+ if ($pattern_ok->($p) && $p->matches_rawname($name)) {
+ $pattern = $p;
+ last;
+ }
+ }
+ }
+ if (defined $pattern) {
+ return (wantarray) ?
+ ( symbol => $pattern, soname => $soname ) : $pattern;
+ }
+ }
+ return;
+}
+
+# merge_symbols($object, $minver)
+# Needs $Objdump->get_object($soname) as parameter
+# Do not merge symbols found in the list of (arch-specific) internal symbols.
+sub merge_symbols {
+ my ($self, $object, $minver) = @_;
+
+ my $soname = $object->{SONAME};
+ error(g_('cannot merge symbols from objects without SONAME'))
+ unless $soname;
+
+ my %include_groups = ();
+ my $groups = $self->get_field($soname, 'Allow-Internal-Symbol-Groups');
+ if (not defined $groups) {
+ $groups = $self->get_field($soname, 'Ignore-Blacklist-Groups');
+ if (defined $groups) {
+ warnings::warnif('deprecated',
+ 'symbols file field "Ignore-Blacklist-Groups" is deprecated, ' .
+ 'use "Allow-Internal-Symbol-Groups" instead');
+ }
+ }
+ if (defined $groups) {
+ $include_groups{$_} = 1 foreach (split ' ', $groups);
+ }
+
+ my %dynsyms;
+ foreach my $sym ($object->get_exported_dynamic_symbols()) {
+ my $name = $sym->{name} . '@' .
+ ($sym->{version} ? $sym->{version} : 'Base');
+ my $symobj = $self->lookup_symbol($name, $soname);
+ if (symbol_is_internal($sym->{name}, \%include_groups)) {
+ next unless defined $symobj;
+
+ if ($symobj->has_tag('allow-internal')) {
+ # Allow the symbol.
+ } elsif ($symobj->has_tag('ignore-blacklist')) {
+ # Allow the symbol and warn.
+ warnings::warnif('deprecated',
+ 'symbol tag "ignore-blacklist" is deprecated, ' .
+ 'use "allow-internal" instead');
+ } else {
+ # Ignore the symbol.
+ next;
+ }
+ }
+ $dynsyms{$name} = $sym;
+ }
+
+ unless ($self->has_object($soname)) {
+ $self->create_object($soname, '');
+ }
+ # Scan all symbols provided by the objects
+ my $obj = $self->get_object($soname);
+ # invalidate the minimum version cache - it is not sufficient to
+ # invalidate in add_symbol, since we might change a minimum
+ # version for a particular symbol without adding it
+ $obj->{minver_cache} = [];
+ foreach my $name (keys %dynsyms) {
+ my $sym;
+ if ($sym = $self->lookup_symbol($name, $obj, 1)) {
+ # If the symbol is already listed in the file
+ $sym->mark_found_in_library($minver, $self->get_arch());
+ } else {
+ # The exact symbol is not present in the file, but it might match a
+ # pattern.
+ my $pattern = $self->find_matching_pattern($name, $obj, 1);
+ if (defined $pattern) {
+ $pattern->mark_found_in_library($minver, $self->get_arch());
+ $sym = $pattern->create_pattern_match(symbol => $name);
+ } else {
+ # Symbol without any special info as no pattern matched
+ $sym = Dpkg::Shlibs::Symbol->new(symbol => $name,
+ minver => $minver);
+ }
+ $self->add_symbol($sym, $obj);
+ }
+ }
+
+ # Process all symbols which could not be found in the library.
+ foreach my $sym ($self->get_symbols($soname)) {
+ if (not exists $dynsyms{$sym->get_symbolname()}) {
+ $sym->mark_not_found_in_library($minver, $self->get_arch());
+ }
+ }
+
+ # Deprecate patterns which didn't match anything
+ for my $pattern (grep { $_->get_pattern_matches() == 0 }
+ $self->get_patterns($soname)) {
+ $pattern->mark_not_found_in_library($minver, $self->get_arch());
+ }
+}
+
+sub is_empty {
+ my $self = shift;
+ return scalar(keys %{$self->{objects}}) ? 0 : 1;
+}
+
+sub has_object {
+ my ($self, $soname) = @_;
+ return exists $self->{objects}{$soname};
+}
+
+sub get_object {
+ my ($self, $soname) = @_;
+ return ref($soname) ? $soname : $self->{objects}{$soname};
+}
+
+sub create_object {
+ my ($self, $soname, @deps) = @_;
+ $self->{objects}{$soname} = {
+ syms => {},
+ fields => {},
+ patterns => {
+ aliases => {},
+ generic => [],
+ },
+ deps => [ @deps ],
+ minver_cache => []
+ };
+}
+
+sub get_dependency {
+ my ($self, $soname, $dep_id) = @_;
+ $dep_id //= 0;
+ return $self->get_object($soname)->{deps}[$dep_id];
+}
+
+sub get_smallest_version {
+ my ($self, $soname, $dep_id) = @_;
+ $dep_id //= 0;
+ my $so_object = $self->get_object($soname);
+ return $so_object->{minver_cache}[$dep_id]
+ if defined $so_object->{minver_cache}[$dep_id];
+ my $minver;
+ foreach my $sym ($self->get_symbols($so_object)) {
+ next if $dep_id != $sym->{dep_id};
+ $minver //= $sym->{minver};
+ if (version_compare($minver, $sym->{minver}) > 0) {
+ $minver = $sym->{minver};
+ }
+ }
+ $so_object->{minver_cache}[$dep_id] = $minver;
+ return $minver;
+}
+
+sub get_dependencies {
+ my ($self, $soname) = @_;
+ return @{$self->get_object($soname)->{deps}};
+}
+
+sub get_field {
+ my ($self, $soname, $name) = @_;
+ if (my $obj = $self->get_object($soname)) {
+ if (exists $obj->{fields}{$name}) {
+ return $obj->{fields}{$name};
+ }
+ }
+ return;
+}
+
+# Tries to find a symbol like the $refsym and returns its descriptor.
+# $refsym may also be a symbol name.
+sub lookup_symbol {
+ my ($self, $refsym, $sonames, $inc_deprecated) = @_;
+ $inc_deprecated //= 0;
+ my $name = (ref $refsym) ? $refsym->get_symbolname() : $refsym;
+
+ foreach my $so ((ref($sonames) eq 'ARRAY') ? @$sonames : $sonames) {
+ if (my $obj = $self->get_object($so)) {
+ my $sym = $obj->{syms}{$name};
+ if ($sym and ($inc_deprecated or not $sym->{deprecated}))
+ {
+ return (wantarray) ?
+ ( symbol => $sym, soname => $so ) : $sym;
+ }
+ }
+ }
+ return;
+}
+
+# Tries to find a pattern like the $refpat and returns its descriptor.
+# $refpat may also be a pattern spec.
+sub lookup_pattern {
+ my ($self, $refpat, $sonames, $inc_deprecated) = @_;
+ $inc_deprecated //= 0;
+ # If $refsym is a string, we need to create a dummy ref symbol.
+ $refpat = $self->create_symbol($refpat, dummy => 1) if ! ref($refpat);
+
+ if ($refpat && $refpat->is_pattern()) {
+ foreach my $soname ((ref($sonames) eq 'ARRAY') ? @$sonames : $sonames) {
+ if (my $obj = $self->get_object($soname)) {
+ my $pat;
+ if (my $type = $refpat->get_alias_type()) {
+ if (exists $obj->{patterns}{aliases}{$type}) {
+ $pat = $obj->{patterns}{aliases}{$type}{$refpat->get_symbolname()};
+ }
+ } elsif ($refpat->get_pattern_type() eq 'generic') {
+ for my $p (@{$obj->{patterns}{generic}}) {
+ if (($inc_deprecated || !$p->{deprecated}) &&
+ $p->equals($refpat, versioning => 0))
+ {
+ $pat = $p;
+ last;
+ }
+ }
+ }
+ if ($pat && ($inc_deprecated || !$pat->{deprecated})) {
+ return (wantarray) ?
+ (symbol => $pat, soname => $soname) : $pat;
+ }
+ }
+ }
+ }
+ return;
+}
+
+# Get symbol object reference either by symbol name or by a reference object.
+sub get_symbol_object {
+ my ($self, $refsym, $soname) = @_;
+ my $sym = $self->lookup_symbol($refsym, $soname, 1);
+ if (! defined $sym) {
+ $sym = $self->lookup_pattern($refsym, $soname, 1);
+ }
+ return $sym;
+}
+
+sub get_new_symbols {
+ my ($self, $ref, %opts) = @_;
+ my $with_optional = (exists $opts{with_optional}) ?
+ $opts{with_optional} : 0;
+ my @res;
+ foreach my $soname ($self->get_sonames()) {
+ next if not $ref->has_object($soname);
+
+ # Scan raw symbols first.
+ foreach my $sym (grep { ($with_optional || ! $_->is_optional())
+ && $_->is_legitimate($self->get_arch()) }
+ $self->get_symbols($soname))
+ {
+ my $refsym = $ref->lookup_symbol($sym, $soname, 1);
+ my $isnew;
+ if (defined $refsym) {
+ # If the symbol exists in the $ref symbol file, it might
+ # still be new if $refsym is not legitimate.
+ $isnew = not $refsym->is_legitimate($self->get_arch());
+ } else {
+ # If the symbol does not exist in the $ref symbol file, it does
+ # not mean that it's new. It might still match a pattern in the
+ # symbol file. However, due to performance reasons, first check
+ # if the pattern that the symbol matches (if any) exists in the
+ # ref symbol file as well.
+ $isnew = not (
+ ($sym->get_pattern() and $ref->lookup_pattern($sym->get_pattern(), $soname, 1)) or
+ $ref->find_matching_pattern($sym, $soname, 1)
+ );
+ }
+ push @res, { symbol => $sym, soname => $soname } if $isnew;
+ }
+
+ # Now scan patterns
+ foreach my $p (grep { ($with_optional || ! $_->is_optional())
+ && $_->is_legitimate($self->get_arch()) }
+ $self->get_patterns($soname))
+ {
+ my $refpat = $ref->lookup_pattern($p, $soname, 0);
+ # If reference pattern was not found or it is not legitimate,
+ # considering current one as new.
+ if (not defined $refpat or
+ not $refpat->is_legitimate($self->get_arch()))
+ {
+ push @res, { symbol => $p , soname => $soname };
+ }
+ }
+ }
+ return @res;
+}
+
+sub get_lost_symbols {
+ my ($self, $ref, %opts) = @_;
+ return $ref->get_new_symbols($self, %opts);
+}
+
+
+sub get_new_libs {
+ my ($self, $ref) = @_;
+ my @res;
+ foreach my $soname ($self->get_sonames()) {
+ push @res, $soname if not $ref->get_object($soname);
+ }
+ return @res;
+}
+
+sub get_lost_libs {
+ my ($self, $ref) = @_;
+ return $ref->get_new_libs($self);
+}
+
+1;