Profile of overload.pm

Filename	/usr/share/perl/5.28/overload.pm
Statements	Executed 138 statements in 890µs

Subroutines
Calls	P	F	Exclusive Time	Inclusive Time	Subroutine
6	1	1	199µs	199µs	overload::::OVERLOADoverload::OVERLOAD
6	6	4	82µs	281µs	overload::::importoverload::import
1	1	1	12µs	17µs	overload::::BEGIN@81overload::BEGIN@81
1	1	1	8µs	13µs	overload::::BEGIN@112overload::BEGIN@112
1	1	1	6µs	39µs	overload::::BEGIN@142overload::BEGIN@142
0	0	0	0s	0s	overload::::AddrRefoverload::AddrRef
0	0	0	0s	0s	overload::::Methodoverload::Method
0	0	0	0s	0s	overload::::Overloadedoverload::Overloaded
0	0	0	0s	0s	overload::::OverloadedStringifyoverload::OverloadedStringify
0	0	0	0s	0s	overload::::constantoverload::constant
0	0	0	0s	0s	overload::::mycanoverload::mycan
0	0	0	0s	0s	overload::::niloverload::nil
0	0	0	0s	0s	overload::::ov_methodoverload::ov_method
0	0	0	0s	0s	overload::::remove_constantoverload::remove_constant
0	0	0	0s	0s	overload::::unimportoverload::unimport

Call graph for these subroutines as a Graphviz dot language file.

Line	State ments	Time on line	Calls	Time in subs	Code
1					package overload;
2
3	1	400ns			our $VERSION = '1.30';
4
5	1	7µs			%ops = (
6					with_assign => "+ - * / % ** << >> x .",
7					assign => "+= -= = /= %= *= <<= >>= x= .=",
8					num_comparison => "< <= > >= == !=",
9					'3way_comparison' => "<=> cmp",
10					str_comparison => "lt le gt ge eq ne",
11					binary => '& &= \| \|= ^ ^= &. &.= \|. \|.= ^. ^.=',
12					unary => "neg ! ~ ~.",
13					mutators => '++ --',
14					func => "atan2 cos sin exp abs log sqrt int",
15					conversion => 'bool "" 0+ qr',
16					iterators => '<>',
17					filetest => "-X",
18					dereferencing => '${} @{} %{} &{} *{}',
19					matching => '~~',
20					special => 'nomethod fallback =',
21					);
22
23	1	100ns			my %ops_seen;
24	1	38µs			@ops_seen{ map split(/ /), values %ops } = ();
25
26					sub nil {}
27
28					# spent 199µs within overload::OVERLOAD which was called 6 times, avg 33µs/call: # 6 times (199µs+0s) by overload::import at line 57, avg 33µs/call sub OVERLOAD {
29	6	2µs			$package = shift;
30	6	13µs			my %arg = @_;
31	6	2µs			my $sub;
32	6	26µs			*{$package . "::(("} = \&nil; # Make it findable via fetchmethod.
33	6	52µs			for (keys %arg) {
34	15	12µs			if ($_ eq 'fallback') {
35	6	58µs			for my $sym (*{$package . "::()"}) {
36	6	5µs			*$sym = \&nil; # Make it findable via fetchmethod.
37	6	6µs			$$sym = $arg{$_};
38					}
39					} else {
40					warnings::warnif("overload arg '$_' is invalid")
41	9	10µs			unless exists $ops_seen{$_};
42	9	5µs			$sub = $arg{$_};
43	9	3µs			if (not ref $sub) {
44	4	11µs			$ {$package . "::(" . $_} = $sub;
45	4	3µs			$sub = \&nil;
46					}
47					#print STDERR "Setting '$ {'package'}::\cO$_' to \\&'$sub'.\n";
48	9	17µs			*{$package . "::(" . $_} = \&{ $sub };
49					}
50					}
51					}
52
53					# spent 281µs (82+199) within overload::import which was called 6 times, avg 47µs/call: # once (15µs+72µs) by Template::Exception::BEGIN@27 at line 27 of Template/Exception.pm # once (14µs+31µs) by File::Temp::Dir::BEGIN@1543 at line 1543 of File/Temp.pm # once (17µs+27µs) by Getopt::Long::CallBack::BEGIN@1568 at line 1568 of Getopt/Long.pm # once (13µs+30µs) by File::Temp::BEGIN@32 at line 32 of File/Temp.pm # once (16µs+22µs) by Path::Tiny::Error::BEGIN@2133 at line 2133 of Path/Tiny.pm # once (7µs+17µs) by Path::Tiny::BEGIN@29 at line 32 of Path/Tiny.pm sub import {
54	6	18µs			$package = (caller())[0];
55					# *{$package . "::OVERLOAD"} = \&OVERLOAD;
56	6	2µs			shift;
57	6	41µs	6	199µs	$package->overload::OVERLOAD(@_); # spent 199µs making 6 calls to overload::OVERLOAD, avg 33µs/call
58					}
59
60					sub unimport {
61					$package = (caller())[0];
62					shift;
63					*{$package . "::(("} = \&nil;
64					for (@_) {
65					warnings::warnif("overload arg '$_' is invalid")
66					unless exists $ops_seen{$_};
67					delete $ {$package . "::"}{$_ eq 'fallback' ? '()' : "(" .$_};
68					}
69					}
70
71					sub Overloaded {
72					my $package = shift;
73					$package = ref $package if ref $package;
74					mycan ($package, '()') \|\| mycan ($package, '((');
75					}
76
77					sub ov_method {
78					my $globref = shift;
79					return undef unless $globref;
80					my $sub = \&{*$globref};
81	2	188µs	2	23µs	# spent 17µs (12+5) within overload::BEGIN@81 which was called: # once (12µs+5µs) by Path::Tiny::BEGIN@29 at line 81 no overloading; # spent 17µs making 1 call to overload::BEGIN@81 # spent 5µs making 1 call to overloading::unimport
82					return $sub if $sub != \&nil;
83					return shift->can($ {*$globref});
84					}
85
86					sub OverloadedStringify {
87					my $package = shift;
88					$package = ref $package if ref $package;
89					#$package->can('(""')
90					ov_method mycan($package, '(""'), $package
91					or ov_method mycan($package, '(0+'), $package
92					or ov_method mycan($package, '(bool'), $package
93					or ov_method mycan($package, '(nomethod'), $package;
94					}
95
96					sub Method {
97					my $package = shift;
98					if(ref $package) {
99					local $@;
100					local $!;
101					require Scalar::Util;
102					$package = Scalar::Util::blessed($package);
103					return undef if !defined $package;
104					}
105					#my $meth = $package->can('(' . shift);
106					ov_method mycan($package, '(' . shift), $package;
107					#return $meth if $meth ne \&nil;
108					#return $ {*{$meth}};
109					}
110
111					sub AddrRef {
112	2	134µs	2	17µs	# spent 13µs (8+5) within overload::BEGIN@112 which was called: # once (8µs+5µs) by Path::Tiny::BEGIN@29 at line 112 no overloading; # spent 13µs making 1 call to overload::BEGIN@112 # spent 4µs making 1 call to overloading::unimport
113					"$_[0]";
114					}
115
116	1	1µs			StrVal = AddrRef;
117
118					sub mycan { # Real can would leave stubs.
119					my ($package, $meth) = @_;
120
121					local $@;
122					local $!;
123					require mro;
124
125					my $mro = mro::get_linear_isa($package);
126					foreach my $p (@$mro) {
127					my $fqmeth = $p . q{::} . $meth;
128					return \*{$fqmeth} if defined &{$fqmeth};
129					}
130
131					return undef;
132					}
133
134	1	1µs			%constants = (
135					'integer' => 0x1000, # HINT_NEW_INTEGER
136					'float' => 0x2000, # HINT_NEW_FLOAT
137					'binary' => 0x4000, # HINT_NEW_BINARY
138					'q' => 0x8000, # HINT_NEW_STRING
139					'qr' => 0x10000, # HINT_NEW_RE
140					);
141
142	2	224µs	2	73µs	# spent 39µs (6+34) within overload::BEGIN@142 which was called: # once (6µs+34µs) by Path::Tiny::BEGIN@29 at line 142 use warnings::register; # spent 39µs making 1 call to overload::BEGIN@142 # spent 34µs making 1 call to warnings::register::import
143					sub constant {
144					# Arguments: what, sub
145					while (@_) {
146					if (@_ == 1) {
147					warnings::warnif ("Odd number of arguments for overload::constant");
148					last;
149					}
150					elsif (!exists $constants {$_ [0]}) {
151					warnings::warnif ("'$_[0]' is not an overloadable type");
152					}
153					elsif (!ref $_ [1] \|\| "$_[1]" !~ /(^\|=)CODE$0x[0-9a-f]+$$/) {
154					# Can't use C<ref $_[1] eq "CODE"> above as code references can be
155					# blessed, and C<ref> would return the package the ref is blessed into.
156					if (warnings::enabled) {
157					$_ [1] = "undef" unless defined $_ [1];
158					warnings::warn ("'$_[1]' is not a code reference");
159					}
160					}
161					else {
162					$^H{$_[0]} = $_[1];
163					$^H \|= $constants{$_[0]};
164					}
165					shift, shift;
166					}
167					}
168
169					sub remove_constant {
170					# Arguments: what, sub
171					while (@_) {
172					delete $^H{$_[0]};
173					$^H &= ~ $constants{$_[0]};
174					shift, shift;
175					}
176					}
177
178	1	10µs			1;
179
180					__END__