Profile of Opcode.pm

Filename	/usr/local/perls/perl-5.26.1/lib/5.26.1/darwin-2level/Opcode.pm
Statements	Executed 0 statements in 0s

Subroutines
Calls	P	F	Exclusive Time	Inclusive Time	Subroutine
1	1	1	50µs	60.1ms	Opcode::::_safe_call_svOpcode::_safe_call_sv (xsub)
1	1	1	33µs	33µs	Opcode::::_safe_pkg_prepOpcode::_safe_pkg_prep (xsub)
1	1	1	6µs	6µs	Opcode::::opsetOpcode::opset (xsub)
1	1	1	3µs	3µs	Opcode::::invert_opsetOpcode::invert_opset (xsub)
0	0	0	0s	0s	Opcode::::BEGINOpcode::BEGIN
0	0	0	0s	0s	Opcode::::_init_optagsOpcode::_init_optags
0	0	0	0s	0s	Opcode::::opdumpOpcode::opdump
0	0	0	0s	0s	Opcode::::ops_to_opsetOpcode::ops_to_opset
0	0	0	0s	0s	Opcode::::opset_to_hexOpcode::opset_to_hex

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

Line	State ments	Time on line	Calls	Time in subs	Code
1					package Opcode;
2
3					use 5.006_001;
4
5					use strict;
6
7					our($VERSION, @ISA, @EXPORT_OK);
8
9					$VERSION = "1.39";
10
11					use Carp;
12					use Exporter ();
13					use XSLoader;
14
15					BEGIN {
16					@ISA = qw(Exporter);
17					@EXPORT_OK = qw(
18					opset ops_to_opset
19					opset_to_ops opset_to_hex invert_opset
20					empty_opset full_opset
21					opdesc opcodes opmask define_optag
22					opmask_add verify_opset opdump
23					);
24					}
25
26					sub opset (;@);
27					sub opset_to_hex ($);
28					sub opdump (;$);
29					use subs @EXPORT_OK;
30
31					XSLoader::load();
32
33					_init_optags();
34
35					sub ops_to_opset { opset @_ } # alias for old name
36
37					sub opset_to_hex ($) {
38					return "(invalid opset)" unless verify_opset($_[0]);
39					unpack("h*",$_[0]);
40					}
41
42					sub opdump (;$) {
43					my $pat = shift;
44					# handy utility: perl -MOpcode=opdump -e 'opdump File'
45					foreach(opset_to_ops(full_opset)) {
46					my $op = sprintf " %12s %s\n", $_, opdesc($_);
47					next if defined $pat and $op !~ m/$pat/i;
48					print $op;
49					}
50					}
51
- -
54					sub _init_optags {
55					my(%all, %seen);
56					@all{opset_to_ops(full_opset)} = (); # keys only
57
58					local($_);
59					local($/) = "\n=cut"; # skip to optags definition section
60					<DATA>;
61					$/ = "\n="; # now read in 'pod section' chunks
62					while(<DATA>) {
63					next unless m/^item\s+(:\w+)/;
64					my $tag = $1;
65
66					# Split into lines, keep only indented lines
67					my @lines = grep { m/^\s/ } split(/\n/);
68					foreach (@lines) { s/(?:\t\|--).*// } # delete comments
69					my @ops = map { split ' ' } @lines; # get op words
70
71					foreach(@ops) {
72					warn "$tag - $_ already tagged in $seen{$_}\n" if $seen{$_};
73					$seen{$_} = $tag;
74					delete $all{$_};
75					}
76					# opset will croak on invalid names
77					define_optag($tag, opset(@ops));
78					}
79					close(DATA);
80					warn "Untagged opnames: ".join(' ',keys %all)."\n" if %all;
81					}
82
83
84					1;
85
86					__DATA__
87
88					=head1 NAME
89
90					Opcode - Disable named opcodes when compiling perl code
91
92					=head1 SYNOPSIS
93
94					use Opcode;
95
96
97					=head1 DESCRIPTION
98
99					Perl code is always compiled into an internal format before execution.
100
101					Evaluating perl code (e.g. via "eval" or "do 'file'") causes
102					the code to be compiled into an internal format and then,
103					provided there was no error in the compilation, executed.
104					The internal format is based on many distinct I<opcodes>.
105
106					By default no opmask is in effect and any code can be compiled.
107
108					The Opcode module allow you to define an I<operator mask> to be in
109					effect when perl I<next> compiles any code. Attempting to compile code
110					which contains a masked opcode will cause the compilation to fail
111					with an error. The code will not be executed.
112
113					=head1 NOTE
114
115					The Opcode module is not usually used directly. See the ops pragma and
116					Safe modules for more typical uses.
117
118					=head1 WARNING
119
120					The authors make B<no warranty>, implied or otherwise, about the
121					suitability of this software for safety or security purposes.
122
123					The authors shall not in any case be liable for special, incidental,
124					consequential, indirect or other similar damages arising from the use
125					of this software.
126
127					Your mileage will vary. If in any doubt B<do not use it>.
128
129
130					=head1 Operator Names and Operator Lists
131
132					The canonical list of operator names is the contents of the array
133					PL_op_name defined and initialised in file F<opcode.h> of the Perl
134					source distribution (and installed into the perl library).
135
136					Each operator has both a terse name (its opname) and a more verbose or
137					recognisable descriptive name. The opdesc function can be used to
138					return a list of descriptions for a list of operators.
139
140					Many of the functions and methods listed below take a list of
141					operators as parameters. Most operator lists can be made up of several
142					types of element. Each element can be one of
143
144					=over 8
145
146					=item an operator name (opname)
147
148					Operator names are typically small lowercase words like enterloop,
149					leaveloop, last, next, redo etc. Sometimes they are rather cryptic
150					like gv2cv, i_ncmp and ftsvtx.
151
152					=item an operator tag name (optag)
153
154					Operator tags can be used to refer to groups (or sets) of operators.
155					Tag names always begin with a colon. The Opcode module defines several
156					optags and the user can define others using the define_optag function.
157
158					=item a negated opname or optag
159
160					An opname or optag can be prefixed with an exclamation mark, e.g., !mkdir.
161					Negating an opname or optag means remove the corresponding ops from the
162					accumulated set of ops at that point.
163
164					=item an operator set (opset)
165
166					An I<opset> as a binary string of approximately 44 bytes which holds a
167					set or zero or more operators.
168
169					The opset and opset_to_ops functions can be used to convert from
170					a list of operators to an opset and I<vice versa>.
171
172					Wherever a list of operators can be given you can use one or more opsets.
173					See also Manipulating Opsets below.
174
175					=back
176
177
178					=head1 Opcode Functions
179
180					The Opcode package contains functions for manipulating operator names
181					tags and sets. All are available for export by the package.
182
183					=over 8
184
185					=item opcodes
186
187					In a scalar context opcodes returns the number of opcodes in this
188					version of perl (around 350 for perl-5.7.0).
189
190					In a list context it returns a list of all the operator names.
191					(Not yet implemented, use @names = opset_to_ops(full_opset).)
192
193					=item opset (OP, ...)
194
195					Returns an opset containing the listed operators.
196
197					=item opset_to_ops (OPSET)
198
199					Returns a list of operator names corresponding to those operators in
200					the set.
201
202					=item opset_to_hex (OPSET)
203
204					Returns a string representation of an opset. Can be handy for debugging.
205
206					=item full_opset
207
208					Returns an opset which includes all operators.
209
210					=item empty_opset
211
212					Returns an opset which contains no operators.
213
214					=item invert_opset (OPSET)
215
216					Returns an opset which is the inverse set of the one supplied.
217
218					=item verify_opset (OPSET, ...)
219
220					Returns true if the supplied opset looks like a valid opset (is the
221					right length etc) otherwise it returns false. If an optional second
222					parameter is true then verify_opset will croak on an invalid opset
223					instead of returning false.
224
225					Most of the other Opcode functions call verify_opset automatically
226					and will croak if given an invalid opset.
227
228					=item define_optag (OPTAG, OPSET)
229
230					Define OPTAG as a symbolic name for OPSET. Optag names always start
231					with a colon C<:>.
232
233					The optag name used must not be defined already (define_optag will
234					croak if it is already defined). Optag names are global to the perl
235					process and optag definitions cannot be altered or deleted once
236					defined.
237
238					It is strongly recommended that applications using Opcode should use a
239					leading capital letter on their tag names since lowercase names are
240					reserved for use by the Opcode module. If using Opcode within a module
241					you should prefix your tags names with the name of your module to
242					ensure uniqueness and thus avoid clashes with other modules.
243
244					=item opmask_add (OPSET)
245
246					Adds the supplied opset to the current opmask. Note that there is
247					currently I<no> mechanism for unmasking ops once they have been masked.
248					This is intentional.
249
250					=item opmask
251
252					Returns an opset corresponding to the current opmask.
253
254					=item opdesc (OP, ...)
255
256					This takes a list of operator names and returns the corresponding list
257					of operator descriptions.
258
259					=item opdump (PAT)
260
261					Dumps to STDOUT a two column list of op names and op descriptions.
262					If an optional pattern is given then only lines which match the
263					(case insensitive) pattern will be output.
264
265					It's designed to be used as a handy command line utility:
266
267					perl -MOpcode=opdump -e opdump
268					perl -MOpcode=opdump -e 'opdump Eval'
269
270					=back
271
272					=head1 Manipulating Opsets
273
274					Opsets may be manipulated using the perl bit vector operators & (and), \| (or),
275					^ (xor) and ~ (negate/invert).
276
277					However you should never rely on the numerical position of any opcode
278					within the opset. In other words both sides of a bit vector operator
279					should be opsets returned from Opcode functions.
280
281					Also, since the number of opcodes in your current version of perl might
282					not be an exact multiple of eight, there may be unused bits in the last
283					byte of an upset. This should not cause any problems (Opcode functions
284					ignore those extra bits) but it does mean that using the ~ operator
285					will typically not produce the same 'physical' opset 'string' as the
286					invert_opset function.
287
288
289					=head1 TO DO (maybe)
290
291					$bool = opset_eq($opset1, $opset2) true if opsets are logically
292					equivalent
293					$yes = opset_can($opset, @ops) true if $opset has all @ops set
294
295					@diff = opset_diff($opset1, $opset2) => ('foo', '!bar', ...)
296
297					=cut
298
299					# the =cut above is used by _init_optags() to get here quickly
300
301					=head1 Predefined Opcode Tags
302
303					=over 5
304
305					=item :base_core
306
307					null stub scalar pushmark wantarray const defined undef
308
309					rv2sv sassign
310
311					rv2av aassign aelem aelemfast aelemfast_lex aslice kvaslice
312					av2arylen
313
314					rv2hv helem hslice kvhslice each values keys exists delete
315					aeach akeys avalues multideref argelem argdefelem argcheck
316
317					preinc i_preinc predec i_predec postinc i_postinc
318					postdec i_postdec int hex oct abs pow multiply i_multiply
319					divide i_divide modulo i_modulo add i_add subtract i_subtract
320
321					left_shift right_shift bit_and bit_xor bit_or nbit_and
322					nbit_xor nbit_or sbit_and sbit_xor sbit_or negate i_negate not
323					complement ncomplement scomplement
324
325					lt i_lt gt i_gt le i_le ge i_ge eq i_eq ne i_ne ncmp i_ncmp
326					slt sgt sle sge seq sne scmp
327
328					substr vec stringify study pos length index rindex ord chr
329
330					ucfirst lcfirst uc lc fc quotemeta trans transr chop schop
331					chomp schomp
332
333					match split qr
334
335					list lslice splice push pop shift unshift reverse
336
337					cond_expr flip flop andassign orassign dorassign and or dor xor
338
339					warn die lineseq nextstate scope enter leave
340
341					rv2cv anoncode prototype coreargs avhvswitch anonconst
342
343					entersub leavesub leavesublv return method method_named
344					method_super method_redir method_redir_super
345					-- XXX loops via recursion?
346
347					leaveeval -- needed for Safe to operate, is safe
348					without entereval
349
350					=item :base_mem
351
352					These memory related ops are not included in :base_core because they
353					can easily be used to implement a resource attack (e.g., consume all
354					available memory).
355
356					concat repeat join range
357
358					anonlist anonhash
359
360					Note that despite the existence of this optag a memory resource attack
361					may still be possible using only :base_core ops.
362
363					Disabling these ops is a I<very> heavy handed way to attempt to prevent
364					a memory resource attack. It's probable that a specific memory limit
365					mechanism will be added to perl in the near future.
366
367					=item :base_loop
368
369					These loop ops are not included in :base_core because they can easily be
370					used to implement a resource attack (e.g., consume all available CPU time).
371
372					grepstart grepwhile
373					mapstart mapwhile
374					enteriter iter
375					enterloop leaveloop unstack
376					last next redo
377					goto
378
379					=item :base_io
380
381					These ops enable I<filehandle> (rather than filename) based input and
382					output. These are safe on the assumption that only pre-existing
383					filehandles are available for use. Usually, to create new filehandles
384					other ops such as open would need to be enabled, if you don't take into
385					account the magical open of ARGV.
386
387					readline rcatline getc read
388
389					formline enterwrite leavewrite
390
391					print say sysread syswrite send recv
392
393					eof tell seek sysseek
394
395					readdir telldir seekdir rewinddir
396
397					=item :base_orig
398
399					These are a hotchpotch of opcodes still waiting to be considered
400
401					gvsv gv gelem
402
403					padsv padav padhv padcv padany padrange introcv clonecv
404
405					once
406
407					rv2gv refgen srefgen ref refassign lvref lvrefslice lvavref
408
409					bless -- could be used to change ownership of objects
410					(reblessing)
411
412					regcmaybe regcreset regcomp subst substcont
413
414					sprintf prtf -- can core dump
415
416					crypt
417
418					tie untie
419
420					dbmopen dbmclose
421					sselect select
422					pipe_op sockpair
423
424					getppid getpgrp setpgrp getpriority setpriority
425					localtime gmtime
426
427					entertry leavetry -- can be used to 'hide' fatal errors
428
429					entergiven leavegiven
430					enterwhen leavewhen
431					break continue
432					smartmatch
433
434					custom -- where should this go
435
436					=item :base_math
437
438					These ops are not included in :base_core because of the risk of them being
439					used to generate floating point exceptions (which would have to be caught
440					using a $SIG{FPE} handler).
441
442					atan2 sin cos exp log sqrt
443
444					These ops are not included in :base_core because they have an effect
445					beyond the scope of the compartment.
446
447					rand srand
448
449					=item :base_thread
450
451					These ops are related to multi-threading.
452
453					lock
454
455					=item :default
456
457					A handy tag name for a I<reasonable> default set of ops. (The current ops
458					allowed are unstable while development continues. It will change.)
459
460					:base_core :base_mem :base_loop :base_orig :base_thread
461
462					This list used to contain :base_io prior to Opcode 1.07.
463
464					If safety matters to you (and why else would you be using the Opcode module?)
465					then you should not rely on the definition of this, or indeed any other, optag!
466
467					=item :filesys_read
468
469					stat lstat readlink
470
471					ftatime ftblk ftchr ftctime ftdir fteexec fteowned
472					fteread ftewrite ftfile ftis ftlink ftmtime ftpipe
473					ftrexec ftrowned ftrread ftsgid ftsize ftsock ftsuid
474					fttty ftzero ftrwrite ftsvtx
475
476					fttext ftbinary
477
478					fileno
479
480					=item :sys_db
481
482					ghbyname ghbyaddr ghostent shostent ehostent -- hosts
483					gnbyname gnbyaddr gnetent snetent enetent -- networks
484					gpbyname gpbynumber gprotoent sprotoent eprotoent -- protocols
485					gsbyname gsbyport gservent sservent eservent -- services
486
487					gpwnam gpwuid gpwent spwent epwent getlogin -- users
488					ggrnam ggrgid ggrent sgrent egrent -- groups
489
490					=item :browse
491
492					A handy tag name for a I<reasonable> default set of ops beyond the
493					:default optag. Like :default (and indeed all the other optags) its
494					current definition is unstable while development continues. It will change.
495
496					The :browse tag represents the next step beyond :default. It it a
497					superset of the :default ops and adds :filesys_read the :sys_db.
498					The intent being that scripts can access more (possibly sensitive)
499					information about your system but not be able to change it.
500
501					:default :filesys_read :sys_db
502
503					=item :filesys_open
504
505					sysopen open close
506					umask binmode
507
508					open_dir closedir -- other dir ops are in :base_io
509
510					=item :filesys_write
511
512					link unlink rename symlink truncate
513
514					mkdir rmdir
515
516					utime chmod chown
517
518					fcntl -- not strictly filesys related, but possibly as
519					dangerous?
520
521					=item :subprocess
522
523					backtick system
524
525					fork
526
527					wait waitpid
528
529					glob -- access to Cshell via <`rm *`>
530
531					=item :ownprocess
532
533					exec exit kill
534
535					time tms -- could be used for timing attacks (paranoid?)
536
537					=item :others
538
539					This tag holds groups of assorted specialist opcodes that don't warrant
540					having optags defined for them.
541
542					SystemV Interprocess Communications:
543
544					msgctl msgget msgrcv msgsnd
545
546					semctl semget semop
547
548					shmctl shmget shmread shmwrite
549
550					=item :load
551
552					This tag holds opcodes related to loading modules and getting information
553					about calling environment and args.
554
555					require dofile
556					caller runcv
557
558					=item :still_to_be_decided
559
560					chdir
561					flock ioctl
562
563					socket getpeername ssockopt
564					bind connect listen accept shutdown gsockopt getsockname
565
566					sleep alarm -- changes global timer state and signal handling
567					sort -- assorted problems including core dumps
568					tied -- can be used to access object implementing a tie
569					pack unpack -- can be used to create/use memory pointers
570
571					hintseval -- constant op holding eval hints
572
573					entereval -- can be used to hide code from initial compile
574
575					reset
576
577					dbstate -- perl -d version of nextstate(ment) opcode
578
579					=item :dangerous
580
581					This tag is simply a bucket for opcodes that are unlikely to be used via
582					a tag name but need to be tagged for completeness and documentation.
583
584					syscall dump chroot
585
586					=back
587
588					=head1 SEE ALSO
589
590					L<ops> -- perl pragma interface to Opcode module.
591
592					L<Safe> -- Opcode and namespace limited execution compartments
593
594					=head1 AUTHORS
595
596					Originally designed and implemented by Malcolm Beattie,
597					[email protected] as part of Safe version 1.
598
599					Split out from Safe module version 1, named opcode tags and other
600					changes added by Tim Bunce.
601
602					=cut
603

					# spent 60.1ms (50µs+60.0) within Opcode::_safe_call_sv which was called: # once (50µs+60.0ms) by Safe::reval at line 366 of Safe.pm sub Opcode::_safe_call_sv; # xsub
					# spent 33µs within Opcode::_safe_pkg_prep which was called: # once (33µs+0s) by Safe::new at line 176 of Safe.pm sub Opcode::_safe_pkg_prep; # xsub
					# spent 3µs within Opcode::invert_opset which was called: # once (3µs+0s) by Safe::permit_only at line 262 of Safe.pm sub Opcode::invert_opset; # xsub
					# spent 6µs within Opcode::opset which was called: # once (6µs+0s) by Safe::permit_only at line 262 of Safe.pm sub Opcode::opset; # xsub