leakfinder.pl: Yet mair exceptions

regcomp.c: Typo

remove various redundant dTHXes

Remove either unused dTHXes, or remove dTHXes where a nocontext func can
be used instead. Smaller/faster machine code is the result.

remove unused dTHXes in /win32/*

Remove dTHXes in win32 perl funcs where they were not used, or could be
replaced with nocontext croaks/warns. Since Perl_get_context is a function
it is not optimized away by the compiler.

create aTHXa, some unused dTHXs removed in /win32/*

dTHXes that were unused, or because Newx/Safefree were the only things
called were removed. In some places the dTHX turned into dTHXa and aTHXa
so the context is  not fetched until it is actually used
(locality/frees a C stack slot or frees a non-volatile register). Also see
http://www.nntp.perl.org/group/perl.perl5.porters/2012/10/msg194414.html
and http://www.nntp.perl.org/group/perl.perl5.porters/2012/10/msg194861.html

"func not implemented" croaks optimizations in /win32/*

This commit removes a number of "* not implemented" strings from the image.
A win32_croak_not_implemented wrapper is created to reduce machine code
by not putting the format string on the C stack many times. embed.fnc was
used to declare win32_croak_not_implemented for proper cross compiler
support of noreturn (noreturn on GCC and VC ok). Tailcalling and noreturn
optimizations of the C compiler are heavily used in this commit.

perlpolicy: remove 5.12 references from maint cherry pick policy

Sync version of autodie in Maintainers.pl with CPAN

fix a hash key order dependency in cpan/autodie/t/hints_pod_examples.t

At the same time make part of the internals deterministic Just In Case.

Version bump on autodie to 2.13 as well.

limit number of args before formatting

this makes a difference when the number of args is quite large

fix Carp stacktraces after deleting a stash

When a stash is deleted, caller() will return undef in the package slot
for any stack level for which the deleted stash was the current package.
This made Carp confused in some cases, so fix that.

Remove x bit from MANIFEST

Upgrade to Thread::Queue 3.01

svleak.t: Fix a mad failure

Stop eval "qq'\$\0foo'" from leaking

If the dollar sign in a double-quoted string is followed by a null,
then scan_ident gets confused, as it uses the nullness to keep track
of whether it has found an identifier.  In this case it treats $\0 as
a punctuation variable but then loses track of that fact and thinks it
has found the end of the string.

It’s complicated, but the end result is that the sequence of tokens
emitted for eval "qq'$\0foo'" would be the following:

    stringify ( $ . "foo" )

instead of this:

    stringify ( $ <ident> . "foo" )

But the missing identifier after the dollar sign results in a syn-
tax error that prevents yylex from having a chance to emit the
"foo", which by that time it has put on the forced token stack.

There are cases in which the CV that owns the ops on the forced token
stack can be freed while the ops are still on that stack and will
still be fed to the parser, so we treat the forced token stack like
the savestack, and do not allow ops thereon to be freed when their CV
is freed, to avoid feeding freed ops to the parser.

In this case, it means that the ops on the stack are never freed,
resulting in a memory leak.

Whether scan_ident needs to be fixed (or ‘fixed’) I don’t know.  I do
know that when the parser is freed any remaining forced tokens should
also be freed.  Even if this leak could be fixed some other way, it
would still be a good idea for parser_free to check for forced tokens
that need to be cleaned up.

leakfinder.pl: Clean up exceptions

Remove two (exit and END) that were from preliminary versions of
the script.

Skip all lines beginning with push and unshift.

Remove leading whitespace when looking up exceptions.

leakfinder.pl: Another exception

Skip non-functional glob test on VMS.

Sync the version of Module::Pluggable in Maintainers.pl with CPAN

upgrade Module::Pluggable to 4.5 (test changes only)

note there is an untrue comment next to VERSION line in Pluggable.pm, 4.5 is also on CPAN.

Also note this patch keeps the old Makefile.PL based make process intact.

fix NO_TAINT_SUPPORT on g++

A '&' got lost in the conversion

perl.h: s/non-existant/nonexistent/

Lose the loose. Fix documentation typo.

More violent warning about using NO_TAINT_SUPPORT

I failed to update the commit message of the previous commit (sorry!).
The code is in a much better shape than the message claims and Configure
support, for example, won't be added at all to require more
determination from users. PL_taint_warn has since received the same
treatment. To wit:

 #   define TAINT_WARN_get       (PL_taint_warn)
 #   define TAINT_WARN_set(s)    (PL_taint_warn = (s))

Add C define to remove taint support from perl

By defining NO_TAINT_SUPPORT, all the various checks that perl does for
tainting become no-ops. It's not an entirely complete change: it doesn't
attempt to remove the taint-related interpreter variables, but instead
virtually eliminates access to it.

Why, you ask? Because it appears to speed up perl's run-time
significantly by avoiding various "are we running under taint" checks
and the like.

This change is not in a state to go into blead yet. The actual way I
implemented it might raise some (valid) objections. Basically, I
replaced all uses of the global taint variables (but not PL_taint_warn!)
with an extra layer of get/set macros (TAINT_get/TAINTING_get).
Furthermore, the change is not complete:

- PL_taint_warn would likely deserve the same treatment.
- Obviously, tests fail. We have tests for -t/-T
- Right now, I added a Perl warn() on startup when -t/-T are detected
  but the perl was not compiled support it. It might be argued that it
  should be silently ignored! Needs some thinking.
- Code quality concerns - needs review.
- Configure support required.
- Needs thinking: How does this tie in with CPAN XS modules that use
  PL_taint and friends? It's easy to backport the new macros via PPPort,
  but that doesn't magically change all code out there. Might be
  harmless, though, because whenever you're running under
  NO_TAINT_SUPPORT, any check of PL_taint/etc is going to come up false.
  Thus, the only CPAN code that SHOULD be adversely affected is code
  that changes taint state.

Stop the glob operator from leaking GVs

It was adding GVs to the symbol table (via newGVgen), so they
would never be freed, even after the op was freed, unless done so
explicitly.

There is no reason for these GVs to be exposed.

leakfinder.pl: Mair exceptions

leakfinder.pl: Show file names

It can take a *very* long time to run, so give some indication
that it is actually doing something.

op.c:opslab_force_free: Make paranoid code reflect reality

When opslab_force_free is called, the CV still has a reference count
on the slab.  In fact, we don’t even bother lowering it if all goes
well, but simply free the slab with the reference count set to 1.
So the paranoid code that increments the reference count before free-
ing an op is not necessary.  Also, the shortcut out of the loop
was never triggered, as it was checking for a reference count of 0,
rather than 1.

op.c: Stop SAVEFREEOP from leaking slabs

When a CV is freed prematurely, it cleans up its op slab.  But
SAVEFREEOP may cause the savestack to point to an op in that slab
after the CV has been freed, so SAVEFREEOP is allowed to coun-
termand the freeing of the slab.  Every op that is not on the
savestack is freed.

The reference count of the slab was being left off by one.  The result
was that when the stack unwinding freed the op, it would leave the
slab behind and leak it.

Stop %! after syntax error from leaking the module name

gv.c:S_require_tie_mod: remove SPAGAIN

We are not using SP after this point.

Don’t leak BEGIN blocks after syntax errors

leakfinder.pl: Use DD for output

This solves the problem of binary code being dumped into the
terminal.

Don’t leak pattern buffer when invalid flags croak

Normally if there is a syntax error yyerror just records it and pars-
ing continues anyway.  If there are too many syntax errors, it croaks.

It just happened that if it croaked when encountering invalid flags
for quote-like operators it would leak the buffer containing the pat-
tern (and the substitution for s///).

Since those are stored in the parser struct and are set to null when-
ever something else takes ownership of the SV, these struct members
will only ever be non-null in parser_free when they have leaked.  So
we can free them there.  (I.e., these slots have always been refer-
ence-counted, so treat them that way.)

svleak.t: Enable syntax error tests under -Dmad

Also use the fairly new eleak for brevity’s sake (and also because it
knows about the existing mad leak for string evals).

Use shared memory for sv_debug_file

With -DDEBUGGING -Accflags=-DDEBUG_LEAKING_SCALARS -Duseithreads:

use threads;
use threads::shared;
my @shared_ary :shared;
$shared_ary[0] = &threads::shared::share({});
@shared_ary = ();
__END__
panic: free from wrong pool, 881c00!=800000.
Scalars leaked: 1

threads::shared has to juggle multiple interpreters.  Sometimes the
interpreter it is calling into (and passing as the first argument
via pTHX) is not actually the current thread as far as the OS is
concerned.

Perl_safesysfree in util.c does not take a pTHX parameter, so it
fetches the current interpreter from the data associated with the cur-
rent thread.

The result is that PERL_TRACK_MEMPOOL complains that the file name
associated with an SV under DEBUG_LEAKING_SCALARS is being freed from
the wrong interpreter.

Using shared memory for the file name solves the issue.

Stop require nonexistent::module from leaking

This leak was caused by v5.17.4-125-gf7ee53b.

svleak.t: re-evals leak under mad

Fix invalid token warning with PERL_XMLDUMP and label

Under mad builds, commit 5db1eb8 caused this warning:

$ PERL_XMLDUMP=/dev/null ./perl -Ilib -e 'foo:'
Invalid TOKEN object ignored at -e line 1.

Since I don’t understand the mad code so well, the easiest fix is to
revert back to using a PV, as we did before 5db1eb8.  To record the
utf8ness, we sneak it behind the trailing null.

Stop statement labels from leaking

They have leaked since v5.15.9-35-g5db1eb8 (which probably broke mad
dumping of labels; to be addressed in the next commit).

Stop char classes from leaking

Since 5.10.0, this script has leaked:

$ perl -e 'warn$$; while(1){eval "/[:]/"}'

What exactly has leaked has changed over time.  In bleadperl
it is this:

SV = PV(0x8033c8) at 0x836170
  REFCNT = 1
  FLAGS = ()
  PV = 0x31c0b0 "\2\0\0\0\377\377\377\377\0\0\0\0\f\fS\21\1\0\0\0:\0\0\0;\0\0\0"\0
  CUR = 28
  LEN = 32

This only happens when the character class has only one character in
it, the same character repeated ([aa]), or a multicharacter fold.

A character class is usually compiled as an ANYOF node, but [A] is
optimised down to just A (and EXACT) and /[\xdf]/i is rewritten into a
more complex expression.

When the ANYOF node is abandoned, we need to free any temporary SVs
created in the mean time.  A few of them were leaking.

leakfinder.pl

I wrote this to look for memory leaks.  Since it could be useful to
re-run it at some future time, I might as well put it somewhere where
it will not get lost.

It still needs a bit of work.  Currently, evaluating chunks of binary
code can cause memory leaks.  In those cases the binary code is dumped
straight to the terminal, which is not helpful.

simplify GIMME_V

Since OPf_WANT_VOID == G_VOID etc, we can substantially simplify
the OP_GIMME macro (which is what implements GIMME_V).
This saves 588 bytes in the perl executable on my -O2 system.

Update CGI to CPAN version 3.61

  [DELTA]

  Version 3.61 Nov 2nd, 2012

    (No code changes)

    [INTERNALS]
      - formatting of CGI::Carp documentation was improved. Thanks to benkasminbullock.
      - un-TODO some tests in t/tmpdir.t that were passing in most cases.
      More on this:
        https://github.com/markstos/CGI.pm/issues/19#
        https://github.com/markstos/CGI.pm/commit/cc73dc9807b0fabb56b3cdf1a9726588b2eda0f7

Update Unicode-Normalize to CPAN version 1.16

  [DELTA]

  1.16  Sun Nov  4 17:23:03 2012
    - XSUB: use PERL_NO_GET_CONTEXT (see perlguts)
      (see [rt.cpan.org #80312])

Update Unicode-Collate to CPAN version 0.91

  [DELTA]

  0.91  Sun Nov  4 17:00:20 2012
    - XSUB: use PERL_NO_GET_CONTEXT (see perlguts)
      (see [rt.cpan.org #80313])

Update Digest-SHA to CPAN version 5.73

  [DELTA]

  5.73  Wed Oct 31 04:32:44 MST 2012
    - provided workaround for DEC compiler bug (ref. Makefile.PL)

Sync Module-CoreList version in Maintainers.pl with CPAN

fix an epigraph typo

reported by Vadim Konovalov; thanks!

Remove thread context from Perl_vmssetuserlnm.

This routine by its very nature applies to the whole process so
there is no way it can make use of a thread context, and it may need
to be called from places where there is no thread context, such
as very early in start-up.

It's not documented, was never intended to be part of the API, was
only made global so it could be called from doio.c, and no uses of
it turn up in a CPAN grep, so the change should be safe.

Increase $Module::CoreList::VERSION to 2.76

print deprecation information in corelist

svleak.t: Suppress warning

Stop string eval from leaking ops

This was leaking:

$ ./miniperl  -Xe 'warn $$; while(1){eval "ok 8"};'
1915 at -e line 1.
^C

This was not:

$ ./miniperl  -Xe 'warn $$; while(1){eval "sub {ok 8}"};'
1916 at -e line 1.
^C

The sub is successfully taking care of its ops when it is freed.  The
eval is not.

I made the mistake of having the CV relinquish ownership of the op
slab after an eval syntax error.  That’s precisely the situation in
which the ops are likely to leak, and for which the slab allocator was
designed.  Duh.

Don’t leak when printf causes wide warnings

Don’t leak when printfing to bad handle under fatal warnings

concat2.t: Under miniperl only skip one test

Fix $byte_overload .= $utf8 regression

This is a regression from 5.12.

This was probably broken by commit c5aa287237.

#!perl -lCS
{ package o; use overload '""' => sub { $_[0][0] } }

$x = bless[chr 256],o::;
"$x";
$x->[0] = "\xff";
$x.= chr 257;
$x.= chr 257;

use Devel::Peek;
Dump $x;
print $x;
__END__

Output under 5.12.4:

SV = PVIV(0x820604) at 0x825820
  REFCNT = 1
  FLAGS = (POK,pPOK,UTF8)
  IV = 0
  PV = 0x2139d0 "\303\277\304\201\304\201"\0 [UTF8 "\x{ff}\x{101}\x{101}"]
  CUR = 6
  LEN = 16
ÿāā

Output under 5.14.0:

SV = PVIV(0x820604) at 0x826490
  REFCNT = 1
  FLAGS = (POK,pPOK,UTF8)
  IV = 0
  PV = 0x316230 "\303\277\303\204\302\201\304\201"\0 [UTF8 "\x{ff}\x{c4}\x{81}\x{101}"]
  CUR = 8
  LEN = 16
ÿÄ\81ā

The UTF8 flag is only meaningful right after stringification.

If the $byte_overload scalar happens to have the flag on from last
time, but string overloading will turn the flag off, then pp_concat
gets confused as to whether it is dealing with bytes or utf8.  It
sees both sides as having the same utf8ness, so it concatenates,
which stringifies the lhs and turns off the flag.  The utf8 sequences
appended end up with no utf8 flag associated with them, the observable
effect being that the rhs is encoded as utf8.

If it weren’t for encoding.pm, we could use sv_catpvn_nomg_maybeutf8
and avoid determining the utf8ness of the lhs beforehand.  But see-
ing that encoding.pm still exists, we have to prevent double overload
stringification the other way, by force-stringification of the target.

Don’t leak when pushing on to read-only array

$ ./miniperl -Ilib -w -e 'warn $$; while(1){eval {push @-, ""}}'

Croak first instead of creating a new element to store in the
array first and letting av_store croak.

Don't leak stderr from 'git describe' in cmpVERSION

Detect empty git tag in cmpVERSION

test.pl: allow for undefs in eq_hash

It should be possible to compare hashes with undef values without
triggering warnings.

Fix /a++(?{})+$code_block/

This I would expect:

$ perl5.16.0 -wMre=eval -e '$x = "(?{})"; /a++(?{})+$x/x'
(?{})+ matches null string many times in regex; marked by <-- HERE in m/a++(?{})+ <-- HERE (?{})/ at -e line 1.
Use of uninitialized value $_ in pattern match (m//) at -e line 1.

It warns, but it still runs.

This I would not,

$ perl5.17.5 -wMre=eval -e '$x = "(?{})"; /a++(?{})+$x/x'
Nested quantifiers in regex; marked by <-- HERE in m/a++     + <-- HERE (?{})/ at (eval 1) line 1.

were it not for the fact that I know how it works. :-)

To compile the blocks in $x without recompiling the blocks directly
inside /.../, the regexp compiler blanks out the ‘outer’ blocks with
spaces, and compiles qr'a++     +(?{})'x.  But /x can see through
those spaces, resulting in a change in behaviour.  So use under-
scores instead.

Don’t leak with /(?{})$invalid_code_block/

This script was leaking:

$ ./perl -Ilib -wMre=eval -e '$x = "(?{+})"; while(1){eval {/(?{})$x/}}'

The mallocked array that is allocated before compilation to hold the
code blocks was not being freed before the syntax error from the inner
pattern ($x) was propagated.

Free detritus when croaking with /(?{})$invalid/

This script was leaking:

$ ./miniperl -e 'warn $$; $x = ")"; while( 1){ eval { /(?{})$x/ }; }'

The mallocked array that is allocated before compilation to hold the
code blocks was not being protected properly around the first pass of
compilation.

Stop run-time regexp blocks from leaking regexps

This was leaking like a sieve: $var = '(?{})'; /stuff$var/;

When a run-time regular expression has code blocks in it,
those are compiled separately inside their own qr thingy (see
S_compile_runtime_code in regcomp.c).

In re_op_compile, the newly-compiled code blocks are stored in
pRExC_state->code_blocks, which is a mallocked array.  That array also
holds reference counts on the regular expressions from which the code
blocks derive their existence.  When the whole regular expression is
compiled, the code blocks are fetched from that array, and the new
regular expression ends up holding a reference count on those code
block’s originating regular expressions.

The reference counts that pRExC_state->code_blocks had were not low-
ered when pRExC_state->code_blocks was freed, except for qr/stuff$var/
(because the qr// would take ownership of those reference counts,
which would be lowered when the outer qr// itself was freed).

Stop / $looks_like_block/ from leaking

If an interpolated string looks as though it contains a regexp code
block, the regexp compiler will evaluate it inside qr'...' and then
extract the code blocks from the resulting regexp object.

If it turned out to be a false positive (e.g., "[(?{})]"), then
the code to handle this returned without freeing the temporary reg-
exp object.

add perl5.16.2 to perlhist

add perl5162delta

add the 5.16.2 epigraph

Initial (incomplete) patch to start restoring WinCE build

Subject: RE: status of WinCE Perl port in 2012
From: "Konovalov, Vadim (Vadim)** CTR **" <vadim.konovalov@alcatel-lucent.com>
Date: Tue, 23 Oct 2012 14:26:49 +0200
Message-ID: <35BF8D9716175C43BB9D67CA60CC345E028EE0C899@FRMRSSXCHMBSC2.dc-m.alcatel-lucent.com>

Remove __attribute__malloc__ from MYSWAP functions

These functions are only used when the native sockets functions are not
available, e.g. when building miniperl on Windows following commit
19253ae62c, so gcc's warning about ignoring the __malloc__ attribute here
is not normally seen.

The addition of "a" to these functions in embed.fnc by
commit f54cb97a39 was presumably wrong since none of them actually
allocate any memory (nor did so at the time), so change it to just "R"
(which is implied by the "a" and is still appropriate).

Win32 miniperl: delay loading for Winsock, and then remove it

Slim down the image and speed up start up time for Win32 miniperl by
removing Winsock. Also if the build process on Win32 in the future
requires sockets, commenting one line in win32.h will turn sockets back on
for miniperl, but this time with delay loading on VC Perl. The only casulty
of no sockets for Win32 miniperl was figuring out the computer's name in
win32/config_sh.PL. A workaround by using an ENV var was implemented. The
purpose of this commit is to speed up the build process of Perl.

As said in the comment in win32.h, the WIN32_NO_SOCKETS macro is
incomplete in implementation. It is only removed winsock from being linked
in in miniperl, not full Perl. PERL_IMPLICIT_SYS (specifically PerlSock in
win32/perlhost.h) and makedef.pl's hard coded list of win32_* function
exports cause winsock to still be linked in with even with
WIN32_NO_SOCKETS on full perl. Both PERL_IMPLICIT_SYS (win32/perlhost.h)
and makedef.pl would require changes to remove winsock from being linked
in on full perl in the future.

Add the DynaLoader upgrade to perldelta

Use correct type to avoid a cast added by fe1c5936a5

(Suggested by Tony Cook.)

Bump DynaLoader's $VERSION after commit fe1c5936a5

consting in perl.c:S_Internals_V and Win32 DynaLoader

These assorted static allocated variables were in RW memory in the perl
image. Move them to RO memory so they are sharable between different
Perl processes by the OS. The lack of consting in Win32 Dynaloader traces
to commit 0a753a76406 . S_Internals_V traces to commit 4a5df386486 .

Three spelling corrections.

utf8.c: Stop _core_swash_init from leaking

If an %INC hook or $@ assignment dies, then a scalar is leaked.  I
don’t know that it is possible to test this.

Allow regexp-to-pvlv assignment

Since the xpvlv and regexp structs conflict, we have to find somewhere
else to put the regexp struct.

I was going to sneak it in SvPVX, allocating a buffer large
enough to fit the regexp struct followed by the string, and have
SvPVX - sizeof(regexp) point to the struct.  But that would make all
regexp flag-checking macros fatter, and those are used in hot code.

So I came up with another method.  Regexp stringification is not
speed-critical.  So we can move the regexp stringification out of
re->sv_u and put it in the regexp struct.  Then the regexp struct
itself can be pointed to by re->sv_u.  So SVt_REGEXPs will have
re->sv_any and re->sv_u pointing to the same spot.  PVLVs can then
have sv->sv_any point to the xpvlv body as usual, but have sv->sv_u
point to a regexp struct.  All regexp member access can go through
sv_u instead of sv_any, which will be no slower than before.

Regular expressions will no longer be SvPOK, so we give sv_2pv spec-
ial logic for regexps.  We don’t need to make the regexp struct
larger, as SvLEN is currently always 0 iff mother_re is set.  So we
can replace the SvLEN field with the pv.

SvFAKE is never used without SvPOK or SvSCREAM also set.  So we can
use that to identify regexps.

regcomp.c: Really stop regexp-to-pv assignment from leaking

edd9fea2b8 was not enough.  A scalar may hold a PV even with the
SvPOKp flag off:

$ ./perl -Ilib -e 'warn $$; while(1){ $x = "a"; $x = 1; $x = ${qr//}}'

Turn off OK flags when creating a regexp.

$ perl5.16.0 -le '$x = 1.1; $x = ${qr//}; print 0+$x'
4.15336878055219e-317
$ perl5.16.0 -le '$x = 1; $x = ${qr//}; print 0+$x'
1645024

Very strange.

Under debugging builds, both produce assertion failures.

By turning off all OK flags, we also prevent the destination’s utf8-
ness from sticking.

sv.c: Drop PV when assigning over regexp

    $x = ${qr//};
    $x = 3;

On the second line, we don’t need to copy the stringification of the
regexp, since we are just going to clobber it anyway.

Prune dead code in sv.c:sv_force_normal_flags

When a regexp is unregexped, a new SV (temp) is created, so it
can swap bodies with the regular expression (sv), and then temp
can be freed.

If SvLEN is 0, then a scalar does not own its string buffer.  Copied
regexps use that mechanism to share strings; only the original regexp
owns the string.

This little bit of code for handling the SvPVX field is strange:

/* Remember that SvPVX is in the head, not the body. */
if (SvLEN(temp)) {
    SvLEN_set(temp, SvLEN(sv));
    /* This signals "buffer is owned by someone else" in sv_clear,
       which is the least effort way to stop it freeing the buffer.
    */
    SvLEN_set(sv, SvLEN(sv)+1);
} else {
    /* Their buffer is already owned by someone else. */
    SvPVX(sv) = savepvn(SvPVX(sv), SvCUR(sv));
    SvLEN_set(temp, SvCUR(sv)+1);
}

Checking SvLEN(temp) is pointless if we have just created temp.  That
check is always false.  Presumably it was meant to be SvLEN(sv).  But
the original regexp scalar (i.e., not a copy) can never make it to
this function.  So SvLEN(sv) is always 0, which is why this has
not caused any problem.  The SvLEN_set inside the apodosis is also
strange.  ‘This signals "buffer is owned by someone else"’.  No it
certainly does not!  It is not setting SvLEN to 0, but definitely to
non-zero.  I can only assume this is a copy-and-paste error, which has
never caused a problem because it is unreachable.

I hereby excise this code (leaving the contents of the else).

regcomp.c: Don’t point mother_re to regexp copy

In code like this:

    $x = ${qr//};
    $y = $x
    undef $x;

We end up with $y’s mother_re pointer pointing to something that is
not a regexp.

This can cause thread cloning to create a new regexp with its SvPVX
pointing to the string buffer of the original regexp:

    $x = ${qr/abcd/};
    $y = $x;
    use Devel::Peek;
    Dump($y);
    $x = *3;
    use threads;
    async { Dump $y; print $y, "\n" }->join;

The dump shows that both $y’s share the same string buffer, and nei-
ther claims ownership to it.

I have not been able to make this crash or reuse the string for some-
thing else, but still this is walking a fine line.  Theoretically, it
should be possible for that string to be freed and reused in the par-
ent thread while the child thread is still using it.

Instead of pointing mother_re to the rhs of the assignment, point it
to the original re from which the rhs derives its existence.  I.e.,
copy the mother_re field.

regcomp.c: Stop regexp-to-pv assignemnt from leaking

SvPV_set will just set SvPVX, allowing the existing value to leak.

This leak was caused by f082678508, which allowed reg_temp_copy to
be called with an existing SV, but without modifying the contents of
reg_temp_copy to account.

sv.c: Fix code-before-declarations

Don’t crash with $tied[-1] when array is tied to non-obj

The code for checking to see whether $NEGATIVE_INDICES is defined in
the tie package was very fragile, and was repeated four times.

Don’t skip tied EXISTS for negative array indices

This was broken in 5.14.0 for those cases where $NEGATIVE_INDICES is
not true:

sub TIEARRAY{bless[]};
sub FETCHSIZE { 50 }
sub EXISTS { print "does $_[1] exist?\n" }
tie @a, "";
exists $a[1];
exists $a[-1];
$NEGATIVE_INDICES=1;
exists $a[-1];

$ pbpaste|perl5.12.0
does 1 exist?
does 49 exist?
does -1 exist?
$ pbpaste|perl5.14.0
does 1 exist?
does -1 exist?

This was broken by 54a4274e3c.

yyerror->yyerror_pvn in toke.c:S_new_constant

Avoids a strlen.

rmv a sv_2mortal and unused var in toke.c:Perl_yyerror_pvn

newSVpvn_flags is capable of mortalizing already, use that, is_utf8 is used
only once, waste of an auto var stack slot to calculate it so early,
instead create the flags arg to newSVpvn_flags at the point of usage.
flags param of yyerror_pvn will always be on the C stack.

sv.c: Allow blessed cows

There is no reason kine should not receive blessings, too.

sv.c: Remove redundant Sv[INP]OK checks on fbm/regexps

These two code paths, sv_2iv and sv_2uv, used to be shared with gmag-
ical scalars in general, but now only apply to scalars that cannot
hold numeric values and are always SvPOK.

sv.c: Remove redundant sv_force_normal calls from sv_2[iun]v

The previous commit made it possible to nummify a string whose SvLEN
is 0.  So we don’t need to run shared hash key scalars through
sv_force_normal before nummifying them.  We still need to run COW sca-
lars through sv_force_normal under PERL_OLD_COPY_ON_WRITE, as it uses
the IVX field for COW bookkeeping.  For simplicity’s sake, I’m not
bothering to distinguish shared hash keys scalars from other COW sca-
lars under PERL_OLD_COPY_ON_WRITE.

sv.c: !SvLEN does not mean undefined

There are various SvPOKp(sv) && SvLEN(sv) checks in numeric
conversion routines in sv.c, which date back to perl 1.  (See
<http://perl5.git.perl.org/perl.git/blob/8d063cd8450e59e:/str.c#l89>.)
Back then it did not matter, as str->len (later SvLEN) was always set
when there was a PV.  It was not until perl 5.003_01 (1edc1566d5) that
we got the SvLEN==0 mechanism for PVs not owned by the scalar.  (I
don’t believe it was actually used till later, so when this became a
problem I don’t know--but that’s enough digging.)

A regexp returned by ${qr//} is POK but does not own its string.  This
means that nummifying a regexp will result in a uninitialized warning.

The SvLEN check is redundant and problematic, so I am removing it.
(This also means I can remove the sv_force_normal calls in the next
commit, since shared hash key scalars, which also have SvLEN==0 will
no longer need it to pass the SvLEN checks.)

This does mean, however, that SVt_REGEXP can reach code paths that
expect to be able to use Sv[IN]VX (not valid for regexps), so I actu-
ally have to check that the type != SVt_REGEXP as well.  We already
have code for handling fbm scalars (for which Sv[IN]VX fields are also
unusable), so we can send regexps through those paths.

Stop regexp assignment from clobbering magic

$ perl5.10.0 -le '$1 = ${qr||}; print "ok"'
Modification of a read-only value attempted at -e line 1.
$ perl5.12.0 -le '$1 = ${qr||}; print "ok"'
ok

Wonderful!

It can also cause blessings to be lost, or so I thought:

sub curse {
  for my $obj ( ${$_[0]} ) {
    my $save = $obj;
    $obj = ${qr||};
    $obj = $save;
  }
}
$y = bless \$x;
print $y, "\n"; # main=SCALAR(0x825b70)
curse $y;
print $y, "\n"; # Bus error

The OBJECT flag gets left on, but SvSTASH is null.

Commit b9ad13acb set SvSTASH to null after copying the regexp struct.
Commit 703c388dc did the same with SvMAGIC.  In both cases, this was
to avoid bugs involving magic and blessings being copied by = which
should not happen.  But both changes caused other bugs.

Three months later, 6e1287864cd changed the order of the struct, such
that SvMAGIC and SvSTASH are no longer copied from the parent regexp,
rendering the aforementioned changes no longer necessary.

Fix assertion failure with $float = $regexp assignment

Commit b9ad13acb3 caused case SVt_REGEXP in sv_upgrade to fall
through to the assertions under case SVt_PVIV that are not relevant to
SVt_REGEXP.

We should really be setting the FAKE flag when actually making a sca-
lar a regexp, rather than in sv_upgrade.  (I will probably need it
there in future commits, too, since it really should be possible for
SVt_PVLVs to hold regular expressions.)

sv.c: No need to de-COW COWs on upgrade

I’ve taken the conservative approach of still de-COWing COWs for reg-
exps and anything above.  I’m not confident that it would be safe
for those.

Don’t sv_force_normal in mg.c:S_save_magic

This was added to make SvREADONLY_off safe.  (I think read-only is
turned off during magic so the magic scalar itself can be set without
the sv_set* functions getting upset.)  Since SvREADONLY doesn’t mean
read-only for COWs, we don’t actually need to do sv_force_normal, but
can simply skip SvREADONLY_off for COWs.

By leaving it to sv_set* functions to do sv_force_normal, we avoid
having to copy the string buffer if it is just going to be thrown away
anyway.  S_save_magic can’t know whether the scalar will actually be
overwritten, so it has to copy the buffer.