From Code to Community: Sponsoring The Perl and Raku Conference 2025 Learn more

GUILLEM / Dpkg-1.22.5 / lib / Dpkg / Shlibs / Cppfilt.pm 

            

              
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
—
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
—
133
134
135
136
137
138
139
140
141
142

              
# 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/>.
=encoding utf8
=head1 NAME
Dpkg::Shlibs::Cppfilt - C++ symbol mangling support via c++filt
=head1 DESCRIPTION
This module provides functions that wrap over c++filt for its easy and
fast usage.
B<Note>: This is a private module, its API can change at any time.
=cut
package Dpkg::Shlibs::Cppfilt 0.01;
use strict;
use warnings;
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;
}
=head1 CHANGES
=head2 Version 0.xx
This is a private module.
=cut
1;