| 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 of regen/opcodes has flag or type 'X' set; |
| 92 | argument field N of 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); # 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 | |
| 289 | for (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 | |
| 300 | addbits($_, 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 | 'list', # this gets set in my_attrs() for some reason |
| 305 | ; |
| 306 | |
| 307 | |
| 308 | |
| 309 | # TARGLEX |
| 310 | # |
| 311 | # in constructs like my $x; ...; $x = $a + $b, |
| 312 | # the sassign is optimised away and OPpTARGET_MY is set on the add op |
| 313 | # |
| 314 | # Note that OPpTARGET_MY is mainly used at compile-time. At run time, |
| 315 | # the pp function just updates the SV pointed to by op_targ, and doesn't |
| 316 | # care whether that's a PADTMP or a lexical var. |
| 317 | |
| 318 | # Some comments about when its safe to use T/OPpTARGET_MY. |
| 319 | # |
| 320 | # Safe to set if the ppcode uses: |
| 321 | # tryAMAGICbin, tryAMAGICun, SETn, SETi, SETu, PUSHn, PUSHTARG, SETTARG, |
| 322 | # SETs(TARG), XPUSHn, XPUSHu, |
| 323 | # but make sure set-magic is invoked separately for SETs(TARG) (or change |
| 324 | # it to SETTARG). |
| 325 | # |
| 326 | # Unsafe to set if the ppcode uses dTARG or [X]RETPUSH[YES|NO|UNDEF] |
| 327 | # |
| 328 | # Only the code paths that handle scalar rvalue context matter. If dTARG |
| 329 | # or RETPUSHNO occurs only in list or lvalue paths, T is safe. |
| 330 | # |
| 331 | # lt and friends do SETs (including ncmp, but not scmp or i_ncmp) |
| 332 | # |
| 333 | # Additional mode of failure: the opcode can modify TARG before it "used" |
| 334 | # all the arguments (or may call an external function which does the same). |
| 335 | # If the target coincides with one of the arguments ==> kaboom. |
| 336 | # |
| 337 | # pp.c pos substr each not OK (RETPUSHUNDEF) |
| 338 | # ref not OK (RETPUSHNO) |
| 339 | # trans not OK (target is used for lhs, not retval) |
| 340 | # ucfirst etc not OK: TMP arg processed inplace |
| 341 | # quotemeta not OK (unsafe when TARG == arg) |
| 342 | # pack - unknown whether it is safe |
| 343 | # sprintf: is calling do_sprintf(TARG,...) which can act on TARG |
| 344 | # before other args are processed. |
| 345 | # |
| 346 | # Suspicious wrt "additional mode of failure" (and only it): |
| 347 | # schop, chop, postinc/dec, bit_and etc, negate, complement. |
| 348 | # |
| 349 | # Also suspicious: 4-arg substr, sprintf, uc/lc (POK_only), reverse, pack. |
| 350 | # |
| 351 | # substr/vec: doing TAINT_off()??? |
| 352 | # |
| 353 | # pp_hot.c |
| 354 | # readline - unknown whether it is safe |
| 355 | # match subst not OK (dTARG) |
| 356 | # grepwhile not OK (not always setting) |
| 357 | # join not OK (unsafe when TARG == arg) |
| 358 | # |
| 359 | # concat - pp_concat special-cases TARG==arg to avoid |
| 360 | # "additional mode of failure" |
| 361 | # |
| 362 | # pp_ctl.c |
| 363 | # mapwhile flip caller not OK (not always setting) |
| 364 | # |
| 365 | # pp_sys.c |
| 366 | # backtick glob warn die not OK (not always setting) |
| 367 | # warn not OK (RETPUSHYES) |
| 368 | # open fileno getc sysread syswrite ioctl accept shutdown |
| 369 | # ftsize(etc) readlink telldir fork alarm getlogin not OK (RETPUSHUNDEF) |
| 370 | # umask select not OK (XPUSHs(&PL_sv_undef);) |
| 371 | # fileno getc sysread syswrite tell not OK (meth("FILENO" "GETC")) |
| 372 | # sselect shm* sem* msg* syscall - unknown whether they are safe |
| 373 | # gmtime not OK (list context) |
| 374 | # |
| 375 | # Suspicious wrt "additional mode of failure": warn, die, select. |
| 376 | |
| 377 | |
| 378 | addbits($_, 4 => qw(OPpTARGET_MY TARGMY)) |
| 379 | for ops_with_flag('T'), |
| 380 | ; |
| 381 | |
| 382 | |
| 383 | |
| 384 | |
| 385 | |
| 386 | # op_targ carries a refcount |
| 387 | addbits($_, 6 => qw(OPpREFCOUNTED REFC)) |
| 388 | for qw(leave leavesub leavesublv leavewrite leaveeval); |
| 389 | |
| 390 | |
| 391 | |
| 392 | # Do not copy return value |
| 393 | addbits($_, 7 => qw(OPpLVALUE LV)) for qw(leave leaveloop); |
| 394 | |
| 395 | |
| 396 | |
| 397 | # autovivify: Want ref to something |
| 398 | for (qw(rv2gv rv2sv padsv aelem helem entersub)) { |
| 399 | addbits($_, '4..5' => { |
| 400 | mask_def => 'OPpDEREF', |
| 401 | enum => [ qw( |
| 402 | 1 OPpDEREF_AV DREFAV |
| 403 | 2 OPpDEREF_HV DREFHV |
| 404 | 3 OPpDEREF_SV DREFSV |
| 405 | )], |
| 406 | } |
| 407 | ); |
| 408 | } |
| 409 | |
| 410 | |
| 411 | |
| 412 | # Defer creation of array/hash elem |
| 413 | addbits($_, 6 => qw(OPpLVAL_DEFER LVDEFER)) for qw(aelem helem multideref); |
| 414 | |
| 415 | |
| 416 | |
| 417 | addbits($_, 2 => qw(OPpSLICEWARNING SLICEWARN)) # warn about @hash{$scalar} |
| 418 | for qw(rv2hv rv2av padav padhv hslice aslice); |
| 419 | |
| 420 | |
| 421 | |
| 422 | # XXX Concise seemed to think that OPpOUR_INTRO is used in rv2gv too, |
| 423 | # but I can't see it - DAPM |
| 424 | addbits($_, 6 => qw(OPpOUR_INTRO OURINTR)) # Variable was in an our() |
| 425 | for qw(gvsv rv2sv rv2av rv2hv enteriter split); |
| 426 | |
| 427 | |
| 428 | |
| 429 | # We might be an lvalue to return |
| 430 | # 'values' doesn't actually use this bit, but we reserve it here as |
| 431 | # pp_values may call Perl_do_kv() which is shared among several ops which |
| 432 | # do. |
| 433 | |
| 434 | addbits($_, 3 => qw(OPpMAYBE_LVSUB LVSUB)) |
| 435 | for qw(aassign rv2av rv2gv rv2hv padav padhv aelem helem aslice hslice |
| 436 | av2arylen keys akeys avhvswitch kvaslice kvhslice substr pos vec |
| 437 | multideref values); |
| 438 | |
| 439 | |
| 440 | |
| 441 | for (qw(rv2hv padhv ref)) { |
| 442 | addbits($_, # e.g. %hash in (%hash || $foo) ... |
| 443 | 4 => qw(OPpMAYBE_TRUEBOOL BOOL?), # but cx not known till run time |
| 444 | 5 => qw(OPpTRUEBOOL BOOL), |
| 445 | ); |
| 446 | } |
| 447 | for (qw(grepwhile index length padav pos rindex rv2av subst)) { |
| 448 | addbits($_, |
| 449 | 5 => qw(OPpTRUEBOOL BOOL), # if (@a) {...} |
| 450 | ); |
| 451 | } |
| 452 | |
| 453 | |
| 454 | addbits($_, 1 => qw(OPpHINT_STRICT_REFS STRICT)) |
| 455 | for qw(rv2sv rv2av rv2hv rv2gv multideref); |
| 456 | |
| 457 | |
| 458 | |
| 459 | # Treat caller(1) as caller(2) |
| 460 | addbits($_, 7 => qw(OPpOFFBYONE +1)) for qw(caller wantarray runcv); |
| 461 | |
| 462 | |
| 463 | |
| 464 | # label is in UTF8 */ |
| 465 | addbits($_, 7 => qw(OPpPV_IS_UTF8 UTF)) for qw(last redo next goto dump); |
| 466 | |
| 467 | |
| 468 | |
| 469 | # ==================================================================== |
| 470 | # |
| 471 | # OP-SPECIFIC OPpFOO_* flags: |
| 472 | # |
| 473 | # where FOO is typically the name of an op, and the flag is used by a |
| 474 | # single op (or maybe by a few closely related ops). |
| 475 | |
| 476 | |
| 477 | |
| 478 | # note that for refassign, this bit can mean either OPpPAD_STATE or |
| 479 | # OPpOUR_INTRO depending on the type of the LH child, .e.g. |
| 480 | # \our $foo = ... |
| 481 | # \state $foo = ... |
| 482 | |
| 483 | addbits($_, 6 => qw(OPpPAD_STATE STATE)) for qw(padav padhv padsv lvavref |
| 484 | lvref refassign pushmark); |
| 485 | |
| 486 | # NB: both sassign and aassign use the 'OPpASSIGN' naming convention |
| 487 | # for their private flags |
| 488 | |
| 489 | # there *may* be common scalar items on both sides of a list assign: |
| 490 | # run-time checking will be needed. |
| 491 | addbits('aassign', 6 => qw(OPpASSIGN_COMMON_SCALAR COM_SCALAR)); |
| 492 | # |
| 493 | # as above, but it's possible to check for non-commonality with just |
| 494 | # a SvREFCNT(lhs) == 1 test for each lhs element |
| 495 | addbits('aassign', 5 => qw(OPpASSIGN_COMMON_RC1 COM_RC1)); |
| 496 | |
| 497 | # run-time checking is required for an aggregate on the LHS |
| 498 | addbits('aassign', 4 => qw(OPpASSIGN_COMMON_AGG COM_AGG)); |
| 499 | |
| 500 | addbits('aassign', 2 => qw(OPpASSIGN_TRUEBOOL BOOL)); # if (@a = (...)) {...} |
| 501 | |
| 502 | |
| 503 | # NB: both sassign and aassign use the 'OPpASSIGN' naming convention |
| 504 | # for their private flags |
| 505 | |
| 506 | addbits('sassign', |
| 507 | 6 => qw(OPpASSIGN_BACKWARDS BKWARD), # Left & right switched |
| 508 | 7 => qw(OPpASSIGN_CV_TO_GV CV2GV), # Possible optimisation for constants |
| 509 | ); |
| 510 | |
| 511 | |
| 512 | |
| 513 | for (qw(trans transr)) { |
| 514 | addbits($_, |
| 515 | 0 => qw(OPpTRANS_FROM_UTF <UTF), |
| 516 | 1 => qw(OPpTRANS_TO_UTF >UTF), |
| 517 | 2 => qw(OPpTRANS_IDENTICAL IDENT), # right side is same as left |
| 518 | 3 => qw(OPpTRANS_SQUASH SQUASH), |
| 519 | # 4 is used for OPpTARGET_MY |
| 520 | 5 => qw(OPpTRANS_COMPLEMENT COMPL), |
| 521 | 6 => qw(OPpTRANS_GROWS GROWS), |
| 522 | 7 => qw(OPpTRANS_DELETE DEL), |
| 523 | ); |
| 524 | } |
| 525 | |
| 526 | |
| 527 | |
| 528 | addbits('repeat', 6 => qw(OPpREPEAT_DOLIST DOLIST)); # List replication |
| 529 | |
| 530 | |
| 531 | |
| 532 | # OP_ENTERSUB and OP_RV2CV flags |
| 533 | # |
| 534 | # Flags are set on entersub and rv2cv in three phases: |
| 535 | # parser - the parser passes the flag to the op constructor |
| 536 | # check - the check routine called by the op constructor sets the flag |
| 537 | # context - application of scalar/ref/lvalue context applies the flag |
| 538 | # |
| 539 | # In the third stage, an entersub op might turn into an rv2cv op (undef &foo, |
| 540 | # \&foo, lock &foo, exists &foo, defined &foo). The two places where that |
| 541 | # happens (op_lvalue_flags and doref in op.c) need to make sure the flags do |
| 542 | # not conflict, since some flags with different meanings overlap between |
| 543 | # the two ops. Flags applied in the context phase are only set when there |
| 544 | # is no conversion of op type. |
| 545 | # |
| 546 | # bit entersub flag phase rv2cv flag phase |
| 547 | # --- ------------- ----- ---------- ----- |
| 548 | # 0 OPpENTERSUB_INARGS context |
| 549 | # 1 HINT_STRICT_REFS check HINT_STRICT_REFS check |
| 550 | # 2 OPpENTERSUB_HASTARG checki OPpENTERSUB_HASTARG |
| 551 | # 3 OPpENTERSUB_AMPER check OPpENTERSUB_AMPER parser |
| 552 | # 4 OPpDEREF_AV context |
| 553 | # 5 OPpDEREF_HV context OPpMAY_RETURN_CONSTANT parser/context |
| 554 | # 6 OPpENTERSUB_DB check OPpENTERSUB_DB |
| 555 | # 7 OPpLVAL_INTRO context OPpENTERSUB_NOPAREN parser |
| 556 | |
| 557 | # NB: OPpHINT_STRICT_REFS must equal HINT_STRICT_REFS |
| 558 | |
| 559 | addbits('entersub', |
| 560 | 0 => qw(OPpENTERSUB_INARGS INARGS), # Lval used as arg to a sub |
| 561 | 1 => qw(OPpHINT_STRICT_REFS STRICT), # 'use strict' in scope |
| 562 | 2 => qw(OPpENTERSUB_HASTARG TARG ), # Called from OP tree |
| 563 | 3 => qw(OPpENTERSUB_AMPER AMPER), # Used & form to call |
| 564 | # 4..5 => OPpDEREF, already defined above |
| 565 | 6 => qw(OPpENTERSUB_DB DBG ), # Debug subroutine |
| 566 | # 7 => OPpLVAL_INTRO, already defined above |
| 567 | ); |
| 568 | |
| 569 | # note that some of these flags are just left-over from when an entersub |
| 570 | # is converted into an rv2cv, and could probably be cleared/re-assigned |
| 571 | |
| 572 | addbits('rv2cv', |
| 573 | 1 => qw(OPpHINT_STRICT_REFS STRICT), # 'use strict' in scope |
| 574 | 2 => qw(OPpENTERSUB_HASTARG TARG ), # If const sub, return the const |
| 575 | 3 => qw(OPpENTERSUB_AMPER AMPER ), # Used & form to call |
| 576 | |
| 577 | 5 => qw(OPpMAY_RETURN_CONSTANT CONST ), |
| 578 | 6 => qw(OPpENTERSUB_DB DBG ), # Debug subroutine |
| 579 | 7 => qw(OPpENTERSUB_NOPAREN NO() ), # bare sub call (without parens) |
| 580 | ); |
| 581 | |
| 582 | |
| 583 | |
| 584 | #foo() called before sub foo was parsed */ |
| 585 | addbits('gv', 5 => qw(OPpEARLY_CV EARLYCV)); |
| 586 | |
| 587 | |
| 588 | |
| 589 | # 1st arg is replacement string */ |
| 590 | addbits('substr', 4 => qw(OPpSUBSTR_REPL_FIRST REPL1ST)); |
| 591 | |
| 592 | |
| 593 | |
| 594 | addbits('padrange', |
| 595 | # bits 0..6 hold target range |
| 596 | '0..6' => { |
| 597 | label => 'range', |
| 598 | mask_def => 'OPpPADRANGE_COUNTMASK', |
| 599 | bitcount_def => 'OPpPADRANGE_COUNTSHIFT', |
| 600 | } |
| 601 | # 7 => OPpLVAL_INTRO, already defined above |
| 602 | ); |
| 603 | |
| 604 | |
| 605 | |
| 606 | for (qw(aelemfast aelemfast_lex)) { |
| 607 | addbits($_, |
| 608 | '0..7' => { |
| 609 | label => 'key', |
| 610 | } |
| 611 | ); |
| 612 | } |
| 613 | |
| 614 | |
| 615 | |
| 616 | addbits('rv2gv', |
| 617 | 2 => qw(OPpDONT_INIT_GV NOINIT), # Call gv_fetchpv with GV_NOINIT |
| 618 | # (Therefore will return whatever is currently in |
| 619 | # the symbol table, not guaranteed to be a PVGV) |
| 620 | 6 => qw(OPpALLOW_FAKE FAKE), # OK to return fake glob |
| 621 | ); |
| 622 | |
| 623 | |
| 624 | # NB OPpITER_REVERSED must always be bit 1: see pp_iter() |
| 625 | |
| 626 | addbits('enteriter', |
| 627 | 1 => qw(OPpITER_REVERSED REVERSED),# for (reverse ...) |
| 628 | 3 => qw(OPpITER_DEF DEF), # 'for $_' |
| 629 | ); |
| 630 | addbits('iter', 1 => qw(OPpITER_REVERSED REVERSED)); |
| 631 | |
| 632 | |
| 633 | |
| 634 | addbits('const', |
| 635 | 1 => qw(OPpCONST_NOVER NOVER), # no 6; |
| 636 | 2 => qw(OPpCONST_SHORTCIRCUIT SHORT), # e.g. the constant 5 in (5 || foo) |
| 637 | 3 => qw(OPpCONST_STRICT STRICT), # bareword subject to strict 'subs' |
| 638 | 4 => qw(OPpCONST_ENTERED ENTERED), # Has been entered as symbol |
| 639 | 6 => qw(OPpCONST_BARE BARE), # Was a bare word (filehandle?) |
| 640 | ); |
| 641 | |
| 642 | |
| 643 | |
| 644 | # Range arg potentially a line num. */ |
| 645 | addbits($_, 6 => qw(OPpFLIP_LINENUM LINENUM)) for qw(flip flop); |
| 646 | |
| 647 | |
| 648 | |
| 649 | # Guessed that pushmark was needed. */ |
| 650 | addbits('list', 6 => qw(OPpLIST_GUESSED GUESSED)); |
| 651 | |
| 652 | |
| 653 | |
| 654 | addbits('delete', |
| 655 | 5 => qw(OPpKVSLICE KVSLICE), # Operating on a list of key/value pairs |
| 656 | 6 => qw(OPpSLICE SLICE ), # Operating on a list of keys |
| 657 | #7 => OPpLVAL_INTRO, already defined above |
| 658 | ); |
| 659 | |
| 660 | |
| 661 | |
| 662 | # Checking for &sub, not {} or []. |
| 663 | addbits('exists', 6 => qw(OPpEXISTS_SUB SUB)); |
| 664 | |
| 665 | |
| 666 | |
| 667 | addbits('sort', |
| 668 | 0 => qw(OPpSORT_NUMERIC NUM ), # Optimized away { $a <=> $b } |
| 669 | 1 => qw(OPpSORT_INTEGER INT ), # Ditto while under "use integer" |
| 670 | 2 => qw(OPpSORT_REVERSE REV ), # Reversed sort |
| 671 | 3 => qw(OPpSORT_INPLACE INPLACE), # sort in-place; eg @a = sort @a |
| 672 | 4 => qw(OPpSORT_DESCEND DESC ), # Descending sort |
| 673 | 5 => qw(OPpSORT_QSORT QSORT ), # Use quicksort (not mergesort) |
| 674 | 6 => qw(OPpSORT_STABLE STABLE ), # Use a stable algorithm |
| 675 | 7 => qw(OPpSORT_UNSTABLE UNSTABLE),# Use an unstable algorithm |
| 676 | ); |
| 677 | |
| 678 | |
| 679 | |
| 680 | # reverse in-place (@a = reverse @a) */ |
| 681 | addbits('reverse', 3 => qw(OPpREVERSE_INPLACE INPLACE)); |
| 682 | |
| 683 | |
| 684 | |
| 685 | for (qw(open backtick)) { |
| 686 | addbits($_, |
| 687 | 4 => qw(OPpOPEN_IN_RAW INBIN ), # binmode(F,":raw") on input fh |
| 688 | 5 => qw(OPpOPEN_IN_CRLF INCR ), # binmode(F,":crlf") on input fh |
| 689 | 6 => qw(OPpOPEN_OUT_RAW OUTBIN), # binmode(F,":raw") on output fh |
| 690 | 7 => qw(OPpOPEN_OUT_CRLF OUTCR ), # binmode(F,":crlf") on output fh |
| 691 | ); |
| 692 | } |
| 693 | |
| 694 | |
| 695 | |
| 696 | # The various OPpFT* filetest ops |
| 697 | |
| 698 | # "use filetest 'access'" is in scope: |
| 699 | # this flag is set only on a subset of the FT* ops |
| 700 | addbits($_, 1 => qw(OPpFT_ACCESS FTACCESS)) for ops_with_arg(0, 'F-+'); |
| 701 | |
| 702 | # all OPpFT* ops except stat and lstat |
| 703 | for (grep { $_ !~ /^l?stat$/ } ops_with_flag('-')) { |
| 704 | addbits($_, |
| 705 | 2 => qw(OPpFT_STACKED FTSTACKED ), # stacked filetest, |
| 706 | # e.g. "-f" in "-f -x $foo" |
| 707 | 3 => qw(OPpFT_STACKING FTSTACKING), # stacking filetest. |
| 708 | # e.g. "-x" in "-f -x $foo" |
| 709 | 4 => qw(OPpFT_AFTER_t FTAFTERt ), # previous op was -t |
| 710 | ); |
| 711 | } |
| 712 | |
| 713 | |
| 714 | |
| 715 | addbits('entereval', |
| 716 | 1 => qw(OPpEVAL_HAS_HH HAS_HH ), # Does it have a copy of %^H ? |
| 717 | 2 => qw(OPpEVAL_UNICODE UNI ), |
| 718 | 3 => qw(OPpEVAL_BYTES BYTES ), |
| 719 | 4 => qw(OPpEVAL_COPHH COPHH ), # Construct %^H from COP hints |
| 720 | 5 => qw(OPpEVAL_RE_REPARSING REPARSE), # eval_sv(..., G_RE_REPARSING) |
| 721 | ); |
| 722 | |
| 723 | |
| 724 | |
| 725 | # These must not conflict with OPpDONT_INIT_GV or OPpALLOW_FAKE. |
| 726 | # See pp.c:S_rv2gv. */ |
| 727 | addbits('coreargs', |
| 728 | 0 => qw(OPpCOREARGS_DEREF1 DEREF1), # Arg 1 is a handle constructor |
| 729 | 1 => qw(OPpCOREARGS_DEREF2 DEREF2), # Arg 2 is a handle constructor |
| 730 | #2 reserved for OPpDONT_INIT_GV in rv2gv |
| 731 | #4 reserved for OPpALLOW_FAKE in rv2gv |
| 732 | 6 => qw(OPpCOREARGS_SCALARMOD $MOD ), # \$ rather than \[$@%*] |
| 733 | 7 => qw(OPpCOREARGS_PUSHMARK MARK ), # Call pp_pushmark |
| 734 | ); |
| 735 | |
| 736 | |
| 737 | |
| 738 | addbits('split', |
| 739 | # @a = split() has been replaced with split() where split itself |
| 740 | # does the array assign |
| 741 | 4 => qw(OPpSPLIT_ASSIGN ASSIGN), |
| 742 | 3 => qw(OPpSPLIT_LEX LEX), # the OPpSPLIT_ASSIGN is a lexical array |
| 743 | 2 => qw(OPpSPLIT_IMPLIM IMPLIM), # implicit limit |
| 744 | ); |
| 745 | |
| 746 | |
| 747 | addbits($_, |
| 748 | 2 => qw(OPpLVREF_ELEM ELEM ), |
| 749 | 3 => qw(OPpLVREF_ITER ITER ), |
| 750 | '4..5'=> { |
| 751 | mask_def => 'OPpLVREF_TYPE', |
| 752 | enum => [ qw( |
| 753 | 0 OPpLVREF_SV SV |
| 754 | 1 OPpLVREF_AV AV |
| 755 | 2 OPpLVREF_HV HV |
| 756 | 3 OPpLVREF_CV CV |
| 757 | )], |
| 758 | }, |
| 759 | #6 => qw(OPpPAD_STATE STATE), |
| 760 | #7 => qw(OPpLVAL_INTRO LVINTRO), |
| 761 | ) for 'refassign', 'lvref'; |
| 762 | |
| 763 | |
| 764 | |
| 765 | addbits('multideref', |
| 766 | 4 => qw(OPpMULTIDEREF_EXISTS EXISTS), # deref is actually exists |
| 767 | 5 => qw(OPpMULTIDEREF_DELETE DELETE), # deref is actually delete |
| 768 | ); |
| 769 | |
| 770 | |
| 771 | |
| 772 | addbits('avhvswitch', |
| 773 | '0..1' => { |
| 774 | mask_def => 'OPpAVHVSWITCH_MASK', |
| 775 | label => 'offset', |
| 776 | } |
| 777 | ); |
| 778 | |
| 779 | |
| 780 | addbits('argelem', |
| 781 | '1..2' => { |
| 782 | mask_def => 'OPpARGELEM_MASK', |
| 783 | enum => [ qw( |
| 784 | 0 OPpARGELEM_SV SV |
| 785 | 1 OPpARGELEM_AV AV |
| 786 | 2 OPpARGELEM_HV HV |
| 787 | )], |
| 788 | }, |
| 789 | ); |
| 790 | |
| 791 | |
| 792 | # rv2hv and padhv in void/scalar context implementing 'keys %h' |
| 793 | # directly, without a following OP_KEYS |
| 794 | |
| 795 | addbits('padhv', |
| 796 | 0 => qw(OPpPADHV_ISKEYS KEYS), |
| 797 | ); |
| 798 | addbits('rv2hv', |
| 799 | 0 => qw(OPpRV2HV_ISKEYS KEYS), |
| 800 | ); |
| 801 | |
| 802 | # In conjunction with OPpTRUEBOOL, indicates that the test should be |
| 803 | # inverted. This allows both (index() == -1) and (index() != -1) |
| 804 | # to optimise away the const and eq/ne |
| 805 | |
| 806 | for (qw(index rindex)) { |
| 807 | addbits($_, 6 => qw(OPpINDEX_BOOLNEG NEG)); |
| 808 | } |
| 809 | |
| 810 | |
| 811 | |
| 812 | 1; |
| 813 | |
| 814 | # ex: set ts=8 sts=4 sw=4 et: |