Dpkg::Shlibs:* add more abstract methods and clean up API.

* Make SymbolFile::lookup_*(), SymbolFile::find_matching_pattern() accept both
  symbol/pattern objects AND names.
* Make SymbolFile::lookup_*(), SymbolFile::find_matching_pattern() accept both
  single soname and an array of sonames.
* Make SymbolFile::lookup_*(), SymbolFile::find_matching_pattern() detect
  context and return either a hash of ( soname => .., symbol => .. ) or just a
  scalar symbol reference. In either case, do NOT clone symbols.
* SymbolFile::get_{new,lost}_symbols() returns an array of { soname =>
  .., symbol => .. } hashes where 'symbol' is a real reference, not a clone.
* Add new abstract methods and use them everywhere:
  - SymbolFile::get_arch() - architecture the file is processed under/for.
  - SymbolFile::get_sonames() - names of all sonames.
  - SymbolFile::get_object() - soname object reference by name or object
    reference.
  - SymbolFile::get_symbols($soname) - if $soname is undef, returns ALL
    symbol file symbols.
  - SymbolFile::get_patterns($soname) - if $soname is undef, returns ALL
    symbol file patterns.
  - SymbolFile::get_symbol_object(Ssym, $soname) - a convenience method
    combining both SymbolFile::lookup_{symbol,pattern} methods.
* Make SymbolFile::create_symbol() more flexible. Now it can parse a dummy spec
  without minver.
* Remove Symbol::sclone() as no longer used and needed. Rename Symbol::dclone()
  back to Symbol::clone().

scripts/Dpkg/Shlibs/Symbol.pm

@@ -45,19 +45,8 @@ sub new {
     return $self;
 }
 
-# Shallow clone
-sub sclone {
-    my $self = shift;
-    my $clone = { %$self };
-    if (@_) {
-	my %args=@_;
-	$clone->{$_} = $args{$_} foreach keys %args;
-    }
-    return bless $clone, ref $self;
-}
-
 # Deep clone
-sub dclone {
+sub clone {
     my $self = shift;
     my $clone = Storable::dclone($self);
     if (@_) {
@@ -93,7 +82,7 @@ sub parse_tagspec {
 }
 
 sub parse {
-    my ($self, $symbolspec) = @_;
+    my ($self, $symbolspec, %opts) = @_;
     my $symbol;
     my $symbol_templ;
     my $symbol_quoted;
@@ -135,6 +124,9 @@ sub parse {
     if ($rest =~ /^\s(\S+)(?:\s(\d+))?/) {
 	$self->{minver} = $1;
 	$self->{dep_id} = defined($2) ? $2 : 0;
+    } elsif (defined $opts{default_minver}) {
+	$self->{minver} = $opts{default_minver};
+	$self->{dep_id} = 0;
     } else {
 	return 0;
     }
@@ -354,7 +346,7 @@ sub create_pattern_match {
     # Leave out 'pattern' subfield while deep-cloning
     my $pattern_stuff = $self->{pattern};
     delete $self->{pattern};
-    my $newsym = $self->dclone(@_);
+    my $newsym = $self->clone(@_);
     $self->{pattern} = $pattern_stuff;
 
     # Clean up symbol name related internal fields

scripts/Dpkg/Shlibs/SymbolFile.pm

@@ -88,6 +88,11 @@ sub new {
     return $self;
 }
 
+sub get_arch {
+    my ($self) = @_;
+    return $self->{arch};
+}
+
 sub clear {
     my ($self) = @_;
     $self->{objects} = {};
@@ -102,13 +107,52 @@ sub clear_except {
     }
 }
 
+sub get_sonames {
+    my ($self) = @_;
+    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, $symbol) = @_;
-    $symbol = Dpkg::Shlibs::Symbol->new() unless defined $symbol;
-
-    if ($symbol->parse($spec)) {
-	$symbol->initialize(arch => $self->{arch});
+    my ($self, $spec, %opts) = @_;
+    my $symbol = (exists $opts{base}) ? $opts{base} :
+	Dpkg::Shlibs::Symbol->new();
+
+    my $ret = ($opts{dummy}) ? $symbol->parse($spec, default_minver => 0) :
+	$symbol->parse($spec);
+    if ($ret) {
+	$symbol->initialize(arch => $self->get_arch());
 	return $symbol;
     }
     return undef;
@@ -116,7 +160,7 @@ sub create_symbol {
 
 sub add_symbol {
     my ($self, $symbol, $soname) = @_;
-    my $object = (ref $soname) ? $soname : $self->{objects}{$soname};
+    my $object = $self->get_object($soname);
 
     if ($symbol->is_pattern()) {
 	if (my $alias_type = $symbol->get_alias_type()) {
@@ -146,7 +190,7 @@ sub load {
 
     sub new_symbol {
         my $base = shift || 'Dpkg::Shlibs::Symbol';
-        return (ref $base) ? $base->dclone(@_) : $base->new(@_);
+        return (ref $base) ? $base->clone(@_) : $base->new(@_);
     }
 
     if (defined($seen)) {
@@ -173,7 +217,7 @@ sub load {
 	    # Symbol specification
 	    my $deprecated = ($1) ? $1 : 0;
 	    my $sym = new_symbol($base_symbol, deprecated => $deprecated);
-	    if ($self->create_symbol($2, $sym)) {
+	    if ($self->create_symbol($2, base => $sym)) {
 		$self->add_symbol($sym, $$obj_ref);
 	    } else {
 		warning(_g("Failed to parse line in %s: %s"), $file, $_);
@@ -220,7 +264,7 @@ sub load {
 sub merge_object_from_symfile {
     my ($self, $src, $objid) = @_;
     if (not $self->has_object($objid)) {
-        $self->{objects}{$objid} = $src->{objects}{$objid};
+        $self->{objects}{$objid} = $src->get_object($objid);
     } else {
         warning(_g("Tried to merge the same object (%s) twice in a symfile."), $objid);
     }
@@ -245,8 +289,8 @@ sub dump {
     $opts{template_mode} = 0 unless exists $opts{template_mode};
     $opts{with_deprecated} = 1 unless exists $opts{with_deprecated};
     $opts{with_pattern_matches} = 0 unless exists $opts{with_pattern_matches};
-    foreach my $soname (sort keys %{$self->{objects}}) {
-	my @deps = @{$self->{objects}{$soname}{deps}};
+    foreach my $soname (sort $self->get_sonames()) {
+	my @deps = $self->get_dependencies($soname);
 	my $dep = shift @deps;
 	$dep =~ s/#PACKAGE#/$opts{package}/g if exists $opts{package};
 	print $fh "$soname $dep\n";
@@ -261,21 +305,20 @@ sub dump {
 	    print $fh "* $field: $value\n";
 	}
 
-	my $syms = $self->{objects}{$soname}{syms};
 	my @symbols;
 	if ($opts{template_mode}) {
 	    # Exclude symbols matching a pattern, but include patterns themselves
-	    @symbols = grep { not $_->get_pattern() } values %$syms;
-	    push @symbols, $self->get_soname_patterns($soname);
+	    @symbols = grep { not $_->get_pattern() } $self->get_symbols($soname);
+	    push @symbols, $self->get_patterns($soname);
 	} else {
-	    @symbols = values %$syms;
+	    @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->{arch});
+	            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";
 	    # Dump pattern matches as comments (if requested)
@@ -293,17 +336,18 @@ sub dump {
 # 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, $name, $sonames, $inc_deprecated) = @_;
+    my ($self, $refsym, $sonames, $inc_deprecated) = @_;
     $inc_deprecated = 0 unless defined $inc_deprecated;
+    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->{arch});
+	       $p->arch_is_concerned($self->get_arch());
     };
 
-    foreach my $soname (@$sonames) {
-	my $obj = (ref $soname) ? $soname : $self->{objects}{$soname};
+    foreach my $soname ((ref($sonames) eq 'ARRAY') ? @$sonames : $sonames) {
+	my $obj = $self->get_object($soname);
 	my ($type, $pattern);
 	next unless defined $obj;
 
@@ -332,10 +376,11 @@ sub find_matching_pattern {
 	    }
 	}
 	if (defined $pattern) {
-	    return $pattern;
+	    return (wantarray) ?
+		( symbol => $pattern, soname => $soname ) : $pattern;
 	}
     }
-    return undef;
+    return (wantarray) ? () : undef;
 }
 
 # merge_symbols($object, $minver)
@@ -349,36 +394,33 @@ sub merge_symbols {
     foreach my $sym ($object->get_exported_dynamic_symbols()) {
         my $name = $sym->{name} . '@' .
                    ($sym->{version} ? $sym->{version} : "Base");
-        my $symobj = $self->lookup_symbol($name, [ $soname ]);
+        my $symobj = $self->lookup_symbol($name, $soname);
         if (exists $blacklist{$sym->{name}}) {
             next unless (defined $symobj and $symobj->has_tag("ignore-blacklist"));
         }
         $dynsyms{$name} = $sym;
     }
 
-    unless (exists $self->{objects}{$soname}) {
+    unless ($self->has_object($soname)) {
 	$self->create_object($soname, '');
     }
     # Scan all symbols provided by the objects
-    my $obj = $self->{objects}{$soname};
-    my @obj = ( $obj );
+    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 (exists $obj->{syms}{$name}) {
+	if ($sym = $self->lookup_symbol($name, $obj, 1)) {
 	    # If the symbol is already listed in the file
-	    $sym = $obj->{syms}{$name};
-	    $sym->mark_found_in_library($minver, $self->{arch});
+	    $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 $symobj = $dynsyms{$name};
-	    my $pattern = $self->find_matching_pattern($name, \@obj, 1);
+	    my $pattern = $self->find_matching_pattern($name, $obj, 1);
 	    if (defined $pattern) {
-		$pattern->mark_found_in_library($minver, $self->{arch});
+		$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
@@ -390,17 +432,16 @@ sub merge_symbols {
     }
 
     # Process all symbols which could not be found in the library.
-    foreach my $name (keys %{$self->{objects}{$soname}{syms}}) {
-	if (not exists $dynsyms{$name}) {
-	    my $sym = $self->{objects}{$soname}{syms}{$name};
-	    $sym->mark_not_found_in_library($minver, $self->{arch});
+    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_soname_patterns($soname)) {
-	$pattern->mark_not_found_in_library($minver, $self->{arch});
+                          $self->get_patterns($soname)) {
+	$pattern->mark_not_found_in_library($minver, $self->get_arch());
     }
 }
 
@@ -414,6 +455,11 @@ sub has_object {
     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} = {
@@ -431,16 +477,16 @@ sub create_object {
 sub get_dependency {
     my ($self, $soname, $dep_id) = @_;
     $dep_id = 0 unless defined($dep_id);
-    return $self->{objects}{$soname}{deps}[$dep_id];
+    return $self->get_object($soname)->{deps}[$dep_id];
 }
 
 sub get_smallest_version {
     my ($self, $soname, $dep_id) = @_;
     $dep_id = 0 unless defined($dep_id);
-    my $so_object = $self->{objects}{$soname};
+    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 (values %{$so_object->{syms}}) {
+    foreach my $sym ($self->get_symbols($so_object)) {
         next if $dep_id != $sym->{dep_id};
         $minver = $sym->{minver} unless defined($minver);
         if (version_compare($minver, $sym->{minver}) > 0) {
@@ -453,78 +499,83 @@ sub get_smallest_version {
 
 sub get_dependencies {
     my ($self, $soname) = @_;
-    return @{$self->{objects}{$soname}{deps}};
+    return @{$self->get_object($soname)->{deps}};
 }
 
 sub get_field {
     my ($self, $soname, $name) = @_;
-    if (exists $self->{objects}{$soname}{fields}{$name}) {
-	return $self->{objects}{$soname}{fields}{$name};
+    if (my $obj = $self->get_object($soname)) {
+	if (exists $obj->{fields}{$name}) {
+	    return $obj->{fields}{$name};
+	}
     }
     return undef;
 }
 
+# Tries to find a symbol like the $refsym and returns its descriptor.
+# $refsym may also be a symbol name.
 sub lookup_symbol {
-    my ($self, $name, $sonames, $inc_deprecated) = @_;
+    my ($self, $refsym, $sonames, $inc_deprecated) = @_;
     $inc_deprecated = 0 unless defined($inc_deprecated);
-    foreach my $so (@{$sonames}) {
-	next if (! exists $self->{objects}{$so});
-	if (exists $self->{objects}{$so}{syms}{$name} and
-	    ($inc_deprecated or not
-	    $self->{objects}{$so}{syms}{$name}{deprecated}))
-	{
-	    my $dep_id = $self->{objects}{$so}{syms}{$name}{dep_id};
-	    my $clone = $self->{objects}{$so}{syms}{$name}->sclone();
-	    $clone->{depends} = $self->{objects}{$so}{deps}[$dep_id];
-	    $clone->{soname} = $so;
-	    return $clone;
+    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 undef;
+    return (wantarray) ? () : undef;
 }
 
-# Tries to find a pattern like the $refpat and returns it. If not found, undef
-# is returned.
+# 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 unless defined($inc_deprecated);
-
-    foreach my $soname (@$sonames) {
-	my $object = (ref $soname) ? $soname : $self->{objects}{$soname};
-	my $pat;
-
-	next unless defined $object;
-	if (my $type = $refpat->get_alias_type()) {
-	    if (exists $object->{patterns}{aliases}{$type}) {
-		$pat = $object->{patterns}{aliases}{$type}{$refpat->get_symbolname()};
-	    }
-	} elsif ($refpat->get_pattern_type() eq "generic") {
-	    for my $p (@{$object->{patterns}{generic}}) {
-		if (($inc_deprecated || !$p->{deprecated}) &&
-		    $p->equals($refpat, versioning => 0))
-		{
-		    $pat = $p;
-		    last;
+    # 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;
 		}
 	    }
 	}
-	if ($pat && ($inc_deprecated || !$pat->{deprecated})) {
-	    return $pat;
-	}
     }
-    return undef;
+    return (wantarray) ? () : undef;
 }
 
-# Collects all patterns of the given soname and returns them as an array.
-sub get_soname_patterns {
-    my ($self, $soname) = @_;
-    my $object = (ref $soname) ? $soname : $self->{objects}{$soname};
-    my @aliases;
-
-    foreach my $alias (values %{$object->{patterns}{aliases}}) {
-	push @aliases, values %$alias;
+# 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 (@aliases, @{$object->{patterns}{generic}});
+    return $sym;
 }
 
 sub get_new_symbols {
@@ -532,23 +583,20 @@ sub get_new_symbols {
     my $with_optional = (exists $opts{with_optional}) ?
 	$opts{with_optional} : 0;
     my @res;
-    foreach my $soname (keys %{$self->{objects}}) {
-	my $mysyms = $self->{objects}{$soname}{syms};
-	next if not exists $ref->{objects}{$soname};
-	my $refsyms = $ref->{objects}{$soname}{syms};
-	my @soname = ( $soname );
+    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->{arch}) }
-	                      values %$mysyms)
+	                        && $_->is_legitimate($self->get_arch()) }
+	                      $self->get_symbols($soname))
 	{
-	    my $refsym = $refsyms->{$sym->get_symbolname()};
+	    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->{arch});
+		$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
@@ -556,25 +604,25 @@ sub get_new_symbols {
 		# 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->get_symbolname(), \@soname, 1)
+		    ($sym->get_pattern() and $ref->lookup_pattern($sym->get_pattern(), $soname, 1)) or
+		    $ref->find_matching_pattern($sym, $soname, 1)
 		);
 	    }
-	    push @res, $sym->sclone(soname => $soname) if $isnew;
+	    push @res, { symbol => $sym, soname => $soname } if $isnew;
 	}
 
 	# Now scan patterns
 	foreach my $p (grep { ($with_optional || ! $_->is_optional())
-	                      && $_->is_legitimate($self->{arch}) }
-	                    $self->get_soname_patterns($soname))
+	                      && $_->is_legitimate($self->get_arch()) }
+	                    $self->get_patterns($soname))
 	{
-	    my $refpat = $ref->lookup_pattern($p, \@soname, 0);
+	    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->{arch}))
+	        not $refpat->is_legitimate($self->get_arch()))
 	    {
-		push @res, $p->sclone(soname => $soname);
+		push @res, { symbol => $p , soname => $soname };
 	    }
 	}
     }
@@ -590,8 +638,8 @@ sub get_lost_symbols {
 sub get_new_libs {
     my ($self, $ref) = @_;
     my @res;
-    foreach my $soname (keys %{$self->{objects}}) {
-	push @res, $soname if not exists $ref->{objects}{$soname};
+    foreach my $soname ($self->get_sonames()) {
+	push @res, $soname if not $ref->get_object($soname);
     }
     return @res;
 }

scripts/dpkg-gensymbols.pl

@@ -260,7 +260,7 @@ if ($compare) {
 		_g("see diff output below"));
 	$exitcode = 2 if ($compare >= 2);
     }
-    if (my @syms = $symfile->get_lost_symbols($ref_symfile)) {
+    if ($symfile->get_lost_symbols($ref_symfile)) {
 	warning(_g("some symbols or patterns disappeared in the symbols file: %s"),
 	        _g("see diff output below"));
 	$exitcode = 1 if ($compare >= 1);

scripts/dpkg-shlibdeps.pl

@@ -320,19 +320,20 @@ foreach my $file (keys %exec) {
 	    $name .= "\@Base";
 	}
         print " Looking up symbol $name\n" if $debug > 1;
-	my $symdep = $symfile->lookup_symbol($name, \@sonames);
-	if (defined($symdep)) {
-            print " Found in symbols file of $symdep->{soname} (minver: " .
-                  "$symdep->{minver}, dep: $symdep->{depends})\n" if $debug > 1;
-	    $soname_used{$symdep->{soname}}++;
-	    $global_soname_used{$symdep->{soname}}++;
-            if (exists $alt_soname{$symdep->{soname}}) {
+	my %symdep = $symfile->lookup_symbol($name, \@sonames);
+	if (keys %symdep) {
+	    my $depends = $symfile->get_dependency($symdep{soname},
+		$symdep{symbol}{dep_id});
+            print " Found in symbols file of $symdep{soname} (minver: " .
+                  "$symdep{symbol}{minver}, dep: $depends)\n" if $debug > 1;
+	    $soname_used{$symdep{soname}}++;
+	    $global_soname_used{$symdep{soname}}++;
+            if (exists $alt_soname{$symdep{soname}}) {
                 # Also count usage on alternate soname
-                $soname_used{$alt_soname{$symdep->{soname}}}++;
-                $global_soname_used{$alt_soname{$symdep->{soname}}}++;
+                $soname_used{$alt_soname{$symdep{soname}}}++;
+                $global_soname_used{$alt_soname{$symdep{soname}}}++;
             }
-	    update_dependency_version($symdep->{depends},
-				      $symdep->{minver});
+	    update_dependency_version($depends, $symdep{symbol}{minver});
 	} else {
 	    my $syminfo = $dumplibs_wo_symfile->locate_symbol($name);
 	    if (not defined($syminfo)) {

scripts/t/200_Dpkg_Shlibs.t

@@ -22,7 +22,9 @@ use warnings;
 
 use_ok('Dpkg::Shlibs');
 
+my $tmp;
 my @tmp;
+my %tmp;
 
 my @save_paths = @Dpkg::Shlibs::librarypaths;
 @Dpkg::Shlibs::librarypaths = ();
@@ -137,23 +139,22 @@ ok( $sym_file_old->get_lost_symbols($sym_file), 'has lost symbols' );
 is( $sym_file_old->lookup_symbol('__bss_start@Base', ['libc.so.6']),
     undef, 'internal symbols are blacklisted' );
 
-$sym = $sym_file->lookup_symbol('_errno@GLIBC_2.0', ['libc.so.6'], 1);
-isa_ok($sym, 'Dpkg::Shlibs::Symbol');
-is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => '_errno@GLIBC_2.0',
+%tmp = $sym_file->lookup_symbol('_errno@GLIBC_2.0', ['libc.so.6'], 1);
+isa_ok($tmp{symbol}, 'Dpkg::Shlibs::Symbol');
+is_deeply(\%tmp, { symbol => Dpkg::Shlibs::Symbol->new( 'symbol' => '_errno@GLIBC_2.0',
 		  'minver' => '2.3.6.ds1-13', 'dep_id' => 0,
-		  'deprecated' => '2.6-1', 'depends' => '',
-		  'soname' => 'libc.so.6' ), 'deprecated symbol');
+		  'deprecated' => '2.6-1'), 'soname' => 'libc.so.6' },
+		  'deprecated symbol');
 
 # Wildcard test
 my $pat = $sym_file_old->create_symbol('*@GLIBC_PRIVATE 2.3.6.wildcard');
 $sym_file_old->add_symbol($pat, 'libc.so.6');
 $sym_file_old->merge_symbols($obj, "2.6-1");
-$sym = $sym_file_old->lookup_symbol('__nss_services_lookup@GLIBC_PRIVATE', ['libc.so.6']);
+$sym = $sym_file_old->lookup_symbol('__nss_services_lookup@GLIBC_PRIVATE', 'libc.so.6');
 is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => '__nss_services_lookup@GLIBC_PRIVATE',
-		  'minver' => '2.3.6.wildcard', 'dep_id' => 0,
-		  'deprecated' => 0, 'depends' => '',
+		  'minver' => '2.3.6.wildcard', 'dep_id' => 0, 'deprecated' => 0,
 		  'tags' => { 'symver' => undef,  optional => undef }, 'tagorder' => [ 'symver', 'optional' ],
-		  'soname' => 'libc.so.6', 'matching_pattern' => $pat ), 'wildcarded symbol');
+		  'matching_pattern' => $pat ), 'wildcarded symbol');
 
 # Save -> Load test
 use File::Temp;
@@ -183,26 +184,22 @@ $sym_file = Dpkg::Shlibs::SymbolFile->new(file => "$datadir/symbols.include-1");
 
 $sym = $sym_file->lookup_symbol('symbol_before@Base', ['libfake.so.1']);
 is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol_before@Base',
-		  'minver' => '0.9', 'dep_id' => 0, 'deprecated' => 0,
-		  'depends' => 'libfake1 #MINVER#', 'soname' => 'libfake.so.1' ),
+		  'minver' => '0.9', 'dep_id' => 0, 'deprecated' => 0 ),
 	    'symbol before include not lost');
 
 $sym = $sym_file->lookup_symbol('symbol_after@Base', ['libfake.so.1']);
 is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol_after@Base',
-		  'minver' => '1.1', 'dep_id' => 0, 'deprecated' => 0,
-		  'depends' => 'libfake1 #MINVER#', 'soname' => 'libfake.so.1' ),
+		  'minver' => '1.1', 'dep_id' => 0, 'deprecated' => 0 ),
 	    'symbol after include not lost');
 
 $sym = $sym_file->lookup_symbol('symbol1_fake1@Base', ['libfake.so.1']);
 is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol1_fake1@Base',
-		  'minver' => '1.0', 'dep_id' => 0, 'deprecated' => 0,
-		  'depends' => 'libfake1 #MINVER#', 'soname' => 'libfake.so.1' ),
+		  'minver' => '1.0', 'dep_id' => 0, 'deprecated' => 0 ),
 	    'overrides order with #include');
 
 $sym = $sym_file->lookup_symbol('symbol3_fake1@Base', ['libfake.so.1']);
 is_deeply($sym, Dpkg::Shlibs::Symbol->new ( 'symbol' => 'symbol3_fake1@Base',
-		  'minver' => '0', 'dep_id' => 0, 'deprecated' => 0,
-		  'depends' => 'libfake1 #MINVER#', 'soname' => 'libfake.so.1' ),
+		  'minver' => '0', 'dep_id' => 0, 'deprecated' => 0 ),
 	    'overrides order with #include');
 
 is($sym_file->get_smallest_version('libfake.so.1'), "0",
@@ -210,16 +207,14 @@ is($sym_file->get_smallest_version('libfake.so.1'), "0",
 
 $sym = $sym_file->lookup_symbol('symbol_in_libdivert@Base', ['libdivert.so.1']);
 is_deeply($sym, Dpkg::Shlibs::Symbol->new ( 'symbol' => 'symbol_in_libdivert@Base',
-		  'minver' => '1.0~beta1', 'dep_id' => 0, 'deprecated' => 0,
-		  'depends' => 'libdivert1 #MINVER#', 'soname' => 'libdivert.so.1'),
+		  'minver' => '1.0~beta1', 'dep_id' => 0, 'deprecated' => 0 ),
 	    '#include can change current object');
 
 $sym_file = Dpkg::Shlibs::SymbolFile->new(file => "$datadir/symbols.include-2");
 
 $sym = $sym_file->lookup_symbol('symbol1_fake2@Base', ['libfake.so.1']);
 is_deeply($sym, Dpkg::Shlibs::Symbol->new ( 'symbol' => 'symbol1_fake2@Base',
-		  'minver' => '1.0', 'dep_id' => 1, 'deprecated' => 0,
-		  'depends' => 'libvirtualfake', 'soname' => 'libfake.so.1' ),
+		  'minver' => '1.0', 'dep_id' => 1, 'deprecated' => 0 ),
 	    'overrides order with circular #include');
 
 is($sym_file->get_smallest_version('libfake.so.1'), "1.0",
@@ -317,7 +312,6 @@ $sym_file->merge_symbols($tags_obj_i386, '100.MISSING');
 $sym = $sym_file->lookup_symbol('symbol11_optional@Base', ['libbasictags.so.1'], 1);
 is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol11_optional@Base', 'symbol_templ' => 'symbol11_optional@Base',
 		  'minver' => '1.1', 'dep_id' => 1, 'deprecated' => '100.MISSING',
-		  'depends' => 'libbasictags1 (>= 1.1)', 'soname' => 'libbasictags.so.1',
 		  'tags' => { 'optional' => undef }, 'tagorder' => [ 'optional' ] ),
 	    'disappered optional symbol gets deprecated');
 
@@ -325,7 +319,6 @@ $sym_file->merge_symbols($tags_obj_i386, '101.MISSING');
 $sym = $sym_file->lookup_symbol('symbol11_optional@Base', ['libbasictags.so.1'], 1);
 is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol11_optional@Base', 'symbol_templ' => 'symbol11_optional@Base',
 		  'minver' => '1.1', 'dep_id' => 1, 'deprecated' => '101.MISSING',
-		  'depends' => 'libbasictags1 (>= 1.1)', 'soname' => 'libbasictags.so.1',
 		  'tags' => { 'optional' => undef }, 'tagorder' => [ 'optional' ] ),
 	    'deprecated text of MISSING optional symbol gets rebumped each merge');
 
@@ -337,7 +330,6 @@ $sym_file->merge_symbols($tags_obj_i386, '100.MISSING');
 $sym = $sym_file->lookup_symbol('symbol11_optional@Base', ['libbasictags.so.1']);
 is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol11_optional@Base', 'symbol_templ' => 'symbol11_optional@Base',
 		  'minver' => '1.1', 'dep_id' => 1, 'deprecated' => 0,
-		  'depends' => 'libbasictags1 (>= 1.1)', 'soname' => 'libbasictags.so.1',
 		  'tags' => { 'optional' => undef }, 'tagorder' => [ 'optional' ] ),
 	    'reappered optional symbol gets undeprecated + minver');
 is( scalar($sym_file->get_lost_symbols($sym_file_dup) +
@@ -350,10 +342,9 @@ $tags_obj_i386->add_dynamic_symbol($symbol21);
 $sym_file->merge_symbols($tags_obj_i386, '100.MISSING');
 $sym = $sym_file->lookup_symbol('symbol21_amd64@Base', ['libbasictags.so.1']);
 is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol21_amd64@Base', 'symbol_templ' => 'symbol21_amd64@Base',
-		  'symbol_quoted' => "'", 'minver' => '2.1', 'dep_id' => 0, 'deprecated' => 0,
-		  'depends' => 'libbasictags1 #MINVER#', 'soname' => 'libbasictags.so.1' ),
+		  'symbol_quoted' => "'", 'minver' => '2.1', 'dep_id' => 0, 'deprecated' => 0 ),
 	    'symbol appears on foreign arch, arch tag should be removed');
-@tmp = map { $_->get_symbolname() } $sym_file->get_new_symbols($sym_file_dup);
+@tmp = map { $_->{symbol}->get_symbolname() } $sym_file->get_new_symbols($sym_file_dup);
 is_deeply( \@tmp, [ 'symbol21_amd64@Base' ], "symbol from foreign arch is NEW");
 is( $sym->get_symbolspec(1), ' symbol21_amd64@Base 2.1', 'no tags => no quotes in the symbol name' );
 
@@ -365,50 +356,43 @@ $sym_file->merge_symbols($tags_obj_i386, '100.MISSING');
 $sym = $sym_file->lookup_symbol('symbol22_i386@Base', ['libbasictags.so.1'], 1);
 is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol22_i386@Base', 'symbol_templ' => 'symbol22_i386@Base',
 		  'minver' => '2.2', 'dep_id' => 0, 'deprecated' => '100.MISSING',
-		  'depends' => 'libbasictags1 #MINVER#', 'soname' => 'libbasictags.so.1',
 		  'tags' => { 'arch' => '!amd64 !ia64 !alpha' }, 'tagorder' => [ 'arch' ] ),
 	    'disappeared arch specific symbol gets deprecated');
 $sym = $sym_file->lookup_symbol('symbol41_i386_and_optional@Base', ['libbasictags.so.1'], 1);
 is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol41_i386_and_optional@Base',
 		  'symbol_templ' => 'symbol41_i386_and_optional@Base', 'symbol_quoted' => '"',
 		  'minver' => '4.1', 'dep_id' => 0, 'deprecated' => '100.MISSING',
-		  'depends' => 'libbasictags1 #MINVER#', 'soname' => 'libbasictags.so.1',
 		  'tags' => { 'arch' => 'i386', 'optional' => 'reason' }, 'tagorder' => [ 'arch', 'optional' ] ),
 	    'disappeared optional arch specific symbol gets deprecated');
-@tmp = map { $_->get_symbolname() } $sym_file->get_lost_symbols($sym_file_dup);
+@tmp = map { $_->{symbol}->get_symbolname() } $sym_file->get_lost_symbols($sym_file_dup);
 is_deeply( \@tmp, [ 'symbol22_i386@Base' ], "missing arch specific is LOST, but optional arch specific isn't");
 
 # Tests for tagged #includes
 $sym_file = Dpkg::Shlibs::SymbolFile->new(file => "$datadir/symbols.include-3", arch => 'i386');
 $sym = $sym_file->lookup_symbol('symbol2_fake1@Base', ['libbasictags.so.2']);
 is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol2_fake1@Base',
-		  'minver' => '1.0', 'depends' => 'libbasictags2', 'soname' => 'libbasictags.so.2',
-		  'tags' => { 'optional' => undef, 'random tag' => 'random value' },
+		  'minver' => '1.0', 'tags' => { 'optional' => undef, 'random tag' => 'random value' },
 		  'tagorder' => [ 'optional', 'random tag' ] ),
 	    'symbols from #included file inherits tags');
 $sym = $sym_file->lookup_symbol('symbol41_i386_and_optional@Base', ['libbasictags.so.1']);
 is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol41_i386_and_optional@Base',
 		  'symbol_templ' => 'symbol41_i386_and_optional@Base', symbol_quoted => '"',
-		  'minver' => '4.1', 'depends' => 'libbasictags1 #MINVER#', 'soname' => 'libbasictags.so.1',
-		  'tags' => { 'optional' => 'reason', 't' => 'v', 'arch' => 'i386' },
+		  'minver' => '4.1', 'tags' => { 'optional' => 'reason', 't' => 'v', 'arch' => 'i386' },
 		  'tagorder' => [ 'optional', 't', 'arch' ] ),
 	    'symbols in #included file can override tag values');
 $sym = $sym_file->lookup_symbol('symbol51_untagged@Base', ['libbasictags.so.1']);
 is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol51_untagged@Base',
-		  'minver' => '5.1', 'depends' => 'libbasictags1 #MINVER#', 'soname' => 'libbasictags.so.1',
-		  'tags' => { 'optional' => 'from parent', 't' => 'v' },
+		  'minver' => '5.1', 'tags' => { 'optional' => 'from parent', 't' => 'v' },
 		  'tagorder' => [ 'optional', 't' ] ),
 	    'symbols are properly cloned when #including');
 
-# Test Symbol::sclone() and Symbol::dclone()
+# Test Symbol::clone()
 $sym = Dpkg::Shlibs::Symbol->new(symbol => 'foobar', testfield => 1, teststruct => { 'foo' => 1 });
-@tmp = ( $sym->sclone(), $sym->dclone() );
-$tmp[0]->{teststruct}{foo} = 2;
-$tmp[0]->{testfield} = 2;
-$tmp[1]->{teststruct}{foo} = 3;
-$tmp[1]->{testfield} = 3;
-is ( $sym->{teststruct}{foo}, 2, 'struct changed via sclone()' );
-is ( $sym->{testfield}, 1, 'original field not changed' );
+$tmp = $sym->clone();
+$tmp->{teststruct}{foo} = 3;
+$tmp->{testfield} = 3;
+is ( $sym->{teststruct}{foo}, 1, 'original field "foo" not changed' );
+is ( $sym->{testfield}, 1, 'original field "testfield" not changed' );
 
 ############ Test symbol patterns ###########
 sub load_patterns_obj {
@@ -431,7 +415,7 @@ load_patterns_symbols();
 
 save_load_test($sym_file, 'save -> load test of patterns template', template_mode => 1);
 
-isnt( $sym_file->get_soname_patterns('libpatterns.so.1') , 0,
+isnt( $sym_file->get_patterns('libpatterns.so.1') , 0,
     "patterns.symbols has patterns" );
 
 $sym_file->merge_symbols($obj, '100.MISSING');
@@ -442,17 +426,17 @@ is_deeply( \@tmp, [], "no LOST symbols if all patterns matched." );
 is_deeply( \@tmp, [], "no NEW symbols if all patterns matched." );
 
 # Pattern resolution order: aliases (c++, symver), generic
-$sym = $sym_file->lookup_symbol('SYMVER_1@SYMVER_1',['libpatterns.so.1']);
+$sym = $sym_file->lookup_symbol('SYMVER_1@SYMVER_1','libpatterns.so.1');
 is ( $sym->{minver}, '1', "specific SYMVER_1 symbol" );
 
-$sym = $sym_file->lookup_symbol('_ZN3NSB6Symver14symver_method1Ev@SYMVER_1', ['libpatterns.so.1']);
+$sym = $sym_file->lookup_symbol('_ZN3NSB6Symver14symver_method1Ev@SYMVER_1', 'libpatterns.so.1');
 is ( $sym->{minver}, '1.method1', "specific symbol prefered over pattern" );
 
-$sym = $sym_file->lookup_symbol('_ZN3NSB6Symver14symver_method2Ev@SYMVER_1', ['libpatterns.so.1']);
+$sym = $sym_file->lookup_symbol('_ZN3NSB6Symver14symver_method2Ev@SYMVER_1', 'libpatterns.so.1');
 is ( $sym->{minver}, '1.method2', "c++ alias pattern preferred over generic pattern" );
 is ( $sym->get_pattern()->get_symbolname(), 'NSB::Symver::symver_method2()@SYMVER_1' );
 
-$sym = $sym_file->lookup_symbol('_ZN3NSB6SymverD1Ev@SYMVER_1', ['libpatterns.so.1']);
+$sym = $sym_file->lookup_symbol('_ZN3NSB6SymverD1Ev@SYMVER_1', 'libpatterns.so.1');
 is ( $sym->{minver}, '1.generic', 'generic (c++ & symver) pattern covers the rest (destructor)' );
 ok ( $sym->get_pattern()->equals($sym_file->create_symbol('(c++|symver)SYMVER_1 1.generic')) );
 
@@ -463,7 +447,7 @@ ok ( $sym->is_optional(), "Old style wildcard is optional");
 is ( $sym->get_alias_type(), "symver", "old style wildcard is a symver pattern" );
 is ( $sym->get_symbolname(), 'SYMVEROPT_2', "wildcard pattern got renamed" );
 
-$pat = $sym_file->lookup_pattern($sym_file->create_symbol('(symver|optional)SYMVEROPT_2 2'), ['libpatterns.so.1']);
+$pat = $sym_file->lookup_pattern('(symver|optional)SYMVEROPT_2', 'libpatterns.so.1');
 $sym->{symbol_templ} = $pat->{symbol_templ};
 is_deeply( $pat, $sym, "old style wildcard is the same as (symver|optional)" );
 
@@ -475,14 +459,14 @@ $sym_file->merge_symbols($obj, '100.MISSING');
 is_deeply ( [ map { $_->get_symbolname() } $pat->get_pattern_matches() ],
     [], "old style wildcard matches nothing.");
 is ( $pat->{deprecated}, '100.MISSING', "old style wildcard gets deprecated." );
-@tmp = map { $_->get_symbolname() } $sym_file->get_lost_symbols($sym_file_dup);
+@tmp = map { $_->{symbol}->get_symbolname() } $sym_file->get_lost_symbols($sym_file_dup);
 is_deeply( \@tmp, [], "but old style wildcard is not LOST." );
 
 # 'Internal' pattern covers all internal symbols
 load_patterns_obj();
-@tmp = grep { $_->get_symbolname() =~ /Internal/ } values %{$sym_file->{objects}{'libpatterns.so.1'}{syms}};
+@tmp = grep { $_->get_symbolname() =~ /Internal/ } $sym_file->get_symbols('libpatterns.so.1');
 $sym = $sym_file->create_symbol('(regex|c++)^_Z(T[ISV])?N3NSA6ClassA8Internal.*@Base$ 1.internal'),
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1']);
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1');
 is_deeply ([ sort $pat->get_pattern_matches() ], [ sort @tmp ],
     "Pattern covers all internal symbols");
 is ( $tmp[0]->{minver}, '1.internal' );
@@ -501,13 +485,13 @@ my @private_symnames = sort qw(
     _ZTVN3NSA6ClassA7PrivateE@Base
 );
 $sym = $sym_file->create_symbol('(c++|regex|optional)NSA::ClassA::Private(::.*)?@Base 1');
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1']);
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1');
 isnt( $pat, undef, 'pattern for private class has been found' );
 is_deeply( [ sort map { $_->get_symbolname() } $pat->get_pattern_matches() ],
     \@private_symnames, "private pattern matched expected symbols" );
 ok( ($pat->get_pattern_matches())[0]->is_optional(),
     "private symbol is optional like its pattern" );
-ok( $sym_file->lookup_symbol(($pat->get_pattern_matches())[0]->get_symbolname(), ['libpatterns.so.1']),
+ok( $sym_file->lookup_symbol(($pat->get_pattern_matches())[0], 'libpatterns.so.1'),
     "lookup_symbol() finds symbols matched by pattern (after merge)"),
 
 # Get rid of a private symbol, it should not be lost
@@ -515,8 +499,8 @@ delete $obj->{dynsyms}{$private_symnames[0]};
 load_patterns_symbols();
 $sym_file->merge_symbols($obj, '100.MISSING');
 
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1']);
-@tmp = map { $_->get_symbolname() } $sym_file->get_lost_symbols($sym_file_dup);
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1');
+@tmp = map { $_->{symbol}->get_symbolname() } $sym_file->get_lost_symbols($sym_file_dup);
 is_deeply( \@tmp, [], "no LOST symbols when got rid of patterned optional symbol." );
 ok( ! $pat->{deprecated} , "there are still matches, pattern is not deprecated." );
 
@@ -527,7 +511,7 @@ foreach my $tmp (@private_symnames) {
 load_patterns_symbols();
 $sym_file->merge_symbols($obj, '100.MISSING');
 
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1'], 1);
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1', 1);
 @tmp = $sym_file->get_lost_symbols($sym_file_dup);
 is_deeply( \@tmp, [ ],
     "All private symbols gone, but pattern is not LOST because it is optional." );
@@ -537,14 +521,14 @@ is( $pat->{deprecated}, '100.MISSING',
 # Internal symbols. All covered by the pattern?
 @tmp = grep { $_->get_symbolname() =~ /Internal/ } values %{$sym_file->{objects}{'libpatterns.so.1'}{syms}};
 $sym = $sym_file->create_symbol('(regex|c++)^_Z(T[ISV])?N3NSA6ClassA8Internal.*@Base$ 1.internal'),
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1']);
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1');
 is_deeply ([ sort $pat->get_pattern_matches() ], [ sort @tmp ],
     "Pattern covers all internal symbols");
 is ( $tmp[0]->{minver}, '1.internal' );
 
 # Delete matches of the non-optional pattern
 $sym = $sym_file->create_symbol('(c++)"non-virtual thunk to NSB::ClassD::generate_vt(char const*) const@Base" 1');
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1']);
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1');
 isnt( $pat, undef, 'lookup_pattern() finds alias-based pattern' );
 
 is( scalar($pat->get_pattern_matches()), 2, "two matches for the generate_vt pattern" );
@@ -554,8 +538,8 @@ foreach my $tmp ($pat->get_pattern_matches()) {
 load_patterns_symbols();
 $sym_file->merge_symbols($obj, '100.MISSING');
 
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1'], 1);
-@tmp = map { $sym_file->lookup_pattern($_, ['libpatterns.so.1'], 1) }
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1', 1);
+@tmp = map { scalar $sym_file->lookup_pattern($_->{symbol}, 'libpatterns.so.1', 1) }
              $sym_file->get_lost_symbols($sym_file_dup);
 is_deeply( \@tmp, [ $pat ], "No matches - generate_vt() pattern is LOST." );
 is( $pat->{deprecated}, '100.MISSING',
@@ -565,9 +549,9 @@ is( $pat->{deprecated}, '100.MISSING',
 load_patterns_obj();
 load_patterns_symbols();
 
-$pat = $sym_file_dup->lookup_pattern($sym, ['libpatterns.so.1']);
+$pat = $sym_file_dup->lookup_pattern($sym, 'libpatterns.so.1');
 $pat->{deprecated} = '0.1-1';
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1']);
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1');
 $pat->{deprecated} = '0.1-1';
 
 $sym_file->merge_symbols($obj, '100.FOUND');
@@ -575,7 +559,7 @@ ok( ! $pat->{deprecated},
     "Previously deprecated pattern with matches got undeprecated" );
 is( $pat->{minver}, '100.FOUND',
     "Previously deprecated pattern with matches got minver bumped" );
-@tmp = map { $_->get_symbolspec(1) } $sym_file->get_new_symbols($sym_file_dup);
+@tmp = map { $_->{symbol}->get_symbolspec(1) } $sym_file->get_new_symbols($sym_file_dup);
 is_deeply( \@tmp, [ $pat->get_symbolspec(1) ],
     "Previously deprecated pattern with matches is NEW. Matches themselves are not NEW." );
 foreach my $sym ($pat->get_pattern_matches()) {