<h2>Editing File: /opt/rh/gcc-toolset-11/root/usr/bin/cg_diff</h2><form method='post'><textarea name='content' class='file-edit'>#! /usr/bin/perl

##--------------------------------------------------------------------##
##--- Cachegrind's differencer.                         cg_diff.in ---##
##--------------------------------------------------------------------##

#  This file is part of Cachegrind, a Valgrind tool for cache
#  profiling programs.
#
#  Copyright (C) 2002-2017 Nicholas Nethercote
#     njn@valgrind.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 &lt;http://www.gnu.org/licenses/&gt;.
#
#  The GNU General Public License is contained in the file COPYING.

#----------------------------------------------------------------------------
# This is a very cut-down and modified version of cg_annotate.
#----------------------------------------------------------------------------

use warnings;
use strict;

#----------------------------------------------------------------------------
# Global variables
#----------------------------------------------------------------------------

# Version number
my $version = &quot;3.17.0&quot;;

# Usage message.
my $usage = &lt;&lt;END
usage: cg_diff [options] &lt;cachegrind-out-file1&gt; &lt;cachegrind-out-file2&gt;

  options for the user, with defaults in [ ], are:
    -h --help             show this message
    -v --version          show version
    --mod-filename=&lt;expr&gt; a Perl search-and-replace expression that is applied
                          to filenames, eg. --mod-filename='s/prog[0-9]/projN/'
    --mod-funcname=&lt;expr&gt; like --mod-filename, but applied to function names

  cg_diff is Copyright (C) 2002-2017 Nicholas Nethercote.
  and licensed under the GNU General Public License, version 2.
  Bug reports, feedback, admiration, abuse, etc, to: njn\@valgrind.org.
                                                
END
;

# --mod-filename expression
my $mod_filename = undef;

# --mod-funcname expression
my $mod_funcname = undef;

#-----------------------------------------------------------------------------
# Argument and option handling
#-----------------------------------------------------------------------------
sub process_cmd_line() 
{
    my ($file1, $file2) = (undef, undef);

    for my $arg (@ARGV) { 

        if ($arg =~ /^-/) {
            # --version
            if ($arg =~ /^-v$|^--version$/) {
                die(&quot;cg_diff-$version\n&quot;);

            } elsif ($arg =~ /^--mod-filename=(.*)/) {
                $mod_filename = $1;

            } elsif ($arg =~ /^--mod-funcname=(.*)/) {
                $mod_funcname = $1;

            } else {            # -h and --help fall under this case
                die($usage);
            }

        } elsif (not defined($file1)) {
            $file1 = $arg;

        } elsif (not defined($file2)) {
            $file2 = $arg;

        } else {
            die($usage);
        }
    }

    # Must have specified two input files.
    if (not defined $file1 or not defined $file2) {
        die($usage);
    }

    return ($file1, $file2);
}

#-----------------------------------------------------------------------------
# Reading of input file
#-----------------------------------------------------------------------------
sub max ($$) 
{
    my ($x, $y) = @_;
    return ($x &gt; $y ? $x : $y);
}

# Add the two arrays;  any '.' entries are ignored.  Two tricky things:
# 1. If $a2-&gt;[$i] is undefined, it defaults to 0 which is what we want; we turn
#    off warnings to allow this.  This makes things about 10% faster than
#    checking for definedness ourselves.
# 2. We don't add an undefined count or a &quot;.&quot;, even though it's value is 0,
#    because we don't want to make an $a2-&gt;[$i] that is undef become 0
#    unnecessarily.
sub add_array_a_to_b ($$) 
{
    my ($a, $b) = @_;

    my $n = max(scalar @$a, scalar @$b);
    $^W = 0;
    foreach my $i (0 .. $n-1) {
        $b-&gt;[$i] += $a-&gt;[$i] if (defined $a-&gt;[$i] &amp;&amp; &quot;.&quot; ne $a-&gt;[$i]);
    }
    $^W = 1;
}

sub sub_array_b_from_a ($$) 
{
    my ($a, $b) = @_;

    my $n = max(scalar @$a, scalar @$b);
    $^W = 0;
    foreach my $i (0 .. $n-1) {
        $a-&gt;[$i] -= $b-&gt;[$i];       # XXX: doesn't handle '.' entries
    }
    $^W = 1;
}

# Add each event count to the CC array.  '.' counts become undef, as do
# missing entries (implicitly).
sub line_to_CC ($$)
{
    my ($line, $numEvents) = @_;

    my @CC = (split /\s+/, $line);
    (@CC &lt;= $numEvents) or die(&quot;Line $.: too many event counts\n&quot;);
    return \@CC;
}

sub read_input_file($) 
{
    my ($input_file) = @_;

    open(INPUTFILE, &quot;&lt; $input_file&quot;) 
         || die &quot;Cannot open $input_file for reading\n&quot;;

    # Read &quot;desc:&quot; lines.
    my $desc;
    my $line;
    while ($line = &lt;INPUTFILE&gt;) {
        if ($line =~ s/desc:\s+//) {
            $desc .= $line;
        } else {
            last;
        }
    }

    # Read &quot;cmd:&quot; line (Nb: will already be in $line from &quot;desc:&quot; loop above).
    ($line =~ s/^cmd:\s+//) or die(&quot;Line $.: missing command line\n&quot;);
    my $cmd = $line;
    chomp($cmd);    # Remove newline

    # Read &quot;events:&quot; line.  We make a temporary hash in which the Nth event's
    # value is N, which is useful for handling --show/--sort options below.
    $line = &lt;INPUTFILE&gt;;
    (defined $line &amp;&amp; $line =~ s/^events:\s+//) 
        or die(&quot;Line $.: missing events line\n&quot;);
    my @events = split(/\s+/, $line);
    my $numEvents = scalar @events;

    my $currFileName;
    my $currFileFuncName;

    my %CCs;                    # hash(&quot;$filename#$funcname&quot; =&gt; CC array)
    my $currCC = undef;         # CC array

    my $summaryCC;

    # Read body of input file.
    while (&lt;INPUTFILE&gt;) {
        s/#.*$//;   # remove comments
        if (s/^(\d+)\s+//) {
            my $CC = line_to_CC($_, $numEvents);
            defined($currCC) || die;
            add_array_a_to_b($CC, $currCC);

        } elsif (s/^fn=(.*)$//) {
            defined($currFileName) || die;
            my $tmpFuncName = $1;
            if (defined $mod_funcname) {
                eval &quot;\$tmpFuncName =~ $mod_funcname&quot;;
            }
            $currFileFuncName = &quot;$currFileName#$tmpFuncName&quot;;
            $currCC = $CCs{$currFileFuncName};
            if (not defined $currCC) {
                $currCC = [];
                $CCs{$currFileFuncName} = $currCC;
            }

        } elsif (s/^fl=(.*)$//) {
            $currFileName = $1;
            if (defined $mod_filename) {
                eval &quot;\$currFileName =~ $mod_filename&quot;;
            }
            # Assume that a &quot;fn=&quot; line is followed by a &quot;fl=&quot; line.
            $currFileFuncName = undef;  

        } elsif (s/^\s*$//) {
            # blank, do nothing
        
        } elsif (s/^summary:\s+//) {
            $summaryCC = line_to_CC($_, $numEvents);
            (scalar(@$summaryCC) == @events) 
                or die(&quot;Line $.: summary event and total event mismatch\n&quot;);

        } else {
            warn(&quot;WARNING: line $. malformed, ignoring\n&quot;);
        }
    }

    # Check if summary line was present
    if (not defined $summaryCC) {
        die(&quot;missing final summary line, aborting\n&quot;);
    }

    close(INPUTFILE);

    return ($cmd, \@events, \%CCs, $summaryCC);
}

#----------------------------------------------------------------------------
# &quot;main()&quot;
#----------------------------------------------------------------------------
# Commands seen in the files.  Need not match.
my $cmd1;
my $cmd2;

# Events seen in the files.  They must match.
my $events1;
my $events2;

# Individual CCs, organised by filename/funcname/line_num.
# hashref(&quot;$filename#$funcname&quot;, CC array)
my $CCs1;
my $CCs2;

# Total counts for summary (an arrayref).
my $summaryCC1;
my $summaryCC2;

#----------------------------------------------------------------------------
# Read the input files
#----------------------------------------------------------------------------
my ($file1, $file2) = process_cmd_line();
($cmd1, $events1, $CCs1, $summaryCC1) = read_input_file($file1);
($cmd2, $events2, $CCs2, $summaryCC2) = read_input_file($file2);

#----------------------------------------------------------------------------
# Check the events match
#----------------------------------------------------------------------------
my $n = max(scalar @$events1, scalar @$events2);
$^W = 0;    # turn off warnings, because we might hit undefs
foreach my $i (0 .. $n-1) {
    ($events1-&gt;[$i] eq $events2-&gt;[$i]) || die &quot;events don't match, aborting\n&quot;;
}
$^W = 1;

#----------------------------------------------------------------------------
# Do the subtraction: CCs2 -= CCs1
#----------------------------------------------------------------------------
while (my ($filefuncname, $CC1) = each(%$CCs1)) {
    my $CC2 = $CCs2-&gt;{$filefuncname};
    if (not defined $CC2) {
        $CC2 = [];
        sub_array_b_from_a($CC2, $CC1);     # CC2 -= CC1
        $CCs2-&gt;{$filefuncname} = $CC2;
    } else {
        sub_array_b_from_a($CC2, $CC1);     # CC2 -= CC1
    }
}
sub_array_b_from_a($summaryCC2, $summaryCC1);

#----------------------------------------------------------------------------
# Print the result, in CCs2
#----------------------------------------------------------------------------
print(&quot;desc: Files compared:   $file1; $file2\n&quot;);
print(&quot;cmd:  $cmd1; $cmd2\n&quot;);
print(&quot;events: &quot;);
for my $e (@$events1) {
    print(&quot; $e&quot;);
}
print(&quot;\n&quot;);

while (my ($filefuncname, $CC) = each(%$CCs2)) {

    my @x = split(/#/, $filefuncname);
    (scalar @x == 2) || die;

    print(&quot;fl=$x[0]\n&quot;);
    print(&quot;fn=$x[1]\n&quot;);

    print(&quot;0&quot;);
    foreach my $n (@$CC) {
        print(&quot; $n&quot;);
    }
    print(&quot;\n&quot;);
}

print(&quot;summary:&quot;);
foreach my $n (@$summaryCC2) {
    print(&quot; $n&quot;);
}
print(&quot;\n&quot;);

##--------------------------------------------------------------------##
##--- end                                                          ---##
##--------------------------------------------------------------------##
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Frh%2Fgcc-toolset-11%2Froot%2Fusr%2Fbin'>Back to Directory</a>