1#!perl 2 3=head1 F<regen/op_private> 4 5This file contains all the definitions of the meanings of the flags in the 6op_private field of an OP. 7 8After editing this file, run C<make regen>. This will generate/update data 9in: 10 11 opcode.h 12 lib/B/Op_private.pm 13 14C<B::Op_private> holds three global hashes, C<%bits>, C<%defines>, 15C<%labels>, which hold roughly the same information as found in this file 16(after processing). 17 18F<opcode.h> gains a series of C<OPp*> defines, and a few static data 19structures: 20 21C<PL_op_private_valid> defines, per-op, which op_private bits are legally 22allowed to be set. This is a good first place to look to see if an op has 23any spare private bits. 24 25C<PL_op_private_bitdef_ix>, C<PL_op_private_bitdefs>, 26C<PL_op_private_labels>, C<PL_op_private_bitfields>, 27C<PL_op_private_valid> contain (in a compact form) the data needed by 28Perl_do_op_dump() to dump the op_private field of an op. 29 30This file actually contains perl code which is run by F<regen/opcode.pl>. 31The basic idea is that you keep calling addbits() to add definitions of 32what a particular bit or range of bits in op_private means for a 33particular op. This can be specified either as a 1-bit flag or a 1-or-more 34bit bit field. Here's a general example: 35 36 addbits('aelem', 37 7 => qw(OPpLVAL_INTRO LVINTRO), 38 6 => qw(OPpLVAL_DEFER LVDEFER), 39 '4..5' => { 40 mask_def => 'OPpDEREF', 41 enum => [ qw( 42 1 OPpDEREF_AV DREFAV 43 2 OPpDEREF_HV DREFHV 44 3 OPpDEREF_SV DREFSV 45 )], 46 }, 47 ); 48 49Here for the op C<aelem>, bits 6 and 7 (bits are numbered 0..7) are 50defined as single-bit flags. The first string following the bit number is 51the define name that gets emitted in F<opcode.h>, and the second string is 52the label, which will be displayed by F<Concise.pm> and Perl_do_op_dump() 53(as used by C<perl -Dx>). 54 55If the bit number is actually two numbers connected with '..', then this 56defines a bit field, which is 1 or more bits taken to hold a small 57unsigned integer. Instead of two string arguments, it just has a single 58hash ref argument. A bit field allows you to generate extra defines, such 59as a mask, and optionally allows you to define an enumeration, where a 60subset of the possible values of the bit field are given their own defines 61and labels. The full syntax of this hash is explained further below. 62 63Note that not all bits for a particular op need to be added in a single 64addbits() call; they accumulate. In particular, this file is arranged in 65two halves; first, generic flags shared by multiple ops are added, then 66in the second half, specific per-op flags are added, e.g. 67 68 addbits($_, 7 => qw(OPpLVAL_INTRO LVINTRO)) for qw(pos substr vec ...); 69 70 .... 71 72 addbits('substr', 73 4 => qw(OPpSUBSTR_REPL_FIRST REPL1ST), 74 3 => ... 75 ); 76 77(although the dividing line between these two halves is somewhat 78subjective, and is based on whether "OPp" is followed by the op name or 79something generic). 80 81There are some utility functions for generating a list of ops from 82F<regen/opcodes> based on various criteria. These are: 83 84 ops_with_check('ck_foo') 85 ops_with_flag('X') 86 ops_with_arg(N, 'XYZ') 87 88which respectively return a list of op names where: 89 90 field 3 of regen/opcodes specifies 'ck_foo' as the check function; 91 field 4 of of regen/opcodes has flag or type 'X' set; 92 argument field N of of regen/opcodes matches 'XYZ'; 93 94For example 95 96 addbits($_, 4 => qw(OPpTARGET_MY TARGMY)) for ops_with_flag('T'); 97 98If a label is specified as '-', then the flag or bit field is not 99displayed symbolically by Concise/-Dx; instead the bits are treated as 100unrecognised and are included in the final residual integer value after 101all recognised bits have been processed (this doesn't apply to individual 102enum labels). 103 104Here is a full example of a bit field hash: 105 106 '5..6' => { 107 mask_def => 'OPpFOO_MASK', 108 baseshift_def => 'OPpFOO_SHIFT', 109 bitcount_def => 'OPpFOO_BITS', 110 label => 'FOO', 111 enum => [ qw( 112 1 OPpFOO_A A 113 2 OPpFOO_B B 114 3 OPpFOO_C C 115 )], 116 }; 117 118The optional C<*_def> keys cause defines to be emitted that specify 119useful values based on the bit range (5 to 6 in this case): 120 121 mask_def: a mask that will extract the bit field 122 baseshift_def: how much to shift to make the bit field reach bit 0 123 bitcount_def: how many bits make up the bit field 124 125The example above will generate 126 127 #define OPpFOO_MASK 0x60 128 #define OPpFOO_SHIFT 5 129 #define OPpFOO_BITS 2 130 131The optional enum list specifies a set of defines and labels for (possibly 132a subset of) the possible values of the bit field (which in this example 133are 0,1,2,3). If a particular value matches an enum, then it will be 134displayed symbolically (e.g. 'C'), otherwise as a small integer. The 135defines are suitably shifted. The example above will generate 136 137 #define OPpFOO_A 0x20 138 #define OPpFOO_B 0x40 139 #define OPpFOO_C 0x60 140 141So you can write code like 142 143 if ((o->op_private & OPpFOO_MASK) == OPpFOO_C) ... 144 145The optional 'label' key causes Concise/-Dx output to prefix the value 146with C<LABEL=>; so in this case it might display C<FOO=C>. If the field 147value is zero, and if no label is present, and if no enum matches, then 148the field isn't displayed. 149 150=cut 151 152 153use warnings; 154use strict; 155 156 157 158 159# ==================================================================== 160# 161# GENERIC OPpFOO flags 162# 163# Flags where FOO is a generic term (like LVAL), and the flag is 164# shared between multiple (possibly unrelated) ops. 165 166 167 168 169{ 170 # The lower few bits of op_private often indicate the number of 171 # arguments. This is usually set by newUNOP() and newLOGOP (to 1), 172 # by newBINOP() (to 1 or 2), and by ck_fun() (to 1..15). 173 # 174 # These values are sometimes used at runtime: in particular, 175 # the MAXARG macro extracts out the lower 4 bits. 176 # 177 # Some ops encroach upon these bits; for example, entersub is a unop, 178 # but uses bit 0 for something else. Bit 0 is initially set to 1 in 179 # newUNOP(), but is later cleared (in ck_rvconst()), when the code 180 # notices that this op is an entersub. 181 # 182 # The important thing below is that any ops which use MAXARG at 183 # runtime must have all 4 bits allocated; if bit 3 were used for a new 184 # flag say, then things could break. The information on the other 185 # types of op is for completeness (so we can account for every bit 186 # used in every op) 187 188 my (%maxarg, %args0, %args1, %args2, %args3, %args4); 189 190 # these are the functions which currently use MAXARG at runtime 191 # (i.e. in the pp() functions). Thus they must always have 4 bits 192 # allocated 193 $maxarg{$_} = 1 for qw( 194 binmode bless caller chdir close enterwrite eof exit fileno getc 195 getpgrp gmtime index mkdir rand reset setpgrp sleep srand sysopen 196 tell umask 197 ); 198 199 # find which ops use 0,1,2,3 or 4 bits of op_private for arg count info 200 201 $args0{$_} = 1 for qw(entersub avhvswitch 202 rv2hv); # UNOPs that usurp bit 0 203 204 $args1{$_} = 1 for ( 205 qw(reverse), # ck_fun(), but most bits stolen 206 qw(mapstart grepstart), # set in ck_fun, but 207 # cleared in ck_grep, 208 # unless there is an error 209 grep !$maxarg{$_} && !$args0{$_}, 210 ops_with_flag('1'), # UNOP 211 ops_with_flag('+'), # UNOP_AUX 212 ops_with_flag('%'), # BASEOP/UNOP 213 ops_with_flag('|'), # LOGOP 214 ops_with_flag('-'), # FILESTATOP 215 ops_with_flag('}'), # LOOPEXOP 216 ops_with_flag('.'), # METHOP 217 ); 218 219 $args2{$_} = 1 for ( 220 qw(vec), 221 grep !$maxarg{$_} && !$args0{$_} && !$args1{$_}, 222 ops_with_flag('2'), # BINOP 223 ); 224 225 $args3{$_} = 1 for grep !$maxarg{$_} && !$args0{$_} 226 && !$args1{$_} && !$args2{$_}, 227 # substr starts off with 4 bits set in 228 # ck_fun(), but since it never has more than 7 229 # args, bit 3 is later stolen 230 qw(substr); 231 232 $args4{$_} = 1 for keys %maxarg, 233 grep !$args0{$_} && !$args1{$_} 234 && !$args2{$_} && !$args3{$_}, 235 ops_with_check('ck_fun'), 236 # these other ck_*() functions call ck_fun() 237 ops_with_check('ck_exec'), 238 ops_with_check('ck_glob'), 239 ops_with_check('ck_index'), 240 ops_with_check('ck_join'), 241 ops_with_check('ck_lfun'), 242 ops_with_check('ck_open'), 243 ops_with_check('ck_select'), 244 ops_with_check('ck_stringify'), 245 ops_with_check('ck_tell'), 246 ops_with_check('ck_trunc'), 247 ; 248 249 250 for (sort keys %args1) { 251 addbits($_, '0..0' => { 252 mask_def => 'OPpARG1_MASK', 253 label => '-', 254 } 255 ); 256 } 257 258 for (sort keys %args2) { 259 addbits($_, '0..1' => { 260 mask_def => 'OPpARG2_MASK', 261 label => '-', 262 } 263 ); 264 } 265 266 for (sort keys %args3) { 267 addbits($_, '0..2' => { 268 mask_def => 'OPpARG3_MASK', 269 label => '-', 270 } 271 ); 272 } 273 274 for (sort keys %args4) { 275 addbits($_, '0..3' => { 276 mask_def => 'OPpARG4_MASK', 277 label => '-', 278 } 279 ); 280 } 281} 282 283 284 285# if NATIVE_HINTS is defined, op_private on cops holds the top 8 bits 286# of PL_hints, although only bits 6 & 7 are officially used for that 287# purpose (the rest ought to be masked off). Bit 5 is set separately 288 289for (qw(nextstate dbstate)) { 290 addbits($_, 291 5 => qw(OPpHUSH_VMSISH HUSH), 292 ); 293} 294 295 296# op is in local context, or pad variable is being introduced, e.g. 297# local $h{foo} 298# my $x 299 300addbits($_, 7 => qw(OPpLVAL_INTRO LVINTRO)) 301 for qw(gvsv rv2sv rv2hv rv2gv rv2av aelem helem aslice split 302 hslice delete padsv padav padhv enteriter entersub padrange 303 pushmark cond_expr refassign lvref lvrefslice lvavref multideref 304 multiconcat), 305 'list', # this gets set in my_attrs() for some reason 306 ; 307 308 309 310# TARGLEX 311# 312# in constructs like my $x; ...; $x = $a + $b, 313# the sassign is optimised away and OPpTARGET_MY is set on the add op 314# 315# Note that OPpTARGET_MY is mainly used at compile-time. At run time, 316# the pp function just updates the SV pointed to by op_targ, and doesn't 317# care whether that's a PADTMP or a lexical var. 318 319# Some comments about when its safe to use T/OPpTARGET_MY. 320# 321# Safe to set if the ppcode uses: 322# tryAMAGICbin, tryAMAGICun, SETn, SETi, SETu, PUSHn, PUSHTARG, SETTARG, 323# SETs(TARG), XPUSHn, XPUSHu, 324# but make sure set-magic is invoked separately for SETs(TARG) (or change 325# it to SETTARG). 326# 327# Unsafe to set if the ppcode uses dTARG or [X]RETPUSH[YES|NO|UNDEF] 328# 329# Only the code paths that handle scalar rvalue context matter. If dTARG 330# or RETPUSHNO occurs only in list or lvalue paths, T is safe. 331# 332# lt and friends do SETs (including ncmp, but not scmp or i_ncmp) 333# 334# Additional mode of failure: the opcode can modify TARG before it "used" 335# all the arguments (or may call an external function which does the same). 336# If the target coincides with one of the arguments ==> kaboom. 337# 338# pp.c pos substr each not OK (RETPUSHUNDEF) 339# ref not OK (RETPUSHNO) 340# trans not OK (target is used for lhs, not retval) 341# ucfirst etc not OK: TMP arg processed inplace 342# quotemeta not OK (unsafe when TARG == arg) 343# pack - unknown whether it is safe 344# sprintf: is calling do_sprintf(TARG,...) which can act on TARG 345# before other args are processed. 346# 347# Suspicious wrt "additional mode of failure" (and only it): 348# schop, chop, postinc/dec, bit_and etc, negate, complement. 349# 350# Also suspicious: 4-arg substr, sprintf, uc/lc (POK_only), reverse, pack. 351# 352# substr/vec: doing TAINT_off()??? 353# 354# pp_hot.c 355# readline - unknown whether it is safe 356# match subst not OK (dTARG) 357# grepwhile not OK (not always setting) 358# join not OK (unsafe when TARG == arg) 359# 360# concat - pp_concat special-cases TARG==arg to avoid 361# "additional mode of failure" 362# 363# pp_ctl.c 364# mapwhile flip caller not OK (not always setting) 365# 366# pp_sys.c 367# backtick glob warn die not OK (not always setting) 368# warn not OK (RETPUSHYES) 369# open fileno getc sysread syswrite ioctl accept shutdown 370# ftsize(etc) readlink telldir fork alarm getlogin not OK (RETPUSHUNDEF) 371# umask select not OK (XPUSHs(&PL_sv_undef);) 372# fileno getc sysread syswrite tell not OK (meth("FILENO" "GETC")) 373# sselect shm* sem* msg* syscall - unknown whether they are safe 374# gmtime not OK (list context) 375# 376# Suspicious wrt "additional mode of failure": warn, die, select. 377 378 379addbits($_, 4 => qw(OPpTARGET_MY TARGMY)) 380 for ops_with_flag('T'), 381; 382 383 384 385 386 387# op_targ carries a refcount 388addbits($_, 6 => qw(OPpREFCOUNTED REFC)) 389 for qw(leave leavesub leavesublv leavewrite leaveeval); 390 391 392 393# Do not copy return value 394addbits($_, 7 => qw(OPpLVALUE LV)) for qw(leave leaveloop); 395 396 397 398# autovivify: Want ref to something 399for (qw(rv2gv rv2sv padsv aelem helem entersub)) { 400 addbits($_, '4..5' => { 401 mask_def => 'OPpDEREF', 402 enum => [ qw( 403 1 OPpDEREF_AV DREFAV 404 2 OPpDEREF_HV DREFHV 405 3 OPpDEREF_SV DREFSV 406 )], 407 } 408 ); 409} 410 411 412 413# Defer creation of array/hash elem 414addbits($_, 6 => qw(OPpLVAL_DEFER LVDEFER)) for qw(aelem helem multideref); 415 416 417 418addbits($_, 2 => qw(OPpSLICEWARNING SLICEWARN)) # warn about @hash{$scalar} 419 for qw(rv2hv rv2av padav padhv hslice aslice); 420 421 422 423# XXX Concise seemed to think that OPpOUR_INTRO is used in rv2gv too, 424# but I can't see it - DAPM 425addbits($_, 6 => qw(OPpOUR_INTRO OURINTR)) # Variable was in an our() 426 for qw(gvsv rv2sv rv2av rv2hv enteriter split); 427 428 429 430# We might be an lvalue to return 431# 'values' doesn't actually use this bit, but we reserve it here as 432# pp_values may call Perl_do_kv() which is shared among several ops which 433# do. 434 435addbits($_, 3 => qw(OPpMAYBE_LVSUB LVSUB)) 436 for qw(aassign rv2av rv2gv rv2hv padav padhv aelem helem aslice hslice 437 av2arylen keys akeys avhvswitch kvaslice kvhslice substr pos vec 438 multideref values); 439 440 441 442for (qw(rv2hv padhv ref)) { 443 addbits($_, # e.g. %hash in (%hash || $foo) ... 444 4 => qw(OPpMAYBE_TRUEBOOL BOOL?), # but cx not known till run time 445 5 => qw(OPpTRUEBOOL BOOL), 446 ); 447} 448for (qw(grepwhile index length padav pos rindex rv2av subst)) { 449 addbits($_, 450 5 => qw(OPpTRUEBOOL BOOL), # if (@a) {...} 451 ); 452} 453 454 455addbits($_, 1 => qw(OPpHINT_STRICT_REFS STRICT)) 456 for qw(rv2sv rv2av rv2hv rv2gv multideref); 457 458 459 460# Treat caller(1) as caller(2) 461addbits($_, 7 => qw(OPpOFFBYONE +1)) for qw(caller wantarray runcv); 462 463 464 465# label is in UTF8 */ 466addbits($_, 7 => qw(OPpPV_IS_UTF8 UTF)) for qw(last redo next goto dump); 467 468 469 470# ==================================================================== 471# 472# OP-SPECIFIC OPpFOO_* flags: 473# 474# where FOO is typically the name of an op, and the flag is used by a 475# single op (or maybe by a few closely related ops). 476 477 478 479# note that for refassign, this bit can mean either OPpPAD_STATE or 480# OPpOUR_INTRO depending on the type of the LH child, .e.g. 481# \our $foo = ... 482# \state $foo = ... 483 484addbits($_, 6 => qw(OPpPAD_STATE STATE)) for qw(padav padhv padsv lvavref 485 lvref refassign pushmark); 486 487# NB: both sassign and aassign use the 'OPpASSIGN' naming convention 488# for their private flags 489 490# there *may* be common scalar items on both sides of a list assign: 491# run-time checking will be needed. 492addbits('aassign', 6 => qw(OPpASSIGN_COMMON_SCALAR COM_SCALAR)); 493# 494# as above, but it's possible to check for non-commonality with just 495# a SvREFCNT(lhs) == 1 test for each lhs element 496addbits('aassign', 5 => qw(OPpASSIGN_COMMON_RC1 COM_RC1)); 497 498# run-time checking is required for an aggregate on the LHS 499addbits('aassign', 4 => qw(OPpASSIGN_COMMON_AGG COM_AGG)); 500 501addbits('aassign', 2 => qw(OPpASSIGN_TRUEBOOL BOOL)); # if (@a = (...)) {...} 502 503 504# NB: both sassign and aassign use the 'OPpASSIGN' naming convention 505# for their private flags 506 507addbits('sassign', 508 6 => qw(OPpASSIGN_BACKWARDS BKWARD), # Left & right switched 509 7 => qw(OPpASSIGN_CV_TO_GV CV2GV), # Possible optimisation for constants 510); 511 512 513 514for (qw(trans transr)) { 515 addbits($_, 516 0 => qw(OPpTRANS_FROM_UTF <UTF), # search chars are utf8 517 1 => qw(OPpTRANS_TO_UTF >UTF), # replacement chars are utf8 518 2 => qw(OPpTRANS_IDENTICAL IDENT), # right side is same as left 519 3 => qw(OPpTRANS_SQUASH SQUASH), # /s 520 # 4 is used for OPpTARGET_MY 521 5 => qw(OPpTRANS_COMPLEMENT COMPL), # /c 522 6 => qw(OPpTRANS_GROWS GROWS), # replacement chars longer than 523 # src chars 524 7 => qw(OPpTRANS_DELETE DEL), # /d 525 ); 526} 527 528 529 530addbits('repeat', 6 => qw(OPpREPEAT_DOLIST DOLIST)); # List replication 531 532 533 534# OP_ENTERSUB and OP_RV2CV flags 535# 536# Flags are set on entersub and rv2cv in three phases: 537# parser - the parser passes the flag to the op constructor 538# check - the check routine called by the op constructor sets the flag 539# context - application of scalar/ref/lvalue context applies the flag 540# 541# In the third stage, an entersub op might turn into an rv2cv op (undef &foo, 542# \&foo, lock &foo, exists &foo, defined &foo). The two places where that 543# happens (op_lvalue_flags and doref in op.c) need to make sure the flags do 544# not conflict, since some flags with different meanings overlap between 545# the two ops. Flags applied in the context phase are only set when there 546# is no conversion of op type. 547# 548# bit entersub flag phase rv2cv flag phase 549# --- ------------- ----- ---------- ----- 550# 0 OPpENTERSUB_INARGS context 551# 1 HINT_STRICT_REFS check HINT_STRICT_REFS check 552# 2 OPpENTERSUB_HASTARG checki OPpENTERSUB_HASTARG 553# 3 OPpENTERSUB_AMPER check OPpENTERSUB_AMPER parser 554# 4 OPpDEREF_AV context 555# 5 OPpDEREF_HV context OPpMAY_RETURN_CONSTANT parser/context 556# 6 OPpENTERSUB_DB check OPpENTERSUB_DB 557# 7 OPpLVAL_INTRO context OPpENTERSUB_NOPAREN parser 558 559# NB: OPpHINT_STRICT_REFS must equal HINT_STRICT_REFS 560 561addbits('entersub', 562 0 => qw(OPpENTERSUB_INARGS INARGS), # Lval used as arg to a sub 563 1 => qw(OPpHINT_STRICT_REFS STRICT), # 'use strict' in scope 564 2 => qw(OPpENTERSUB_HASTARG TARG ), # Called from OP tree 565 3 => qw(OPpENTERSUB_AMPER AMPER), # Used & form to call 566 # 4..5 => OPpDEREF, already defined above 567 6 => qw(OPpENTERSUB_DB DBG ), # Debug subroutine 568 # 7 => OPpLVAL_INTRO, already defined above 569); 570 571# note that some of these flags are just left-over from when an entersub 572# is converted into an rv2cv, and could probably be cleared/re-assigned 573 574addbits('rv2cv', 575 1 => qw(OPpHINT_STRICT_REFS STRICT), # 'use strict' in scope 576 2 => qw(OPpENTERSUB_HASTARG TARG ), # If const sub, return the const 577 3 => qw(OPpENTERSUB_AMPER AMPER ), # Used & form to call 578 579 5 => qw(OPpMAY_RETURN_CONSTANT CONST ), 580 6 => qw(OPpENTERSUB_DB DBG ), # Debug subroutine 581 7 => qw(OPpENTERSUB_NOPAREN NO() ), # bare sub call (without parens) 582); 583 584 585 586#foo() called before sub foo was parsed */ 587addbits('gv', 5 => qw(OPpEARLY_CV EARLYCV)); 588 589 590 591# 1st arg is replacement string */ 592addbits('substr', 4 => qw(OPpSUBSTR_REPL_FIRST REPL1ST)); 593 594 595 596addbits('padrange', 597 # bits 0..6 hold target range 598 '0..6' => { 599 label => 'range', 600 mask_def => 'OPpPADRANGE_COUNTMASK', 601 bitcount_def => 'OPpPADRANGE_COUNTSHIFT', 602 } 603 # 7 => OPpLVAL_INTRO, already defined above 604); 605 606 607 608for (qw(aelemfast aelemfast_lex)) { 609 addbits($_, 610 '0..7' => { 611 label => 'key', 612 } 613 ); 614} 615 616 617 618addbits('rv2gv', 619 2 => qw(OPpDONT_INIT_GV NOINIT), # Call gv_fetchpv with GV_NOINIT 620 # (Therefore will return whatever is currently in 621 # the symbol table, not guaranteed to be a PVGV) 622 6 => qw(OPpALLOW_FAKE FAKE), # OK to return fake glob 623); 624 625 626# NB OPpITER_REVERSED must always be bit 1: see pp_iter() 627 628addbits('enteriter', 629 1 => qw(OPpITER_REVERSED REVERSED),# for (reverse ...) 630 3 => qw(OPpITER_DEF DEF), # 'for $_' 631); 632addbits('iter', 1 => qw(OPpITER_REVERSED REVERSED)); 633 634 635 636addbits('const', 637 1 => qw(OPpCONST_NOVER NOVER), # no 6; 638 2 => qw(OPpCONST_SHORTCIRCUIT SHORT), # e.g. the constant 5 in (5 || foo) 639 3 => qw(OPpCONST_STRICT STRICT), # bareword subject to strict 'subs' 640 4 => qw(OPpCONST_ENTERED ENTERED), # Has been entered as symbol 641 6 => qw(OPpCONST_BARE BARE), # Was a bare word (filehandle?) 642); 643 644 645 646# Range arg potentially a line num. */ 647addbits($_, 6 => qw(OPpFLIP_LINENUM LINENUM)) for qw(flip flop); 648 649 650 651# Guessed that pushmark was needed. */ 652addbits('list', 6 => qw(OPpLIST_GUESSED GUESSED)); 653 654 655 656addbits('delete', 657 5 => qw(OPpKVSLICE KVSLICE), # Operating on a list of key/value pairs 658 6 => qw(OPpSLICE SLICE ), # Operating on a list of keys 659 #7 => OPpLVAL_INTRO, already defined above 660); 661 662 663 664# Checking for &sub, not {} or []. 665addbits('exists', 6 => qw(OPpEXISTS_SUB SUB)); 666 667 668 669addbits('sort', 670 0 => qw(OPpSORT_NUMERIC NUM ), # Optimized away { $a <=> $b } 671 1 => qw(OPpSORT_INTEGER INT ), # Ditto while under "use integer" 672 2 => qw(OPpSORT_REVERSE REV ), # Reversed sort 673 3 => qw(OPpSORT_INPLACE INPLACE), # sort in-place; eg @a = sort @a 674 4 => qw(OPpSORT_DESCEND DESC ), # Descending sort 675 6 => qw(OPpSORT_STABLE STABLE ), # Use a stable algorithm 676 7 => qw(OPpSORT_UNSTABLE UNSTABLE),# Use an unstable algorithm 677); 678 679 680 681# reverse in-place (@a = reverse @a) */ 682addbits('reverse', 3 => qw(OPpREVERSE_INPLACE INPLACE)); 683 684 685 686for (qw(open backtick)) { 687 addbits($_, 688 4 => qw(OPpOPEN_IN_RAW INBIN ), # binmode(F,":raw") on input fh 689 5 => qw(OPpOPEN_IN_CRLF INCR ), # binmode(F,":crlf") on input fh 690 6 => qw(OPpOPEN_OUT_RAW OUTBIN), # binmode(F,":raw") on output fh 691 7 => qw(OPpOPEN_OUT_CRLF OUTCR ), # binmode(F,":crlf") on output fh 692 ); 693} 694 695 696 697# The various OPpFT* filetest ops 698 699# "use filetest 'access'" is in scope: 700# this flag is set only on a subset of the FT* ops 701addbits($_, 1 => qw(OPpFT_ACCESS FTACCESS)) for ops_with_arg(0, 'F-+'); 702 703# all OPpFT* ops except stat and lstat 704for (grep { $_ !~ /^l?stat$/ } ops_with_flag('-')) { 705 addbits($_, 706 2 => qw(OPpFT_STACKED FTSTACKED ), # stacked filetest, 707 # e.g. "-f" in "-f -x $foo" 708 3 => qw(OPpFT_STACKING FTSTACKING), # stacking filetest. 709 # e.g. "-x" in "-f -x $foo" 710 4 => qw(OPpFT_AFTER_t FTAFTERt ), # previous op was -t 711 ); 712} 713 714 715 716addbits('entereval', 717 1 => qw(OPpEVAL_HAS_HH HAS_HH ), # Does it have a copy of %^H ? 718 2 => qw(OPpEVAL_UNICODE UNI ), 719 3 => qw(OPpEVAL_BYTES BYTES ), 720 4 => qw(OPpEVAL_COPHH COPHH ), # Construct %^H from COP hints 721 5 => qw(OPpEVAL_RE_REPARSING REPARSE), # eval_sv(..., G_RE_REPARSING) 722); 723 724 725 726# These must not conflict with OPpDONT_INIT_GV or OPpALLOW_FAKE. 727# See pp.c:S_rv2gv. */ 728addbits('coreargs', 729 0 => qw(OPpCOREARGS_DEREF1 DEREF1), # Arg 1 is a handle constructor 730 1 => qw(OPpCOREARGS_DEREF2 DEREF2), # Arg 2 is a handle constructor 731 #2 reserved for OPpDONT_INIT_GV in rv2gv 732 #4 reserved for OPpALLOW_FAKE in rv2gv 733 6 => qw(OPpCOREARGS_SCALARMOD $MOD ), # \$ rather than \[$@%*] 734 7 => qw(OPpCOREARGS_PUSHMARK MARK ), # Call pp_pushmark 735); 736 737 738 739addbits('split', 740 # @a = split() has been replaced with split() where split itself 741 # does the array assign 742 4 => qw(OPpSPLIT_ASSIGN ASSIGN), 743 3 => qw(OPpSPLIT_LEX LEX), # the OPpSPLIT_ASSIGN is a lexical array 744 2 => qw(OPpSPLIT_IMPLIM IMPLIM), # implicit limit 745); 746 747 748addbits($_, 749 2 => qw(OPpLVREF_ELEM ELEM ), 750 3 => qw(OPpLVREF_ITER ITER ), 751'4..5'=> { 752 mask_def => 'OPpLVREF_TYPE', 753 enum => [ qw( 754 0 OPpLVREF_SV SV 755 1 OPpLVREF_AV AV 756 2 OPpLVREF_HV HV 757 3 OPpLVREF_CV CV 758 )], 759 }, 760 #6 => qw(OPpPAD_STATE STATE), 761 #7 => qw(OPpLVAL_INTRO LVINTRO), 762) for 'refassign', 'lvref'; 763 764 765 766addbits('multideref', 767 4 => qw(OPpMULTIDEREF_EXISTS EXISTS), # deref is actually exists 768 5 => qw(OPpMULTIDEREF_DELETE DELETE), # deref is actually delete 769); 770 771 772 773addbits('avhvswitch', 774 '0..1' => { 775 mask_def => 'OPpAVHVSWITCH_MASK', 776 label => 'offset', 777 } 778); 779 780 781addbits('argelem', 782 '1..2' => { 783 mask_def => 'OPpARGELEM_MASK', 784 enum => [ qw( 785 0 OPpARGELEM_SV SV 786 1 OPpARGELEM_AV AV 787 2 OPpARGELEM_HV HV 788 )], 789 }, 790); 791 792 793# rv2hv and padhv in void/scalar context implementing 'keys %h' 794# directly, without a following OP_KEYS 795 796addbits('padhv', 797 0 => qw(OPpPADHV_ISKEYS KEYS), 798); 799addbits('rv2hv', 800 0 => qw(OPpRV2HV_ISKEYS KEYS), 801); 802 803# In conjunction with OPpTRUEBOOL, indicates that the test should be 804# inverted. This allows both (index() == -1) and (index() != -1) 805# to optimise away the const and eq/ne 806 807for (qw(index rindex)) { 808 addbits($_, 6 => qw(OPpINDEX_BOOLNEG NEG)); 809} 810 811 812addbits('concat', 813 # OPf_STACKED normally indicates .=; but it also gets set to optimise 814 # $a . $b . $c into ($a . $b) .= $c 815 # so that the first concat's PADTMP (which holds the result of $a.$b) 816 # can be reused. Set a flag in this case to help deparse and warn 817 # distinguish the cases. 818 6 => qw(OPpCONCAT_NESTED NESTED), 819); 820 821 822addbits('multiconcat', 823 # 7 OPpLVAL_INTRO 824 6 => qw(OPpMULTICONCAT_APPEND APPEND), # $x .= .... 825 5 => qw(OPpMULTICONCAT_FAKE FAKE), # sprintf() optimised to MC. 826 # 4 OPpTARGET_MY 827 3 => qw(OPpMULTICONCAT_STRINGIFY STRINGIFY), # "$a$b..." 828); 829 830 831 8321; 833 834# ex: set ts=8 sts=4 sw=4 et: 835