scripts: get_abi.pl: don't skip what that ends with wildcards

The search algorithm used inside check_undefined_symbols
has an optimization: it seeks only whats that have the same
leave name. This helps not only to speedup the search, but
it also allows providing a hint about a partial match.

There's a drawback, however: when "what:" finishes with a
wildcard, the logic will skip the what, reporting it as
"not found".

Fix it by grouping the remaining cases altogether, and
disabing any hints for such cases.

Signed-off-by: Mauro Carvalho Chehab <mchehab+huawei@kernel.org>
Link: https://lore.kernel.org/r/79ba5139643355230e3bba136b20991cfc92020f.1631957565.git.mchehab+huawei@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/scripts/get_abi.pl b/scripts/get_abi.pl
index f5f2f66..fe83f29 100755 (executable)
--- a/scripts/get_abi.pl
+++ b/scripts/get_abi.pl
@@ -589,44 +589,47 @@ sub check_undefined_symbols {
                        $found_string = 1;
                }
 
+               if ($leave =~ /^\d+$/ || !defined($leaf{$leave})) {
+                       $leave = "others";
+               }
+
                print "--> $file\n" if ($found_string && $hint);
-               if (defined($leaf{$leave})) {
-                       my $what = $leaf{$leave};
-                       $whats .= " $what" if (!($whats =~ m/$what/));
-
-                       foreach my $w (split / /, $what) {
-                               if ($file =~ m#^$w$#) {
-                                       $exact = 1;
-                                       last;
-                               }
+               my $what = $leaf{$leave};
+               $whats .= " $what" if (!($whats =~ m/$what/));
+
+               foreach my $w (split / /, $what) {
+                       if ($file =~ m#^$w$#) {
+                               $exact = 1;
+                               last;
                        }
-                       # Check for aliases
-                       #
-                       # TODO: this algorithm is O(w * n²). It can be
-                       # improved in the future in order to handle it
-                       # faster, by changing parse_existing_sysfs to
-                       # store the sysfs inside a tree, at the expense
-                       # on making the code less readable and/or using some
-                       # additional perl library.
-                       foreach my $a (keys %aliases) {
-                               my $new = $aliases{$a};
-                               my $len = length($new);
-
-                               if (substr($file, 0, $len) eq $new) {
-                                       my $newf = $a . substr($file, $len);
-
-                                       print "    $newf\n" if ($found_string && $hint);
-                                       foreach my $w (split / /, $what) {
-                                               if ($newf =~ m#^$w$#) {
-                                                       $exact = 1;
-                                                       last;
-                                               }
+               }
+               # Check for aliases
+               #
+               # TODO: this algorithm is O(w * n²). It can be
+               # improved in the future in order to handle it
+               # faster, by changing parse_existing_sysfs to
+               # store the sysfs inside a tree, at the expense
+               # on making the code less readable and/or using some
+               # additional perl library.
+               foreach my $a (keys %aliases) {
+                       my $new = $aliases{$a};
+                       my $len = length($new);
+
+                       if (substr($file, 0, $len) eq $new) {
+                               my $newf = $a . substr($file, $len);
+
+                               print "    $newf\n" if ($found_string && $hint);
+                               foreach my $w (split / /, $what) {
+                                       if ($newf =~ m#^$w$#) {
+                                               $exact = 1;
+                                               last;
                                        }
                                }
                        }
-
-                       $defined++;
                }
+
+               $defined++;
+
                next if ($exact);
 
                # Ignore some sysfs nodes
@@ -637,7 +640,7 @@ sub check_undefined_symbols {
                # is not easily parseable.
                next if ($file =~ m#/parameters/#);
 
-               if ($hint && $defined) {
+               if ($hint && $defined && $leave ne "others") {
                        print "$leave at $path might be one of:$whats\n"  if (!$search_string || $found_string);
                        next;
                }
@@ -699,7 +702,16 @@ sub undefined_symbols {
                        my $leave = $what;
                        $leave =~ s,.*/,,;
 
-                       next if ($leave =~ m/^\.\*/ || $leave eq "");
+                       # $leave is used to improve search performance at
+                       # check_undefined_symbols, as the algorithm there can seek
+                       # for a small number of "what". It also allows giving a
+                       # hint about a leave with the same name somewhere else.
+                       # However, there are a few occurences where the leave is
+                       # either a wildcard or a number. Just group such cases
+                       # altogether.
+                       if ($leave =~ m/^\.\*/ || $leave eq "" || $leave =~ /^\d+$/) {
+                               $leave = "others" ;
+                       }
 
                        # Escape all other symbols
                        $what =~ s/$escape_symbols/\\$1/g;