regen/op_private

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