perldelta is now the perl5220delta

7 files changed, 2963 insertions, 155 deletions

diff --git a/Makefile.SH b/Makefile.SH
index 4a7a357ad5..034d812c2e 100755
--- a/Makefile.SH
+++ b/Makefile.SH
@@ -492,7 +492,7 @@ mini_obj = $(minindt_obj) $(MINIDTRACE_O)
 ndt_obj = $(obj0) $(obj1) $(obj2) $(obj3) $(ARCHOBJS)
 obj = $(ndt_obj) $(DTRACE_O)
 
-perltoc_pod_prereqs = extra.pods pod/perl52112delta.pod pod/perlapi.pod pod/perlintern.pod pod/perlmodlib.pod pod/perluniprops.pod
+perltoc_pod_prereqs = extra.pods pod/perl5220delta.pod pod/perlapi.pod pod/perlintern.pod pod/perlmodlib.pod pod/perluniprops.pod
 generated_pods = pod/perltoc.pod $(perltoc_pod_prereqs)
 generated_headers = uudmap.h bitcount.h mg_data.h
 
@@ -1020,9 +1020,9 @@ pod/perlintern.pod: $(MINIPERL_EXE) autodoc.pl embed.fnc
 pod/perlmodlib.pod: $(MINIPERL_EXE) pod/perlmodlib.PL MANIFEST
 	$(MINIPERL) pod/perlmodlib.PL -q
 
-pod/perl52112delta.pod: pod/perldelta.pod
-	$(RMS) pod/perl52112delta.pod
-	$(LNS) perldelta.pod pod/perl52112delta.pod
+pod/perl5220delta.pod: pod/perldelta.pod
+	$(RMS) pod/perl5220delta.pod
+	$(LNS) perldelta.pod pod/perl5220delta.pod
 
 extra.pods: $(MINIPERL_EXE)
 	-@test ! -f extra.pods || rm -f `cat extra.pods`
diff --git a/pod/.gitignore b/pod/.gitignore
index 1ef84951d0..e6a3ab34df 100644
--- a/pod/.gitignore
+++ b/pod/.gitignore
@@ -53,7 +53,7 @@
 /roffitall
 
 # generated
-/perl52112delta.pod
+/perl5220delta.pod
 /perlapi.pod
 /perlintern.pod
 *.html
diff --git a/pod/perldelta.pod b/pod/perldelta.pod
index d1a5fc93ad..46b6b342ff 100644
--- a/pod/perldelta.pod
+++ b/pod/perldelta.pod
@@ -2,94 +2,662 @@
 
 =head1 NAME
 
-[ this is a template for a new perldelta file.  Any text flagged as XXX needs
-to be processed before release. ]
-
-perldelta - what is new for perl v5.21.12
+perldelta - what is new for perl v5.22.0
 
 =head1 DESCRIPTION
 
-This document describes differences between the 5.21.11 release and the 5.21.12
+This document describes differences between the 5.22.0 release and the 5.20.0
 release.
 
-If you are upgrading from an earlier release such as 5.21.10, first read
-L<perl52111delta>, which describes differences between 5.21.10 and 5.21.11.
+If you are upgrading from an earlier release such as 5.18.0, first read
+L<perl5200delta>, which describes differences between 5.18.0 and 5.20.0.
 
-=head1 Notice
+=head1 Core Enhancements
 
-XXX Any important notices here
+=head2 New bitwise operators
 
-=head1 Core Enhancements
+A new experimental facility has been added that makes the four standard
+bitwise operators (C<& | ^ ~>) treat their operands consistently as
+numbers, and introduces four new dotted operators (C<&. |. ^. ~.>) that
+treat their operands consistently as strings.  The same applies to the
+assignment variants (C<&= |= ^= &.= |.= ^.=>).
+
+To use this, enable the "bitwise" feature and disable the
+"experimental::bitwise" warnings category.  See L<perlop/Bitwise String
+Operators> for details.  [rt.perl.org #123466]
+
+=head2 New double-diamond operator
+
+C<<< <<>> >>> is like C<< <> >> but uses three-argument C<open> to open
+each file in @ARGV.  So each element of @ARGV is an actual file name, and
+"|foo" won't be treated as a pipe open.
+
+=head2 New \b boundaries in regular expressions
+
+=head3 qr/\b{gcb}/
+
+C<gcb> stands for Grapheme Cluster Boundary.  It is a Unicode property
+that finds the boundary between sequences of characters that look like a
+single character to a native speaker of a language.  Perl has long had
+the ability to deal with these through the C<\X> regular escape
+sequence.  Now, there is an alternative way of handling these.  See
+L<perlrebackslash/\b{}, \b, \B{}, \B> for details.
+
+=head3 qr/\b{wb}/
+
+C<wb> stands for Word Boundary.  It is a Unicode property
+that finds the boundary between words.  This is similar to the plain
+C<\b> (without braces) but is more suitable for natural language
+processing.  It knows, for example that apostrophes can occur in the
+middle of words.  See L<perlrebackslash/\b{}, \b, \B{}, \B> for details.
+
+=head3 qr/\b{sb}/
+
+C<sb> stands for Sentence Boundary.  It is a Unicode property
+to aid in parsing natural language sentences.
+See L<perlrebackslash/\b{}, \b, \B{}, \B> for details.
+
+=head2 C<no re> covers more and is lexical
+
+Previously running C<no re> would only turn off a few things. Now it
+turns off all the enabled things. For example, previously, you
+couldn't turn off debugging, once enabled, inside the same block.
+
+=head2 Non-Capturing Regular Expression Flag
+
+Regular expressions now support a C</n> flag that disables capturing
+and filling in C<$1>, C<$2>, etc... inside of groups:
+
+  "hello" =~ /(hi|hello)/n; # $1 is not set
+
+This is equivalent to putting C<?:> at the beginning of every capturing group.
+
+See L<perlre/"n"> for more information.
+
+=head2 C<use re 'strict'>
+
+This applies stricter syntax rules to regular expression patterns
+compiled within its scope, which hopefully will alert you to typos and
+other unintentional behavior that backwards-compatibility issues prevent
+us from doing in normal regular expression compilations.  Because the
+behavior of this is subject to change in future Perl releases as we gain
+experience, using this pragma will raise a category
+C<experimental::re_strict> warning.
+See L<'strict' in re|re/'strict' mode>.
+
+=head2 C<qr/foo/x> now ignores any Unicode pattern white space
+
+The C</x> regular expression modifier allows the pattern to contain
+white space and comments, both of which are ignored, for improved
+readability.  Until now, not all the white space characters that Unicode
+designates for this purpose were handled.  The additional ones now
+recognized are
+U+0085 NEXT LINE,
+U+200E LEFT-TO-RIGHT MARK,
+U+200F RIGHT-TO-LEFT MARK,
+U+2028 LINE SEPARATOR,
+and
+U+2029 PARAGRAPH SEPARATOR.
+
+=head2 Unicode 7.0 is now supported
+
+For details on what is in this release, see
+L<http://www.unicode.org/versions/Unicode7.0.0/>.
+
+=head2 S<C<use locale>> can restrict which locale categories are affected
+
+It is now possible to pass a parameter to S<C<use locale>> to specify
+a subset of locale categories to be locale-aware, with the remaining
+ones unaffected.  See L<perllocale/The "use locale" pragma> for details.
+
+=head2 Perl now supports POSIX 2008 locale currency additions.
+
+On platforms that are able to handle POSIX.1-2008, the
+hash returned by
+L<C<POSIX::localeconv()>|perllocale/The localeconv function>
+includes the international currency fields added by that version of the
+POSIX standard.  These are
+C<int_n_cs_precedes>,
+C<int_n_sep_by_space>,
+C<int_n_sign_posn>,
+C<int_p_cs_precedes>,
+C<int_p_sep_by_space>,
+and
+C<int_p_sign_posn>.
+
+=head2 Better heuristics on older platforms for determining locale UTF8ness
+
+On platforms that implement neither the C99 standard nor the POSIX 2001
+standard, determining if the current locale is UTF8 or not depends on
+heuristics.  These are improved in this release.
+
+=head2 Aliasing via reference
+
+Variables and subroutines can now be aliased by assigning to a reference:
+
+    \$c = \$d;
+    \&x = \&y;
+
+Or by using a backslash before a C<foreach> iterator variable, which is
+perhaps the most useful idiom this feature provides:
+
+    foreach \%hash (@array_of_hash_refs) { ... }
+
+This feature is experimental and must be enabled via C<use feature
+'refaliasing'>.  It will warn unless the C<experimental::refaliasing>
+warnings category is disabled.
+
+See L<perlref/Assigning to References>
+
+=head2 C<prototype> with no arguments
+
+C<prototype()> with no arguments now infers C<$_>.  [perl #123514]
+
+=head2 New "const" subroutine attribute
+
+The "const" attribute can be applied to an anonymous subroutine.  It causes
+it to be executed immediately when it is cloned.  Its value is captured and
+used to create a new constant subroutine that is returned.  This feature is
+experimental.  See L<perlsub/Constant Functions>.
+
+=head2 C<fileno> now works on directory handles
 
-XXX New core language features go here.  Summarize user-visible core language
-enhancements.  Particularly prominent performance optimisations could go
-here, but most should go in the L</Performance Enhancements> section.
+When the relevant support is available in the operating system, the
+C<fileno> builtin now works on directory handles, yielding the
+underlying file descriptor in the same way as for filehandles. On
+operating systems without such support, C<fileno> on a directory handle
+continues to return the undefined value, as before, but also sets C<$!> to
+indicate that the operation is not supported.
 
-[ List each enhancement as a =head2 entry ]
+Currently, this uses either a C<dd_fd> member in the OS C<DIR>
+structure, or a dirfd(3) function as specified by POSIX.1-2008.
+
+=head2 List form of pipe open implemented for Win32
+
+The list form of pipe:
+
+  open my $fh, "-|", "program", @arguments;
+
+is now implemented on Win32.  It has the same limitations as C<system
+LIST> on Win32, since the Win32 API doesn't accept program arguments
+as a list.
+
+=head2 C<close> now sets C<$!>
+
+When an I/O error occurs, the fact that there has been an error is recorded
+in the handle.  C<close> returns false for such a handle.  Previously, the
+value of C<$!> would be untouched by C<close>, so the common convention of
+writing C<close $fh or die $!> did not work reliably.  Now the handle
+records the value of C<$!>, too, and C<close> restores it.
+
+=head2 Assignment to list repetition
+
+C<(...) x ...> can now be used within a list that is assigned to, as long
+as the left-hand side is a valid lvalue.  This allows C<(undef,undef,$foo)
+= that_function()> to be written as C<((undef)x2, $foo) = that_function()>.
+
+=head2 Infinity and NaN (not-a-number) handling improved
+
+Floating point values are able to hold the special values infinity (also
+-infinity), and NaN (not-a-number).  Now we more robustly recognize and
+propagate the value in computations, and on output normalize them to C<Inf> and
+C<NaN>.
+
+See also the L<POSIX> enhancements.
+
+=head2 Floating point parsing has been improved
+
+Parsing and printing of floating point values has been improved.
+
+As a completely new feature, hexadecimal floating point literals
+(like 0x1.23p-4)  are now supported, and they can be output with
+C<printf %a>.
+
+=head2 Packing infinity or not-a-number into a character is now fatal
+
+Before, when trying to pack infinity or not-a-number into a
+(signed) character, Perl would warn, and assumed you tried to
+pack C<< 0xFF >>; if you gave it as an argument to C<< chr >>,
+C<< U+FFFD >> was returned.
+
+But now, all such actions (C<< pack >>, C<< chr >>, and C<< print '%c' >>)
+result in a fatal error.
+
+=head2 Experimental C Backtrace API
+
+Starting from Perl 5.21.1, on some platforms Perl supports retrieving
+the C level backtrace (similar to what symbolic debuggers like gdb do).
+
+The backtrace returns the stack trace of the C call frames,
+with the symbol names (function names), the object names (like "perl"),
+and if it can, also the source code locations (file:line).
+
+The supported platforms are Linux and OS X (some *BSD might work at
+least partly, but they have not yet been tested).
+
+The feature needs to be enabled with C<Configure -Dusecbacktrace>.
+
+Also included is a C API to retrieve backtraces.
+
+See L<perlhacktips/"C backtrace"> for more information.
 
 =head1 Security
 
-XXX Any security-related notices go here.  In particular, any security
-vulnerabilities closed should be noted here rather than in the
-L</Selected Bug Fixes> section.
+=head2 Perl is now compiled with -fstack-protector-strong if available
+
+Perl has been compiled with the anti-stack-smashing option
+C<-fstack-protector> since 5.10.1.  Now Perl uses the newer variant
+called C<-fstack-protector-strong>, if available.
+
+=head2 The L<Safe> module could allow outside packages to be replaced
+
+Critical bugfix: outside packages could be replaced.  L<Safe> has
+been patched to 2.38 to address this.
+
+=head2 Perl is now always compiled with -D_FORTIFY_SOURCE=2 if available
 
-[ List each security issue as a =head2 entry ]
+The 'code hardening' option called C<_FORTIFY_SOURCE>, available in
+gcc 4.*, is now always used for compiling Perl, if available.
+
+Note that this isn't necessarily a huge step since in many platforms
+the step had already been taken several years ago: many Linux
+distributions (like Fedora) have been using this option for Perl,
+and OS X has enforced the same for many years.
 
 =head1 Incompatible Changes
 
-XXX For a release on a stable branch, this section aspires to be:
+=head2 Subroutine signatures moved before attributes
+
+The experimental sub signatures feature, as introduced in 5.20, parsed
+signatures after attributes.  In this release, the positioning has been
+moved such that signatures occur after the subroutine name (if any) and
+before the attribute list (if any).
+
+=head2 C<&> and C<\&> prototypes accepts only subs
+
+The C<&> prototype character now accepts only anonymous subs (C<sub {...}>)
+and things beginning with C<\&>.  Formerly it erroneously also allowed
+C<undef> and references to array, hashes, and lists.  [perl #4539]
+[perl #123062]
+
+The C<\&> prototype was allowing subroutine calls, whereas now it only
+allows subroutines.  C<&foo> is permitted.  C<&foo()> and C<foo()> are not.
+[perl #77860]
+
+=head2 C<use encoding> is now lexical
+
+The L<encoding> pragma's effect is now limited to lexical scope.  This
+pragma is deprecated, but in the meantime, it could adversely affect
+unrelated modules that are included in the same program.
+
+=head2 List slices returning empty lists
+
+List slices return an empty list now only if the original list was empty
+(or if there are no indices).  Formerly, a list slice would return an empty
+list if all indices fell outside the original list.  [perl #114498]
+
+=head2 C<\N{}> with a sequence of multiple spaces is now a fatal error.
+
+This has been deprecated since v5.18.
+
+=head2 S<C<use UNIVERSAL '...'>> is now a fatal error
+
+Importing functions from C<UNIVERSAL> has been deprecated since v5.12, and
+is now a fatal error.  S<C<"use UNIVERSAL">> without any arguments is still
+allowed.
+
+=head2 In double-quotish C<\cI<X>>, I<X> must now be a printable ASCII character
+
+In prior releases, failure to do this raised a deprecation warning.
 
-    There are no changes intentionally incompatible with 5.XXX.XXX
-    If any exist, they are bugs, and we request that you submit a
-    report.  See L</Reporting Bugs> below.
+=head2 Splitting the tokens C<(?> and C<(*> in regular expressions is
+now a fatal compilation error.
 
-[ List each incompatible change as a =head2 entry ]
+These had been deprecated since v5.18.
+
+=head2 5 additional characters are treated as white space under C</x> in
+regex patterns (unless escaped)
+
+The use of these characters with C</x> outside bracketed character
+classes and when not preceded by a backslash has raised a deprecation
+warning since v5.18.  Now they will be ignored.  See L</"qr/foo/x">
+for the list of the five characters.
+
+=head2 Comment lines within S<C<(?[ ])>> now are ended only by a C<\n>
+
+S<C<(?[ ])>>  is an experimental feature, introduced in v5.18.  It operates
+as if C</x> is always enabled.  But there was a difference, comment
+lines (following a C<#> character) were terminated by anything matching
+C<\R> which includes all vertical whitespace, such as form feeds.  For
+consistency, this is now changed to match what terminates comment lines
+outside S<C<(?[ ])>>, namely a C<\n> (even if escaped), which is the
+same as what terminates a heredoc string and formats.
+
+=head2 C<(?[...])> operators now follow standard Perl precedence
+
+This experimental feature allows set operations in regular expression patterns.
+Prior to this, the intersection operator had the same precedence as the other
+binary operators.  Now it has higher precedence.  This could lead to different
+outcomes than existing code expects (though the documentation has always noted
+that this change might happen, recommending fully parenthesizing the
+expressions).  See L<perlrecharclass/Extended Bracketed Character Classes>.
+
+=head2 Omitting % and @ on hash and array names is no longer permitted
+
+Really old Perl let you omit the @ on array names and the % on hash
+names in some spots.  This has issued a deprecation warning since Perl
+5.0, and is no longer permitted.
+
+=head2 C<"$!"> text is now in English outside C<"use locale"> scope
+
+Previously, the text, unlike almost everything else, always came out
+based on the current underlying locale of the program.  (Also affected
+on some systems is C<"$^E>".)  For programs that are unprepared to
+handle locale, this can cause garbage text to be displayed.  It's better
+to display text that is translatable via some tool than garbage text
+which is much harder to figure out.
+
+=head2 C<"$!"> text will be returned in UTF-8 when appropriate
+
+The stringification of C<$!> and C<$^E> will have the UTF-8 flag set
+when the text is actually non-ASCII UTF-8.  This will enable programs
+that are set up to be locale-aware to properly output messages in the
+user's native language.  Code that needs to continue the 5.20 and
+earlier behavior can do the stringification within the scopes of both
+'use bytes' and 'use locale ":messages".  No other Perl operations will
+be affected by locale; only C<$!> and C<$^E> stringification.  The
+'bytes' pragma causes the UTF-8 flag to not be set, just as in previous
+Perl releases.  This resolves [perl #112208].
+
+=head2 Support for C<?PATTERN?> without explicit operator has been removed
+
+Starting regular expressions matching only once directly with the
+question mark delimiter is now a syntax error, so that the question mark
+can be available for use in new operators.  Write C<m?PATTERN?> instead,
+explicitly using the C<m> operator: the question mark delimiter still
+invokes match-once behaviour.
+
+=head2 C<defined(@array)> and C<defined(%hash)> are now fatal errors
+
+These have been deprecated since v5.6.1 and have raised deprecation
+warnings since v5.16.
+
+=head2 Using a hash or an array as a reference are now fatal errors.
+
+For example, C<%foo-E<gt>{"bar"}> now causes a fatal compilation
+error.  These have been deprecated since before v5.8, and have raised
+deprecation warnings since then.
+
+=head2 Changes to the C<*> prototype
+
+The C<*> character in a subroutine's prototype used to allow barewords to take
+precedence over most, but not all subroutines.  It was never consistent and
+exhibited buggy behaviour.
+
+Now it has been changed, so subroutines always take precedence over barewords,
+which brings it into conformity with similarly prototyped built-in functions:
+
+    sub splat(*) { ... }
+    sub foo { ... }
+    splat(foo); # now always splat(foo())
+    splat(bar); # still splat('bar') as before
+    close(foo); # close(foo())
+    close(bar); # close('bar')
 
 =head1 Deprecations
 
-XXX Any deprecated features, syntax, modules etc. should be listed here.
+=head2 Setting C<${^ENCODING}> to anything but C<undef>
 
-=head2 Module removals
+This variable allows Perl scripts to be written in a non-ASCII,
+non-UTF-8 encoding.  However, it affects all modules globally, leading
+to wrong answers and segmentation faults.  New scripts should be written
+in UTF-8; old scripts should be converted to UTF-8, which is easily done
+with the L<encoding> pragma.
 
-XXX Remove this section if inapplicable.
+=head2 C<< /\C/ >> character class
 
-The following modules will be removed from the core distribution in a
-future release, and will at that time need to be installed from CPAN.
-Distributions on CPAN which require these modules will need to list them as
-prerequisites.
+This character class, which matches a single byte, even if it appears
+in a multi-byte character has been deprecated. Matching single bytes
+in a multi-byte character breaks encapsulation, and can corrupt utf8
+strings.
 
-The core versions of these modules will now issue C<"deprecated">-category
-warnings to alert you to this fact.  To silence these deprecation warnings,
-install the modules in question from CPAN.
+=head2 Use of non-graphic characters in single-character variable names
 
-Note that these are (with rare exceptions) fine modules that you are encouraged
-to continue to use.  Their disinclusion from core primarily hinges on their
-necessity to bootstrapping a fully functional, CPAN-capable Perl installation,
-not usually on concerns over their design.
+The syntax for single-character variable names is more lenient than
+for longer variable names, allowing the one-character name to be a
+punctuation character or even invisible (a non-graphic).  Perl v5.20
+deprecated the ASCII-range controls as such a name.  Now, all
+non-graphic characters that formerly were allowed are deprecated.
+The practical effect of this occurs only when not under C<S<"use
+utf8">>, and affects just the C1 controls (code points 0x80 through
+0xFF), NO-BREAK SPACE, and SOFT HYPHEN.
 
-=over
+=head2 Inlining of C<sub () { $var }> with observable side-effects
 
-=item XXX
+In many cases Perl makes sub () { $var } into an inlinable constant
+subroutine, capturing the value of $var at the time the C<sub> expression
+is evaluated.  This can break the closure behaviour in those cases where
+$var is subsequently modified.  The subroutine won't return the new value.
 
-XXX Note that deprecated modules should be listed here even if they are listed
-as an updated module in the L</Modules and Pragmata> section.
+This usage is now deprecated in those cases where the variable could be
+modified elsewhere.  Perl detects those cases and emits a deprecation
+warning.  Such code will likely change in the future and stop producing a
+constant.
 
-=back
+If your variable is only modified in the place where it is declared, then
+Perl will continue to make the sub inlinable with no warnings.
 
-[ List each other deprecation as a =head2 entry ]
+    sub make_constant {
+        my $var = shift;
+        return sub () { $var }; # fine
+    }
 
-=head1 Performance Enhancements
+    sub make_constant_deprecated {
+        my $var;
+        $var = shift;
+        return sub () { $var }; # deprecated
+    }
+
+    sub make_constant_deprecated2 {
+        my $var = shift;
+        log_that_value($var); # could modify $var
+        return sub () { $var }; # deprecated
+    }
+
+In the second example above, detecting that $var is assigned to only once
+is too hard to detect.  That it happens in a spot other than the C<my>
+declaration is enough for Perl to find it suspicious.
+
+This deprecation warning happens only for a simple variable for the body of
+the sub.  (A C<BEGIN> block or C<use> statement inside the sub is ignored,
+because it does not become part of the sub's body.)  For more complex
+cases, such as C<sub () { do_something() if 0; $var }> the behaviour has
+changed such that inlining does not happen if the variable is modifiable
+elsewhere.  Such cases should be rare.
+
+=head2 Use of multiple /x regexp modifiers
+
+It is now deprecated to say something like any of the following:
+
+    qr/foo/xx;
+    /(?xax:foo)/;
+    use re qw(/amxx);
+
+That is, now C<x> should only occur once in any string of contiguous
+regular expression pattern modifiers.  We do not believe there are any
+occurrences of this in all of CPAN.  This is in preparation for a future
+Perl release having C</xx> mean to allow white-space for readability in
+bracketed character classes (those enclosed in square brackets:
+C<[...]>).
+
+=head2 Using a NO-BREAK space in a character alias for C<\N{...}> is now
+deprecated
 
-XXX Changes which enhance performance without changing behaviour go here.
-There may well be none in a stable release.
+This non-graphic character is essentially indistinguishable from a
+regular space, and so should not be allowed.  See
+L<charnames/CUSTOM ALIASES>.
 
-[ List each enhancement as a =item entry ]
+=head2 A literal C<"{"> should now be escaped in a pattern
+
+If you want a literal left curly bracket (also called a left brace) in a
+regular expression pattern, you should now escape it by either
+preceding it with a backslash (C<"\{">) or enclosing it within square
+brackets C<"[{]">, or by using C<\Q>; otherwise a deprecation warning
+will be raised.  This was first announced as forthcoming in the v5.16
+release; it will allow future extensions to the language to happen.
+
+=head2 Making all warnings fatal is discouraged
+
+The documentation for L<fatal warnings|warnings/Fatal Warnings> notes that
+C<< use warnings FATAL => 'all' >> is discouraged and provides stronger
+language about the risks of fatal warnings in general.
+
+=head1 Performance Enhancements
 
 =over 4
 
 =item *
 
-XXX
+If method and class names are known at compile time, hashes are precomputed
+to speed up run-time method lookup.  Also, compound method names like
+C<SUPER::new> are parsed at compile time, to save having to parse them at
+run time.
+
+=item *
+
+Array and hash lookups (especially nested ones) that use only constants
+or simple variables as keys, are now considerably faster. See
+L</Internal Changes> for more details.
+
+=item *
+
+C<(...)x1>, C<("constant")x0> and C<($scalar)x0> are now optimised in list
+context.  If the right-hand argument is a constant 1, the repetition
+operator disappears.  If the right-hand argument is a constant 0, the whole
+expressions is optimised to the empty list, so long as the left-hand
+argument is a simple scalar or constant.  C<(foo())x0> is not optimised.
+
+=item *
+
+C<substr> assignment is now optimised into 4-argument C<substr> at the end
+of a subroutine (or as the argument to C<return>).  Previously, this
+optimisation only happened in void context.
+
+=item *
+
+Assignment to lexical variables is often optimised away.  For instance, in
+C<$lexical = chr $foo>, the C<chr> operator writes directly to the lexical
+variable instead of returning a value that gets copied.  This optimisation
+has been extended to C<split>, C<x> and C<vec> on the right-hand side.  It
+has also been made to work with state variable initialization.
+
+=item *
+
+In "\L...", "\Q...", etc., the extra "stringify" op is now optimised away,
+making these just as fast as C<lcfirst>, C<quotemeta>, etc.
+
+=item *
+
+Assignment to an empty list is now sometimes faster.  In particular, it
+never calls C<FETCH> on tied arguments on the right-hand side, whereas it
+used to sometimes.
+
+=item *
+
+C<length> is up to 20% faster for non-magical/non-tied scalars containing a
+string if it is a non-utf8 string or if C<use bytes;> is in scope.
+
+=item *
+
+Non-magical/non-tied scalars that contain only a floating point value and are
+on most Perl builds with 64 bit integers now use 8-32 less bytes of memory
+depending on OS.
+
+=item *
+
+In C<@array = split>, the assignment can be optimized away with C<split>
+writing directly to the array.  This optimisation was happening only for
+package arrays other than @_ and only
+sometimes.  Now this optimisation happens
+almost all the time.
+
+=item *
+
+C<join> is now subject to constant folding.  Moreover, C<join> with a
+scalar or constant for the separator and a single-item list to join is
+simplified to a stringification.  The separator doesn't even get evaluated.
+
+=item *
+
+C<qq(@array)> is implemented using two ops: a stringify op and a join op.
+If the qq contains nothing but a single array, the stringification is
+optimized away.
+
+=item *
+
+C<our $var> and C<our($s,@a,%h)> in void context are no longer evaluated at
+run time.  Even a whole sequence of C<our $foo;> statements will simply be
+skipped over.  The same applies to C<state> variables.
+
+=item *
+
+Many internal functions have been refactored to improve performance and reduce
+their memory footprints.
+
+L<[perl #121436]|https://rt.perl.org/Ticket/Display.html?id=121436>
+L<[perl #121906]|https://rt.perl.org/Ticket/Display.html?id=121906>
+L<[perl #121969]|https://rt.perl.org/Ticket/Display.html?id=121969>
+
+=item *
+
+C<-T> and C<-B> filetests will return sooner when an empty file is detected.
+
+L<perl #121489|https://rt.perl.org/Ticket/Display.html?id=121489>
+
+=item *
+
+Refactoring of C<< pp_tied >> and CC<< pp_ref >> for small improvements.
+
+=item *
+
+Pathtools don't try to load XS on miniperl.
+
+=item *
+
+A typo fix reduces the size of the C<< OP >> structure.
+
+=item *
+
+Hash lookups where the key is a constant is faster.
+
+=item *
+
+Subroutines with an empty prototype and bodies containing just C<undef> are now
+eligible for inlining.
+L<[perl #122728]|https://rt.perl.org/Ticket/Display.html?id=122728>
+
+=item *
+
+Subroutines in packages no longer need to carry typeglobs around with them.
+Declaring a subroutine will now put a simple sub reference in the stash if
+possible, saving memory.  The typeglobs still notionally exist, so accessing
+them will cause the subroutine reference to be upgraded to a typeglob.  This
+optimization does not currently apply to XSUBs or exported subroutines, and
+method calls will undo it, since they cache things in typeglobs.
+L<[perl #120441]|https://rt.perl.org/Ticket/Display.html?id=120441>
+
+=item *
+
+The functions C<utf8::native_to_unicode()> and C<utf8::unicode_to_native()>
+(see L<utf8>) are now optimized out on ASCII platforms.  There is now not even
+a minimal performance hit in writing code portable between ASCII and EBCDIC
+platforms.
+
+=item *
+
+Win32 Perl uses 8 KB less of per-process memory than before for every perl
+process of this version. This data is now memory mapped from disk and shared
+between perl processes from the same perl binary.
 
 =back
 
@@ -119,9 +687,7 @@ XXX
 
 =item *
 
-L<Module::CoreList> has been upgraded from version 5.20150420 to 5.20150520.
-
-Updated to cover the latest releases of Perl.
+L<XXX> has been upgraded from version A.xx to B.yy.
 
 =back
 
@@ -137,30 +703,303 @@ XXX
 
 =head1 Documentation
 
-XXX Changes to files in F<pod/> go here.  Consider grouping entries by
-file and be sure to link to the appropriate page, e.g. L<perlfunc>.
-
 =head2 New Documentation
 
-XXX Changes which create B<new> files in F<pod/> go here.
-
-=head3 L<XXX>
+=head3 L<perlunicook>
 
-XXX Description of the purpose of the new file here
+This document, by Tom Christiansen, provides examples of handling Unicode in
+Perl.
 
 =head2 Changes to Existing Documentation
 
-XXX Changes which significantly change existing files in F<pod/> go here.
-However, any changes to F<pod/perldiag.pod> should go in the L</Diagnostics>
-section.
+=head3 L<perlapi>
+
+=over 4
+
+=item *
+
+Note that C<SvSetSV> doesn't do set magic.
+
+=item *
+
+C<sv_usepvn_flags> - Fix documentation to mention the use of C<NewX> instead of
+C<malloc>.
+
+L<[perl #121869]|https://rt.perl.org/Ticket/Display.html?id=121869>
+
+=item *
+
+Clarify where C<NUL> may be embedded or is required to terminate a string.
+
+=item *
+
+Previously missing documentation due to formatting errors are now included.
+
+=item *
+
+Entries are now organized into groups rather than by file where they are found.
+
+=item *
+
+Alphabetical sorting of entries is now handled by the POD generator to make
+entries easier to find when scanning.
+
+=back
+
+=head3 L<perldata>
+
+=over 4
+
+=item *
+
+The syntax of single-character variable names has been brought
+up-to-date and more fully explained.
+
+=back
+
+=head3 L<perlebcdic>
+
+=over 4
+
+=item *
+
+This document has been significantly updated in the light of recent
+improvements to EBCDIC support.
+
+=back
+
+=head3 L<perlfunc>
+
+=over 4
+
+=item *
+
+Mention that C<study()> is currently a no-op.
+
+=item *
+
+Calling C<delete> or C<exists> on array values is now described as "strongly
+discouraged" rather than "deprecated".
+
+=item *
+
+Improve documentation of C<< our >>.
+
+=item *
+
+C<-l> now notes that it will return false if symlinks aren't supported by the
+file system.
+
+L<[perl #121523]|https://rt.perl.org/Ticket/Display.html?id=121523>
+
+=item *
+
+Note that C<exec LIST> and C<system LIST> may fall back to the shell on
+Win32. Only C<exec PROGRAM LIST> and C<system PROGRAM LIST> indirect object
+syntax will reliably avoid using the shell.
+
+This has also been noted in L<perlport>.
+
+L<[perl #122046]|https://rt.perl.org/Ticket/Display.html?id=122046>
+
+=back
+
+=head3 L<perlguts>
+
+=over 4
+
+=item *
+
+The OOK example has been updated to account for COW changes and a change in the
+storage of the offset.
+
+=item *
+
+Details on C level symbols and libperl.t added.
+
+=back
+
+=head3 L<perlhacktips>
+
+=over 4
+
+=item *
+
+Documentation has been added illustrating the perils of assuming the contents
+of static memory pointed to by the return values of Perl wrappers for C library
+functions doesn't change.
+
+=item *
+
+Recommended replacements for tmpfile, atoi, strtol, and strtoul added.
+
+=item *
+
+Updated documentation for the C<test.valgrind> C<make> target.
+
+L<[perl #121431]|https://rt.perl.org/Ticket/Display.html?id=121431>
+
+=back
+
+=head3 L<perlmodstyle>
+
+=over 4
+
+=item *
+
+Instead of pointing to the module list, we are now pointing to
+L<PrePAN|http://prepan.org/>.
+
+=back
+
+=head3 L<perlpolicy>
+
+=over 4
+
+=item *
+
+We now have a code of conduct for the I<< p5p >> mailing list, as documented
+in L<< perlpolicy/STANDARDS OF CONDUCT >>.
+
+=item *
 
-=head3 L<XXX>
+The conditions for marking an experimental feature as non-experimental are now
+set out.
+
+=back
+
+=head3 L<perlport>
 
 =over 4
 
 =item *
 
-XXX Description of the change here
+Out-of-date VMS-specific information has been fixed/simplified.
+
+=back
+
+=head3 L<perlre>
+
+=over 4
+
+=item *
+
+The C</x> modifier has been clarified to note that comments cannot be continued
+onto the next line by escaping them.
+
+=back
+
+=head3 L<perlrebackslash>
+
+=over 4
+
+=item *
+
+Added documentation of C<\b{sb}>, C<\b{wb}>, C<\b{gcb}>, and C<\b{g}>.
+
+=back
+
+=head3 L<perlrecharclass>
+
+=over 4
+
+=item *
+
+Clarifications have been added to L<perlrecharclass/Character Ranges>
+to the effect that Perl guarantees that C<[A-Z]>, C<[a-z]>, C<[0-9]> and
+any subranges thereof in regular expression bracketed character classes
+are guaranteed to match exactly what a naive English speaker would
+expect them to match, even on platforms (such as EBCDIC) where special
+handling is required to accomplish this.
+
+=item *
+
+The documentation of Bracketed Character Classes has been expanded to cover the
+improvements in C<qr/[\N{named sequence}]/> (see under L</Selected Bug Fixes>).
+
+=back
+
+=head3 L<perlsec>
+
+=over 4
+
+=item *
+
+Comments added on algorithmic complexity and tied hashes.
+
+=back
+
+=head3 L<perlsyn>
+
+=over 4
+
+=item *
+
+An ambiguity in the documentation of the C<...> statement has been corrected.
+L<[perl #122661]|https://rt.perl.org/Ticket/Display.html?id=122661>
+
+=item *
+
+The empty conditional in C<< for >> and C<< while >> is now documented
+in L<< perlsyn >>.
+
+=back
+
+=head3 L<perlunicode>
+
+=over 4
+
+=item *
+
+Update B<Default Word Boundaries> under
+L<perlunicode/"Unicode Regular Expression Support Level">'s
+B<Extended Unicode Support>.
+
+=back
+
+=head3 L<perluniintro>
+
+=over 4
+
+=item *
+
+Advice for how to make sure your strings and regular expression patterns are
+interpreted as Unicode has been revised to account for the new Perl 5.22 EBCDIC
+handling.
+
+=back
+
+=head3 L<perlvar>
+
+=over 4
+
+=item *
+
+Further clarify version number representations and usage.
+
+=back
+
+=head3 L<perlvms>
+
+=over 4
+
+=item *
+
+Out-of-date and/or incorrect material has been removed.
+
+=item *
+
+Updated documentation on environment and shell interaction in VMS.
+
+=back
+
+=head3 L<perlxs>
+
+=over 4
+
+=item *
+
+Added a discussion of locale issues in XS code.
 
 =back
 
@@ -170,21 +1009,157 @@ The following additions or changes have been made to diagnostic output,
 including warnings and fatal error messages.  For the complete list of
 diagnostic messages, see L<perldiag>.
 
-XXX New or changed warnings emitted by the core's C<C> code go here.  Also
-include any changes in L<perldiag> that reconcile it to the C<C> code.
-
 =head2 New Diagnostics
 
-XXX Newly added diagnostic messages go under here, separated into New Errors
-and New Warnings
-
 =head3 New Errors
 
 =over 4
 
 =item *
 
-XXX L<message|perldiag/"message">
+L<Bad symbol for scalar|perldiag/"Bad symbol for scalar">
+
+(P) An internal request asked to add a scalar entry to something that
+wasn't a symbol table entry.
+
+=item *
+
+L<Can't use a hash as a reference|perldiag/"Can't use a hash as a reference">
+
+(F) You tried to use a hash as a reference, as in
+C<< %foo->{"bar"} >> or C<< %$ref->{"hello"} >>.  Versions of perl E<lt>= 5.6.1
+used to allow this syntax, but shouldn't have.
+
+=item *
+
+L<Can't use an array as a reference|perldiag/"Can't use an array as a reference">
+
+(F) You tried to use an array as a reference, as in
+C<< @foo->[23] >> or C<< @$ref->[99] >>.  Versions of perl E<lt>= 5.6.1 used to
+allow this syntax, but shouldn't have.
+
+=item *
+
+L<Can't use 'defined(@array)' (Maybe you should just omit the defined()?)|perldiag/"Can't use 'defined(@array)' (Maybe you should just omit the defined()?)">
+
+(F) defined() is not useful on arrays because it
+checks for an undefined I<scalar> value.  If you want to see if the
+array is empty, just use C<if (@array) { # not empty }> for example.
+
+=item *
+
+L<Can't use 'defined(%hash)' (Maybe you should just omit the defined()?)|perldiag/"Can't use 'defined(%hash)' (Maybe you should just omit the defined()?)">
+
+(F) C<defined()> is not usually right on hashes.
+
+Although C<defined %hash> is false on a plain not-yet-used hash, it
+becomes true in several non-obvious circumstances, including iterators,
+weak references, stash names, even remaining true after C<undef %hash>.
+These things make C<defined %hash> fairly useless in practice, so it now
+generates a fatal error.
+
+If a check for non-empty is what you wanted then just put it in boolean
+context (see L<perldata/Scalar values>):
+
+    if (%hash) {
+       # not empty
+    }
+
+If you had C<defined %Foo::Bar::QUUX> to check whether such a package
+variable exists then that's never really been reliable, and isn't
+a good way to enquire about the features of a package, or whether
+it's loaded, etc.
+
+=item *
+
+L<Cannot chr %f|perldiag/"Cannot chr %f">
+
+=item *
+
+L<Cannot compress %f in pack|perldiag/"Cannot compress %f in pack">
+
+=item *
+
+L<Cannot pack %f with '%c'|perldiag/"Cannot pack %f with '%c'">
+
+=item *
+
+L<Cannot print %f with '%c'|perldiag/"Cannot printf %f with '%c'">
+
+=item *
+
+L<charnames alias definitions may not contain a sequence of multiple spaces|perldiag/"charnames alias definitions may not contain a sequence of multiple spaces">
+
+(F) You defined a character name which had multiple space
+characters in a row.  Change them to single spaces.  Usually these
+names are defined in the C<:alias> import argument to C<use charnames>, but
+they could be defined by a translator installed into C<$^H{charnames}>.
+See L<charnames/CUSTOM ALIASES>.
+
+=item *
+
+L<charnames alias definitions may not contain trailing white-space|perldiag/"charnames alias definitions may not contain trailing white-space">
+
+(F) You defined a character name which ended in a space
+character.  Remove the trailing space(s).  Usually these names are
+defined in the C<:alias> import argument to C<use charnames>, but they
+could be defined by a translator installed into C<$^H{charnames}>.
+See L<charnames/CUSTOM ALIASES>.
+
+=item *
+
+L<:const is not permitted on named subroutines|perldiag/":const is not permitted on named subroutines">
+
+(F) The "const" attribute causes an anonymous subroutine to be run and
+its value captured at the time that it is cloned.  Names subroutines are
+not cloned like this, so the attribute does not make sense on them.
+
+=item *
+
+L<Hexadecimal float: internal error|perldiag/"Hexadecimal float: internal error">
+
+(F) Something went horribly bad in hexadecimal float handling.
+
+=item *
+
+L<Hexadecimal float: unsupported long double format|perldiag/"Hexadecimal float: unsupported long double format">
+
+(F) You have configured Perl to use long doubles but
+the internals of the long double format are unknown,
+therefore the hexadecimal float output is impossible.
+
+=item *
+
+L<Illegal suidscript|perldiag/"Illegal suidscript">
+
+(F) The script run under suidperl was somehow illegal.
+
+=item *
+
+L<In '(?...)', the '(' and '?' must be adjacent in regex; marked by S<<-- HERE> in mE<sol>%sE<sol>|perldiag/"In '(?...)', the '(' and '?' must be adjacent in regex; marked by <-- HERE in m/%s/">
+
+(F) The two-character sequence C<"(?"> in
+this context in a regular expression pattern should be an
+indivisible token, with nothing intervening between the C<"(">
+and the C<"?">, but you separated them.
+
+=item *
+
+L<In '(*VERB...)', the '(' and '*' must be adjacent in regex; marked by S<<-- HERE> in mE<sol>%sE<sol>|perldiag/"In '(*VERB...)', the '(' and '*' must be adjacent in regex; marked by <-- HERE in m/%s/">
+
+(F) The two-character sequence C<"(*"> in
+this context in a regular expression pattern should be an
+indivisible token, with nothing intervening between the C<"(">
+and the C<"*">, but you separated them.
+
+=item *
+
+L<Invalid quantifier in {,} in regex; marked by <-- HERE in mE<sol>%sE<sol>|perldiag/"Invalid quantifier in {,} in regex; marked by <-- HERE in m/%s/">
+
+(F) The pattern looks like a {min,max} quantifier, but the min or max could not
+be parsed as a valid number - either it has leading zeroes, or it represents
+too big a number to cope with.  The S<<-- HERE> shows where in the regular
+expression the problem was discovered.  See L<perlre>.
 
 =back
 
@@ -194,193 +1169,2026 @@ XXX L<message|perldiag/"message">
 
 =item *
 
-XXX L<message|perldiag/"message">
+L<'%s' is an unknown bound type in regex|perldiag/"'%s' is an unknown bound type in regex; marked by <-- HERE in m/%s/">
+
+You used C<\b{...}> or C<\B{...}> and the C<...> is not known to
+Perl.  The current valid ones are given in
+L<perlrebackslash/\b{}, \b, \B{}, \B>.
+
+=item *
+
+L<"%s" is more clearly written simply as "%s" in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"%s" is more clearly written simply as "%s" in regex; marked by <-- HERE in mE<sol>%sE<sol>>
+
+(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>)
+
+You specified a character that has the given plainer way of writing it,
+and which is also portable to platforms running with different character
+sets.
+
+=item *
+
+L<Argument "%s" treated as 0 in increment (++)|perldiag/"Argument "%s" treated
+as 0 in increment (++)">
+
+(W numeric) The indicated string was fed as an argument to the C<++> operator
+which expects either a number or a string matching C</^[a-zA-Z]*[0-9]*\z/>.
+See L<perlop/Auto-increment and Auto-decrement> for details.
+
+=item *
+
+L<Both or neither range ends should be Unicode in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Both or neither range ends should be Unicode in regex; marked by <-- HERE in m/%s/">
+
+(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>)
+
+In a bracketed character class in a regular expression pattern, you
+had a range which has exactly one end of it specified using C<\N{}>, and
+the other end is specified using a non-portable mechanism.  Perl treats
+the range as a Unicode range, that is, all the characters in it are
+considered to be the Unicode characters, and which may be different code
+points on some platforms Perl runs on.  For example, C<[\N{U+06}-\x08]>
+is treated as if you had instead said C<[\N{U+06}-\N{U+08}]>, that is it
+matches the characters whose code points in Unicode are 6, 7, and 8.
+But that C<\x08> might indicate that you meant something different, so
+the warning gets raised.
+
+=item *
+
+L<Character in 'C' format overflow in pack|perldiag/"Character in 'C' format overflow in pack">
+
+(W pack) You tried converting an infinity or not-a-number to an unsigned
+character, which makes no sense.  Perl behaved as if you tried to pack 0xFF.
+
+=item *
+
+L<Character in 'c' format overflow in pack|perldiag/"Character in 'c' format overflow in pack">
+
+(W pack) You tried converting an infinity or not-a-number to a signed
+character, which makes no sense.  Perl behaved as if you tried to pack 0xFF.
+
+=item *
+
+L<:const is experimental|perldiag/":const is experimental">
+
+(S experimental::const_attr) The "const" attribute is experimental.
+If you want to use the feature, disable the warning with C<no warnings
+'experimental::const_attr'>, but know that in doing so you are taking
+the risk that your code may break in a future Perl version.
+
+=item *
+
+L<gmtime(%f) failed|perldiag/"gmtime(%f) failed">
+
+(W overflow) You called C<gmtime> with a number that it could not handle:
+too large, too small, or NaN.  The returned value is C<undef>.
+
+=item *
+
+L<Hexadecimal float: exponent overflow|perldiag/"Hexadecimal float: exponent overflow">
+
+(W overflow) The hexadecimal floating point has larger exponent
+than the floating point supports.
+
+=item *
+
+L<Hexadecimal float: exponent underflow|perldiag/"Hexadecimal float: exponent underflow">
+
+(W overflow) The hexadecimal floating point has smaller exponent
+than the floating point supports.
+
+=item *
+
+L<Hexadecimal float: mantissa overflow|perldiag/"Hexadecimal float: mantissa overflow">
+
+(W overflow) The hexadecimal floating point literal had more bits in
+the mantissa (the part between the 0x and the exponent, also known as
+the fraction or the significand) than the floating point supports.
+
+=item *
+
+L<Hexadecimal float: precision loss|perldiag/"Hexadecimal float: precision loss">
+
+(W overflow) The hexadecimal floating point had internally more
+digits than could be output.  This can be caused by unsupported
+long double formats, or by 64-bit integers not being available
+(needed to retrieve the digits under some configurations).
+
+L<Invalid number (%f) in chr|perldiag/"Invalid number (%f) in chr">
+
+(W utf8) You passed an invalid number (like an infinity or not-a-number) to
+C<chr>.  Those are not valid character numbers, so it returned the Unicode
+replacement character (U+FFFD).
+
+=item *
+
+L<localtime(%f) failed|perldiag/"localtime(%f) failed">
+
+(W overflow) You called C<localtime> with a number that it could not handle:
+too large, too small, or NaN.  The returned value is C<undef>.
+
+=item *
+
+L<Negative repeat count does nothing|perldiag/"Negative repeat count does nothing">
+
+(W numeric) You tried to execute the
+L<C<x>|perlop/Multiplicative Operators> repetition operator fewer than 0
+times, which doesn't make sense.
+
+=item *
+
+L<NO-BREAK SPACE in a charnames alias definition is deprecated|perldiag/"NO-BREAK SPACE in a charnames alias definition is deprecated">
+
+(D deprecated) You defined a character name which contained a no-break
+space character.  Change it to a regular space.  Usually these names are
+defined in the C<:alias> import argument to C<use charnames>, but they
+could be defined by a translator installed into C<$^H{charnames}>.  See
+L<charnames/CUSTOM ALIASES>.
+
+=item *
+
+L<Non-finite repeat count does nothing|perldiag/"Non-finite repeat count does nothing">
+
+(W numeric) You tried to execute the
+L<C<x>|perlop/Multiplicative Operators> repetition operator C<Inf> (or
+C<-Inf>) or C<NaN> times, which doesn't make sense.
+
+=item *
+
+L<PerlIO layer ':win32' is experimental|perldiag/"PerlIO layer ':win32' is experimental">
+
+(S experimental::win32_perlio) The C<:win32> PerlIO layer is
+experimental.  If you want to take the risk of using this layer,
+simply disable this warning:
+
+    no warnings "experimental::win32_perlio";
+
+=item *
+
+L<Ranges of ASCII printables should be some subset of "0-9", "A-Z", or "a-z" in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Ranges of ASCII printables should be some subset of "0-9", "A-Z", or "a-z" in regex; marked by <-- HERE in mE<sol>%sE<sol>">
+
+(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>)
+
+Stricter rules help to find typos and other errors.  Perhaps you didn't
+even intend a range here, if the C<"-"> was meant to be some other
+character, or should have been escaped (like C<"\-">).  If you did
+intend a range, the one that was used is not portable between ASCII and
+EBCDIC platforms, and doesn't have an obvious meaning to a casual
+reader.
+
+ [3-7]    # OK; Obvious and portable
+ [d-g]    # OK; Obvious and portable
+ [A-Y]    # OK; Obvious and portable
+ [A-z]    # WRONG; Not portable; not clear what is meant
+ [a-Z]    # WRONG; Not portable; not clear what is meant
+ [%-.]    # WRONG; Not portable; not clear what is meant
+ [\x41-Z] # WRONG; Not portable; not obvious to non-geek
+
+(You can force portability by specifying a Unicode range, which means that
+the endpoints are specified by
+L<C<\N{...}>|perlrecharclass/Character Ranges>, but the meaning may
+still not be obvious.)
+The stricter rules require that ranges that start or stop with an ASCII
+character that is not a control have all their endpoints be the literal
+character, and not some escape sequence (like C<"\x41">), and the ranges
+must be all digits, or all uppercase letters, or all lowercase letters.
+
+=item *
+
+L<Ranges of digits should be from the same group in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Ranges of digits should be from the same group in regex; marked by <-- HERE in m/%s/">
+
+(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>)
+
+Stricter rules help to find typos and other errors.  You included a
+range, and at least one of the end points is a decimal digit.  Under the
+stricter rules, when this happens, both end points should be digits in
+the same group of 10 consecutive digits.
+
+=item *
+
+L<Redundant argument in %s|perldiag/Redundant argument in %s>
+
+(W redundant) You called a function with more arguments than other
+arguments you supplied indicated would be needed. Currently only
+emitted when a printf-type format required fewer arguments than were
+supplied, but might be used in the future for e.g. L<perlfunc/pack>.
+
+The warnings category C<< redundant >> is new. See also [RT #121025]
+
+=item *
+
+L<Use of \b{} for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale|perldiag/"Use of \b{} for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale">
+
+You are matching a regular expression using locale rules,
+and a Unicode boundary is being matched, but the locale is not a Unicode
+one.  This doesn't make sense.  Perl will continue, assuming a Unicode
+(UTF-8) locale, but the results could well be wrong except if the locale
+happens to be ISO-8859-1 (Latin1) where this message is spurious and can
+be ignored.
+
+=item *
+
+L<< Using E<sol>u for '%s' instead of E<sol>%s in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Using E<sol>u for '%s' instead of E<sol>%s in regex; marked by <-- HERE in mE<sol>%sE<sol>" >>
+
+You used a Unicode boundary (C<\b{...}> or C<\B{...}>) in a
+portion of a regular expression where the character set modifiers C</a>
+or C</aa> are in effect.  These two modifiers indicate an ASCII
+interpretation, and this doesn't make sense for a Unicode definition.
+The generated regular expression will compile so that the boundary uses
+all of Unicode.  No other portion of the regular expression is affected.
+
+=item *
+
+L<The bitwise feature is experimental|perldiag/"The bitwise feature is experimental">
+
+This warning is emitted if you use bitwise
+operators (C<& | ^ ~ &. |. ^. ~.>) with the "bitwise" feature enabled.
+Simply suppress the warning if you want to use the feature, but know
+that in doing so you are taking the risk of using an experimental
+feature which may change or be removed in a future Perl version:
+
+    no warnings "experimental::bitwise";
+    use feature "bitwise";
+    $x |.= $y;
+
+=item *
+
+L<Unescaped left brace in regex is deprecated, passed through in regex; marked by <-- HERE in mE<sol>%sE<sol>|perldiag/"Unescaped left brace in regex is deprecated, passed through in regex; marked by <-- HERE in m/%s/">
+
+(D deprecated, regexp) You used a literal C<"{"> character in a regular
+expression pattern. You should change to use C<"\{"> instead, because a future
+version of Perl (tentatively v5.26) will consider this to be a syntax error.  If
+the pattern delimiters are also braces, any matching right brace
+(C<"}">) should also be escaped to avoid confusing the parser, for
+example,
+
+    qr{abc\{def\}ghi}
+
+=item *
+
+L<Use of literal non-graphic characters in variable names is deprecated|perldiag/"Use of literal non-graphic characters in variable names is deprecated">
+
+=item *
+
+L<Useless use of attribute "const"|perldiag/Useless use of attribute "const">
+
+(W misc) The "const" attribute has no effect except
+on anonymous closure prototypes.  You applied it to
+a subroutine via L<attributes.pm|attributes>.  This is only useful
+inside an attribute handler for an anonymous subroutine.
+
+=item *
+
+L<E<quot>use re 'strict'E<quot> is experimental|perldiag/"use re 'strict'" is experimental>
+
+(S experimental::re_strict) The things that are different when a regular
+expression pattern is compiled under C<'strict'> are subject to change
+in future Perl releases in incompatible ways.  This means that a pattern
+that compiles today may not in a future Perl release.  This warning is
+to alert you to that risk.
+
+=item *
+
+L<Warning: unable to close filehandle %s properly: %s|perldiag/"Warning: unable to close filehandle %s properly: %s">
+
+=item *
+
+L<Wide character (U+%X) in %s|perldiag/"Wide character (U+%X) in %s">
+
+(W locale) While in a single-byte locale (I<i.e.>, a non-UTF-8
+one), a multi-byte character was encountered.   Perl considers this
+character to be the specified Unicode code point.  Combining non-UTF8
+locales and Unicode is dangerous.  Almost certainly some characters
+will have two different representations.  For example, in the ISO 8859-7
+(Greek) locale, the code point 0xC3 represents a Capital Gamma.  But so
+also does 0x393.  This will make string comparisons unreliable.
+
+You likely need to figure out how this multi-byte character got mixed up
+with your single-byte locale (or perhaps you thought you had a UTF-8
+locale, but Perl disagrees).
+
+=item *
+
+The following two warnings for C<tr///> used to be skipped if the
+transliteration contained wide characters, but now they occur regardless of
+whether there are wide characters or not:
+
+L<Useless use of E<sol>d modifier in transliteration operator|perldiag/"Useless use of /d modifier in transliteration operator">
+
+L<Replacement list is longer than search list|perldiag/Replacement list is longer than search list>
+
+=item *
+
+A new C<locale> warning category has been created, with the following warning
+messages currently in it:
+
+=over 4
+
+=item *
+
+L<Locale '%s' may not work well.%s|perldiag/Locale '%s' may not work well.%s>
+
+=item *
+
+L<Can't do %s("%s") on non-UTF-8 locale; resolved to "%s".|perldiag/Can't do %s("%s") on non-UTF-8 locale; resolved to "%s".>
 
 =back
 
-=head2 Changes to Existing Diagnostics
+=back
 
-XXX Changes (i.e. rewording) of diagnostic messages go here
+=head2 Changes to Existing Diagnostics
 
 =over 4
 
 =item *
 
-XXX Describe change here
+<> should be quotes
+
+This warning has been changed to
+L<< <> at require-statement should be quotes|perldiag/"<> at require-statement should be quotes" >>
+to make the issue more identifiable.
+
+=item *
+
+L<Argument "%s" isn't numeric%s|perldiag/"Argument "%s" isn't numeric%s">
+now adds the following note:
+
+    Note that for the C<Inf> and C<NaN> (infinity and not-a-number) the
+    definition of "numeric" is somewhat unusual: the strings themselves
+    (like "Inf") are considered numeric, and anything following them is
+    considered non-numeric.
+
+=item *
+
+L<Global symbol "%s" requires explicit package name|perldiag/"Global symbol "%s" requires explicit package name (did you forget to declare "my %s"?)">
+
+This message has had '(did you forget to declare "my %s"?)' appended to it, to
+make it more helpful to new Perl programmers.
+L<[perl #121638]|https://rt.perl.org/Ticket/Display.html?id=121638>
+
+=item *
+
+'"my" variable &foo::bar can't be in a package' has been reworded to say
+'subroutine' instead of 'variable'.
+
+=item *
+
+L<\N{} in character class restricted to one character in regex; marked by S<<-- HERE> in mE<sol>%sE<sol>|perldiag/"\N{} in inverted character class or as a range end-point is restricted to one character in regex; marked by S<<-- HERE> in m/%s/">
+
+This message has had 'character class' changed to 'inverted character class or
+as a range end-point is' to reflect improvements in C<qr/[\N{named sequence}]/>
+(see under L</Selected Bug Fixes>).
+
+=item *
+
+L<panic: frexp|perldiag/"panic: frexp: %f">
+
+This message has had ': %f' appended to it, to show what the offending floating
+point number is.
+
+=item *
+
+B<Possible precedence problem on bitwise %c operator> reworded as
+L<Possible precedence problem on bitwise %s operator|perldiag/"Possible precedence problem on bitwise %s operator">.
+
+=item *
+
+C<require> with no argument or undef used to warn about a Null filename; now
+it dies with C<Missing or undefined argument to require>.
+
+=item *
+
+L<Unsuccessful %s on filename containing newline|perldiag/"Unsuccessful %s on filename containing newline">
+
+This warning is now only produced when the newline is at the end of
+the filename.
+
+=item *
+
+"Variable %s will not stay shared" has been changed to say "Subroutine"
+when it is actually a lexical sub that will not stay shared.
+
+=item *
+
+L<Variable length lookbehind not implemented in regex mE<sol>%sE<sol>|perldiag/"Variable length lookbehind not implemented in regex m/%s/">
+
+Information about Unicode behaviour has been added.
+
+=back
+
+=head2 Diagnostic Removals
+
+=over
+
+=item *
+
+"Ambiguous use of -foo resolved as -&foo()"
+
+There is actually no ambiguity here, and this impedes the use of negated
+constants; e.g., C<-Inf>.
+
+=item *
+
+"Constant is not a FOO reference"
+
+Compile-time checking of constant dereferencing (e.g., C<< my_constant->() >>)
+has been removed, since it was not taking overloading into account.
+L<[perl #69456]|https://rt.perl.org/Ticket/Display.html?id=69456>
+L<[perl #122607]|https://rt.perl.org/Ticket/Display.html?id=122607>
 
 =back
 
 =head1 Utility Changes
 
-XXX Changes to installed programs such as F<perlbug> and F<xsubpp> go here.
-Most of these are built within the directory F<utils>.
+=head2 F<x2p/>
 
-[ List utility changes as a =head2 entry for each utility and =item
-entries for each change
-Use L<XXX> with program names to get proper documentation linking. ]
+=over 4
+
+=item *
 
-=head2 L<XXX>
+The F<x2p/> directory has been removed from the Perl core.
+
+This removes find2perl, s2p and a2p. They have all been released to CPAN as
+separate distributions (App::find2perl, App::s2p, App::a2p).
+
+=back
+
+=head2 L<h2ph>
 
 =over 4
 
 =item *
 
-XXX
+F<h2ph> now handles hexadecimal constants in the compiler's predefined
+macro definitions, as visible in C<$Config{cppsymbols}>.  [rt.perl.org
+#123784]
 
 =back
 
-=head1 Configuration and Compilation
+=head2 L<encguess>
+
+=over 4
 
-XXX Changes to F<Configure>, F<installperl>, F<installman>, and analogous tools
-go here.  Any other changes to the Perl build process should be listed here.
-However, any platform-specific changes should be listed in the
-L</Platform Support> section, instead.
+=item *
+
+No longer depends on non-core module anymore.
+
+=back
 
-[ List changes as a =item entry ].
+=head1 Configuration and Compilation
 
 =over 4
 
 =item *
 
-XXX
+F<Configure> now checks for F<lrintl>, F<lroundl>, F<llrintl>, and F<llroundl>.
+
+=item *
+
+F<Configure> with C<-Dmksymlinks> should now be faster. [perl #122002]
+
+=item *
+
+pthreads and lcl will be linked by default if present. This allows XS modules
+that require threading to work on non-threaded perls. Note that you must still
+pass C<-Dusethreads> if you want a threaded perl.
+
+=item *
+
+For long doubles (to get more precision and range for floating point numbers)
+one can now use the GCC quadmath library which implements the quadruple
+precision floating point numbers in x86 and ia64 platforms.  See F<INSTALL> for
+details.
+
+=item *
+
+MurmurHash64A and MurmurHash64B can now be configured as the internal hash
+function.
+
+=item *
+
+C<make test.valgrind> now supports parallel testing.
+
+For example:
+
+    TEST_JOBS=9 make test.valgrind
+
+See L<perlhacktips/valgrind> for more information.
+
+L<[perl #121431]|https://rt.perl.org/Ticket/Display.html?id=121431>
+
+=item *
+
+The MAD (Misc Attribute Decoration) build option has been removed
+
+This was an unmaintained attempt at preserving
+the Perl parse tree more faithfully so that automatic conversion of
+Perl 5 to Perl 6 would have been easier.
+
+This build-time configuration option had been unmaintained for years,
+and had probably seriously diverged on both Perl 5 and Perl 6 sides.
+
+=item *
+
+A new compilation flag, C<< -DPERL_OP_PARENT >> is available. For details,
+see the discussion below at L<< /Internal Changes >>.
 
 =back
 
 =head1 Testing
 
-XXX Any significant changes to the testing of a freshly built perl should be
-listed here.  Changes which create B<new> files in F<t/> go here as do any
-large changes to the testing harness (e.g. when parallel testing was added).
-Changes to existing files in F<t/> aren't worth summarizing, although the bugs
-that they represent may be covered elsewhere.
+=over 4
 
-[ List each test improvement as a =item entry ]
+=item *
 
-=over 4
+F<t/porting/re_context.t> has been added to test that L<utf8> and its
+dependencies only use the subset of the C<$1..$n> capture vars that
+Perl_save_re_context() is hard-coded to localize, because that function has no
+efficient way of determining at runtime what vars to localize.
 
 =item *
 
-XXX
+Tests for performance issues have been added in the file F<t/perf/taint.t>.
+
+=item *
+
+Some regular expression tests are written in such a way that they will
+run very slowly if certain optimizations break. These tests have been
+moved into new files, F<< t/re/speed.t >> and F<< t/re/speed_thr.t >>,
+and are run with a C<< watchdog() >>.
+
+=item *
+
+C<< test.pl >> now allows C<< plan skip_all => $reason >>, to make it
+more compatible with C<< Test::More >>.
+
+=item *
+
+A new test script, F<op/infnan.t>, has been added to test if Inf and NaN are
+working correctly.  See L</Infinity and NaN (not-a-number) handling improved>.
 
 =back
 
 =head1 Platform Support
 
-XXX Any changes to platform support should be listed in the sections below.
+=head2 Regained Platforms
+
+=over 4
+
+=item IRIX and Tru64 platforms are working again.
 
-[ Within the sections, list each platform as a =item entry with specific
-changes as paragraphs below it. ]
+(Some C<make test> failures remain.)
 
-=head2 New Platforms
+=item z/OS running EBCDIC Code Page 1047
 
-XXX List any platforms that this version of perl compiles on, that previous
-versions did not.  These will either be enabled by new files in the F<hints/>
-directories, or new subdirectories and F<README> files at the top level of the
-source tree.
+Core perl now works on this EBCDIC platform.  Earlier perls also worked, but,
+even though support wasn't officially withdrawn, recent perls would not compile
+and run well.  Perl 5.20 would work, but had many bugs which have now been
+fixed.  Many CPAN modules that ship with Perl still fail tests, including
+Pod::Simple.  However the version of Pod::Simple currently on CPAN should work;
+it was fixed too late to include in Perl 5.22.  Work is under way to fix many
+of the still-broken CPAN modules, which likely will be installed on CPAN when
+completed, so that you may not have to wait until Perl 5.24 to get a working
+version.
+
+=back
+
+=head2 Discontinued Platforms
 
 =over 4
 
-=item XXX-some-platform
+=item NeXTSTEP/OPENSTEP
 
-XXX
+NeXTSTEP was proprietary OS bundled with NeXT's workstations in the early
+to mid 90's; OPENSTEP was an API specification that provided a NeXTSTEP-like
+environment on a non-NeXTSTEP system.  Both are now long dead, so support
+for building Perl on them has been removed.
 
 =back
 
-=head2 Discontinued Platforms
+=head2 Platform-Specific Notes
+
+=over 4
+
+=item EBCDIC
+
+Special handling is required on EBCDIC platforms to get C<qr/[i-j]/> to
+match only C<"i"> and C<"j">, since there are 7 characters between the
+code points for C<"i"> and C<"j">.  This special handling had only been
+invoked when both ends of the range are literals.  Now it is also
+invoked if any of the C<\N{...}> forms for specifying a character by
+name or Unicode code point is used instead of a literal.  See
+L<perlrecharclass/Character Ranges>.
 
-XXX List any platforms that this version of perl no longer compiles on.
+=item HP-UX
+
+The archname now distinguishes use64bitint from use64bitall.
+
+=item Android
+
+Build support has been improved for cross-compiling in general and for
+Android in particular.
+
+=item VMS
 
 =over 4
 
-=item XXX-some-platform
+=item *
+
+When spawning a subprocess without waiting, the return value is now
+the correct PID.
 
-XXX
+=item *
+
+Fix a prototype so linking doesn't fail under the VMS C++ compiler.
+
+=item *
+
+C<finite>, C<finitel>, and C<isfinite> detection has been added to
+C<configure.com>, environment handling has had some minor changes, and
+a fix for legacy feature checking status.
 
 =back
 
-=head2 Platform-Specific Notes
+=item Win32
+
+=over 4
+
+=item *
+
+F<miniperl.exe> is now built with C<-fno-strict-aliasing>, allowing 64-bit
+builds to complete on GCC 4.8.
+L<[perl #123976]|https://rt.perl.org/Ticket/Display.html?id=123976>
+
+=item *
+
+C<test-prep> again depends on C<test-prep-gcc> for GCC builds.
+L<[perl #124221]|https://rt.perl.org/Ticket/Display.html?id=124221>
+
+=item *
+
+Perl can now be built in C++ mode on Windows by setting the makefile macro
+C<USE_CPLUSPLUS> to the value "define".
+
+=item *
+
+List form pipe open no longer falls back to the shell.
+
+=item *
+
+In release 5.21.8 compiling on VC with dmake was broken. Fixed.
+
+=item *
+
+New C<DebugSymbols> and C<DebugFull> configuration options added to
+Windows makefiles.
+
+=item *
+
+L<B> now compiles again on Windows.
+
+=item *
+
+Previously, on Visual C++ for Win64 built Perls only, when compiling every Perl
+XS module (including CPAN ones) and Perl aware .c file with a 64 bit Visual C++,
+would unconditionally have around a dozen warnings from hv_func.h.  These
+warnings have been silenced.  GCC all bitness and Visual C++ for Win32 were
+not affected.
+
+=item *
+
+Support for building without PerlIO has been removed from the Windows
+makefiles.  Non-PerlIO builds were all but deprecated in Perl 5.18.0 and are
+already not supported by F<Configure> on POSIX systems.
+
+=item *
+
+Between 2 and 6 ms and 7 I/O calls have been saved per attempt to open a perl
+module for each path in C<@INC>.
+
+=item *
+
+Intel C builds are now always built with C99 mode on.
+
+=item *
+
+C<%I64d> is now being used instead of C<%lld> for MinGW.
+
+=item *
+
+In the experimental C<:win32> layer, a crash in C<open> was fixed. Also
+opening C</dev/null>, which works the Win32 Perl's normal C<:unix> layer, was
+implemented for C<:win32>.
+L<[perl #122224]|https://rt.perl.org/Ticket/Display.html?id=122224>
+
+=item *
+
+A new makefile option, C<USE_LONG_DOUBLE>, has been added to the Windows
+dmake makefile for gcc builds only.  Set this to "define" if you want perl to
+use long doubles to give more accuracy and range for floating point numbers.
+
+=back
 
-XXX List any changes for specific platforms.  This could include configuration
-and compilation changes or changes in portability/compatibility.  However,
-changes within modules for platforms should generally be listed in the
-L</Modules and Pragmata> section.
+=item OpenBSD
+
+On OpenBSD, Perl will now default to using the system C<malloc> due to the
+security features it provides. Perl's own malloc wrapper has been in use
+since v5.14 due to performance reasons, but the OpenBSD project believes
+the tradeoff is worth it and would prefer that users who need the speed
+specifically ask for it.
+
+L<[perl #122000]|https://rt.perl.org/Ticket/Display.html?id=122000>.
+
+=item Solaris
 
 =over 4
 
-=item XXX-some-platform
+=item *
 
-XXX
+We now look for the Sun Studio compiler in both F</opt/solstudio*> and
+F</opt/solarisstudio*>.
+
+=item *
+
+Builds on Solaris 10 with C<-Dusedtrace> would fail early since make
+didn't follow implied dependencies to build C<perldtrace.h>.  Added an
+explicit dependency to C<depend>.
+L<[perl #120120]|https://rt.perl.org/Ticket/Display.html?id=120120>
+
+=item *
+
+C<c99> options have been cleaned up, hints look for C<solstudio>
+as well as C<SUNWspro>, and support for native C<setenv> has been added.
+
+=back
 
 =back
 
 =head1 Internal Changes
 
-XXX Changes which affect the interface available to C<XS> code go here.  Other
-significant internal changes for future core maintainers should be noted as
-well.
+=over 4
+
+=item *
 
-[ List each change as a =item entry ]
+Perl 5.21.2 introduced a new build option, C<-DPERL_OP_PARENT>, which causes
+the last C<op_sibling> pointer to refer back to the parent rather than being
+C<NULL>, and where instead a new flag indicates the end of the chain.  In this
+release, the new implementation has been revised; in particular:
 
 =over 4
 
 =item *
 
-XXX
+On C<PERL_OP_PARENT> builds, the C<op_sibling> field has been renamed
+C<op_sibparent> to reflect its new dual purpose.  Since the intention is that
+this field should primarily be accessed via macros, this change should be
+transparent for code written to work under C<PERL_OP_PARENT>.
+
+=item *
+
+The newly-introduced C<op_lastsib> flag bit has been renamed C<op_moresib> and
+its logic inverted; i.e. it is initialised to zero in a new op, and is changed
+to 1 when an op gains a sibling.
+
+=item *
+
+The function C<Perl_op_parent> is now only available on C<PERL_OP_PARENT>
+builds.  Using it on a plain build will be a compile-timer error.
+
+=item *
+
+Three new macros, C<OpMORESIB_set>, C<OpLASTSIB_set>, C<OpMAYBESIB_set> have
+been added, which are intended to be a low-level portable way to set
+C<op_sibling> / C<op_sibparent> while also updating C<op_moresib>.  The first
+sets the sibling pointer to a new sibling, the second makes the op the last
+sibling, and the third conditionally does the first or second action.  The
+C<op_sibling_splice()> function is retained as a higher-level interface that
+can also maintain consistency in the parent at the same time (e.g. by updating
+C<op_first> and C<op_last> where appropriate).
+
+=item *
+
+The macro C<OpSIBLING_set>, added in Perl 5.21.2, has been removed.  It didn't
+manipulate C<op_moresib> and has been superseded by C<OpMORESIB_set> et al.
+
+=item *
+
+The C<op_sibling_splice> function now accepts a null C<parent> argument where
+the splicing doesn't affect the first or last ops in the sibling chain, and
+thus where the parent doesn't need to be updated accordingly.
 
 =back
 
-=head1 Selected Bug Fixes
+=item *
+
+Macros have been created to allow XS code to better manipulate the POSIX locale
+category C<LC_NUMERIC>.  See L<perlapi/Locale-related functions and macros>.
+
+=item *
+
+The previous C<atoi> et al replacement function, C<grok_atou>, has now been
+superseded by C<grok_atoUV>.  See L<perlclib> for details.
+
+=item *
+
+Added Perl_sv_get_backrefs() to determine if an SV is a weak-referent.
+
+Function either returns an SV * of type AV, which contains the set of
+weakreferences which reference the passed in SV, or a simple RV * which
+is the only weakref to this item.
+
+=item *
+
+C<screaminstr> has been removed. Although marked as public API, it is
+undocumented and has no usage in modern perl versions on CPAN Grep. Calling it
+has been fatal since 5.17.0.
+
+=item *
+
+C<newDEFSVOP>, C<block_start>, C<block_end> and C<intro_my> have been added
+to the API.
+
+=item *
+
+The internal C<convert> function in F<op.c> has been renamed
+C<op_convert_list> and added to the API.
+
+=item *
+
+C<sv_magic> no longer forbids "ext" magic on read-only values.  After all,
+perl can't know whether the custom magic will modify the SV or not.
+[perl #123103]
+
+=item *
+
+Starting in 5.21.6, accessing L<perlapi/CvPADLIST> in an XSUB is forbidden.
+CvPADLIST has be reused for a different internal purpose for XSUBs. Guard all
+CvPADLIST expressions with C<CvISXSUB()> if your code doesn't already block
+XSUB CV*s from going through optree CV* expecting code.
+
+=item *
+
+SVs of type SVt_NV are now bodyless when a build configure and platform allow
+it, specifically C<sizeof(NV) <= sizeof(IV)>. The bodyless trick is the same one
+as for IVs since 5.9.2, but for NVs, unlike IVs, is not guaranteed on all
+platforms and build configurations.
+
+=item *
+
+The C<$DB::single>, C<$DB::signal> and C<$DB::trace> now have set and
+get magic that stores their values as IVs and those IVs are used when
+testing their values in C<pp_dbstate>.  This prevents perl from
+recursing infinity if an overloaded object is assigned to any of those
+variables. [perl #122445]
+
+=item *
+
+C<Perl_tmps_grow> which is marked as public API but undocumented has been
+removed from public API. If you use C<EXTEND_MORTAL> macro in your XS code to
+preextend the mortal stack, you are unaffected by this change.
+
+=item *
+
+C<cv_name>, which was introduced in 5.21.4, has been changed incompatibly.
+It now has a flags field that allows the caller to specify whether the name
+should be fully qualified.  See L<perlapi/cv_name>.
+
+=item *
+
+Internally Perl no longer uses the C<SVs_PADMY> flag.  C<SvPADMY()> now
+returns a true value for anything not marked PADTMP.  C<SVs_PADMY> is now
+defined as 0.
+
+=item *
+
+The macros SETsv and SETsvUN have been removed. They were no longer used
+in the core since commit 6f1401dc2a, and have not been found present on
+CPAN.
+
+=item *
+
+The C<< SvFAKE >> bit (unused on HVs) got informally reserved by
+David Mitchell for future work on vtables.
+
+=item *
+
+The C<sv_catpvn_flags> function accepts C<SV_CATBYTES> and C<SV_CATUTF8>
+flags, which specify whether the appended string is bytes or utf8,
+respectively.
+
+=item *
+
+A new opcode class, C<< METHOP >> has been introduced, which holds
+class/method related info needed at runtime to improve performance
+of class/object method calls.
+
+C<< OP_METHOD >> and C<< OP_METHOD_NAMED >> are moved from being
+C<< UNOP/SVOP >> to being C<< METHOP >>.
+
+=item *
+
+C<save_re_context> no longer does anything and has been moved to F<mathoms.c>.
+
+=item *
+
+C<cv_name> is a new API function that can be passed a CV or GV.  It returns an
+SV containing the name of the subroutine for use in diagnostics.
+L<[perl #116735]|https://rt.perl.org/Ticket/Display.html?id=116735>
+L<[perl #120441]|https://rt.perl.org/Ticket/Display.html?id=120441>
+
+=item *
+
+C<cv_set_call_checker_flags> is a new API function that works like
+C<cv_set_call_checker>, except that it allows the caller to specify whether the
+call checker requires a full GV for reporting the subroutine's name, or whether
+it could be passed a CV instead.  Whatever value is passed will be acceptable
+to C<cv_name>.  C<cv_set_call_checker> guarantees there will be a GV, but it
+may have to create one on the fly, which is inefficient.
+L<[perl #116735]|https://rt.perl.org/Ticket/Display.html?id=116735>
+
+=item *
+
+C<CvGV> (which is not part of the API) is now a more complex macro, which may
+call a function and reify a GV.  For those cases where is has been used as a
+boolean, C<CvHASGV> has been added, which will return true for CVs that
+notionally have GVs, but without reifying the GV.  C<CvGV> also returns a GV
+now for lexical subs.
+L<[perl #120441]|https://rt.perl.org/Ticket/Display.html?id=120441>
+
+=item *
+
+Added L<perlapi/sync_locale>.  Changing the program's locale should be avoided
+by XS code.  Nevertheless, certain non-Perl libraries called from XS, such as
+C<Gtk> do so.  When this happens, Perl needs to be told that the locale has
+changed.  Use this function to do so, before returning to Perl.
+
+=item *
+
+The defines and labels for the flags in the C<op_private> field of OPs are now
+auto-generated from data in F<regen/op_private>.  The noticeable effect of this
+is that some of the flag output of C<Concise> might differ slightly, and the
+flag output of C<perl -Dx> may differ considerably (they both use the same set
+of labels now).  Also in debugging builds, there is a new assert in
+C<op_free()> that checks that the op doesn't have any unrecognized flags set in
+C<op_private>.
+
+=item *
+
+Added L<perlapi/sync_locale>.
+Changing the program's locale should be avoided by XS code.  Nevertheless,
+certain non-Perl libraries called from XS, such as C<Gtk> do so.  When this
+happens, Perl needs to be told that the locale has changed.  Use this function
+to do so, before returning to Perl.
+
+=item *
 
-XXX Important bug fixes in the core language are summarized here.  Bug fixes in
-files in F<ext/> and F<lib/> are best summarized in L</Modules and Pragmata>.
+The deprecated variable C<PL_sv_objcount> has been removed.
 
-[ List each fix as a =item entry ]
+=item *
+
+Perl now tries to keep the locale category C<LC_NUMERIC> set to "C"
+except around operations that need it to be set to the program's
+underlying locale.  This protects the many XS modules that cannot cope
+with the decimal radix character not being a dot.  Prior to this
+release, Perl initialized this category to "C", but a call to
+C<POSIX::setlocale()> would change it.  Now such a call will change the
+underlying locale of the C<LC_NUMERIC> category for the program, but the
+locale exposed to XS code will remain "C".  There is an API under
+development for those relatively few modules that need to use the
+underlying locale.  This API will be nailed down during the course of
+developing v5.21.  Send email to L<mailto:perl5-porters@perl.org> for
+guidance.
+
+=item *
+
+A new macro L<C<isUTF8_CHAR>|perlapi/isUTF8_CHAR> has been written which
+efficiently determines if the string given by its parameters begins
+with a well-formed UTF-8 encoded character.
+
+=item *
+
+The following private API functions had their context parameter removed,
+C<Perl_cast_ulong>,  C<Perl_cast_i32>, C<Perl_cast_iv>,    C<Perl_cast_uv>,
+C<Perl_cv_const_sv>, C<Perl_mg_find>,  C<Perl_mg_findext>, C<Perl_mg_magical>,
+C<Perl_mini_mktime>, C<Perl_my_dirfd>, C<Perl_sv_backoff>, C<Perl_utf8_hop>.
+
+Users of the public API prefix-less calls remain unaffected.
+
+=item *
+
+Experimental support for ops in the optree to be able to locate their
+parent, if any. A general-purpose function, C<< op_sibling_splice() >>
+allows for general manipulating an C<< op_sibling >> chain. The last op
+in such a chain is now marked with the field C<< op_lastsib >>.
+
+A new build define, C<< -DPERL_OP_PARENT >> has been added; if
+given, it forces the core to use C<< op_lastsib >> to detect the
+last sibling in a chain, freeing the last C<< op_sibling >> pointer,
+which then points back to the parent (instead of being C<< NULL >>).
+
+A C-level C<< op_parent() >> function, and a C<< B >> C<< parent() >> method
+have been added; under a default build, they return C<< NULL >>, but when
+C<< -DPERL_OP_PARENT >> has been set, they return the parent of the current op.
+
+=item *
+
+The PADNAME and PADNAMELIST types are now separate types, and no longer
+simply aliases for SV and AV.  [perl #123223]
+
+=item *
+
+Pad names are now always UTF8.  The C<PadnameUTF8> macro always returns
+true.  Previously, this was effectively the case already, but any support
+for two different internal representations of pad names has now been
+removed.
+
+=item *
+
+The C<OP_SIBLING> and C<OP_HAS_SIBLING> macros added in an earlier 5.21.x
+release have been renamed C<OpSIBLING> and C<OpHAS_SIBLING>, following the
+existing convention.
+
+=item *
+
+A new op class, C<UNOP_AUX>, has been added. This is a subclass of
+C<UNOP> with an C<op_aux> field added, which points to an array of unions
+of C<UV>, C<SV*> etc. It is intended for where an op needs to store more data
+than a simple C<op_sv> or whatever. Currently the only op of this type is
+C<OP_MULTIDEREF> (see below).
+
+=item *
+
+A new op has been added, C<OP_MULTIDEREF>, which performs one or more
+nested array and hash lookups where the key is a constant or simple
+variable. For example the expression C<$a[0]{$k}[$i]>, which previously
+involved ten C<rv2Xv>, C<Xelem>, C<gvsv> and C<const> ops is now performed
+by a single C<multideref> op. It can also handle C<local>, C<exists> and
+C<delete>. A non-simple index expression, such as C<[$i+1]> is still done
+using C<aelem/helem>, and single-level array lookup with a small constant
+index is still done using C<aelemfast>.
+
+=back
+
+=head1 Selected Bug Fixes
 
 =over 4
 
 =item *
 
-XXX
+C<pack("D", $x)> and C<pack("F", $x)> now zero the padding on x86 long double
+builds.  GCC 4.8 and later, under some build options, would either overwrite
+the zero-initialized padding, or bypass the initialized buffer entirely.  This
+caused F<op/pack.t> to fail.
+L<[perl #123971]|https://rt.perl.org/Ticket/Display.html?id=123971>
+
+=item *
+
+Extending an array cloned from a parent thread could result in "Modification of
+a read-only value attempted" errors when attempting to modify the new elements.
+L<[perl #124127]|https://rt.perl.org/Ticket/Display.html?id=124127>
+
+=item *
+
+An assertion failure and subsequent crash with C<< *x=<y> >> has been fixed.
+L<[perl #123790]|https://rt.perl.org/Ticket/Display.html?id=123790>
+
+=item *
+
+An optimization for state variable initialization introduced in Perl 5.21.6 has
+been reverted because it was found to exacerbate some other existing buggy
+behaviour.
+L<[perl #124160]|https://rt.perl.org/Ticket/Display.html?id=124160>
+
+=item *
+
+The extension of another optimization to cover more ops in Perl 5.21 has also
+been reverted to its Perl 5.20 state as a temporary fix for regression issues
+that it caused.
+L<[perl #123790]|https://rt.perl.org/Ticket/Display.html?id=123790>
+
+=item *
+
+New bitwise ops added in Perl 5.21.9 accidentally caused C<$^H |= 0x1c020000>
+to enable all features.  This has now been fixed.
+
+=item *
+
+A possible crashing/looping bug has been fixed.
+L<[perl #124099]|https://rt.perl.org/Ticket/Display.html?id=124099>
+
+=item *
+
+UTF-8 variable names used in array indexes, unquoted UTF-8 HERE-document
+terminators and UTF-8 function names all now work correctly.
+L<[perl #124113]|https://rt.perl.org/Ticket/Display.html?id=124113>
+
+=item *
+
+Repeated global pattern matches in scalar context on large tainted strings were
+exponentially slow depending on the current match position in the string.
+L<[perl #123202]|https://rt.perl.org/Ticket/Display.html?id=123202>
+
+=item *
+
+Various crashes due to the parser getting confused by syntax errors have been
+fixed.
+L<[perl #123801]|https://rt.perl.org/Ticket/Display.html?id=123801>
+L<[perl #123802]|https://rt.perl.org/Ticket/Display.html?id=123802>
+L<[perl #123955]|https://rt.perl.org/Ticket/Display.html?id=123955>
+L<[perl #123995]|https://rt.perl.org/Ticket/Display.html?id=123995>
+
+=item *
+
+C<split> in the scope of lexical $_ has been fixed not to fail assertions.
+L<[perl #123763]|https://rt.perl.org/Ticket/Display.html?id=123763>
+
+=item *
+
+C<my $x : attr> syntax inside various list operators no longer fails
+assertions.
+L<[perl #123817]|https://rt.perl.org/Ticket/Display.html?id=123817>
+
+=item *
+
+An @ sign in quotes followed by a non-ASCII digit (which is not a valid
+identifier) would cause the parser to crash, instead of simply trying the @ as
+literal.  This has been fixed.
+L<[perl #123963]|https://rt.perl.org/Ticket/Display.html?id=123963>
+
+=item *
+
+C<*bar::=*foo::=*glob_with_hash> has been crashing since Perl 5.14, but no
+longer does.
+L<[perl #123847]|https://rt.perl.org/Ticket/Display.html?id=123847>
+
+=item *
+
+C<foreach> in scalar context was not pushing an item on to the stack, resulting
+in bugs.  (C<print 4, scalar do { foreach(@x){} } + 1> would print 5.)  It has
+been fixed to return C<undef>.
+L<[perl #124004]|https://rt.perl.org/Ticket/Display.html?id=124004>
+
+=item *
+
+A memory leak introduced in Perl 5.21.6 has been fixed.
+L<[perl #123922]|https://rt.perl.org/Ticket/Display.html?id=123922>
+
+=item *
+
+A regression in the behaviour of the C<readline> built-in function, caused by
+the introduction of the C<< <<>> >> operator, has been fixed.
+L<[perl #123990]|https://rt.perl.org/Ticket/Display.html?id=123990>
+
+=item *
+
+Several cases of data used to store environment variable contents in core C
+code being potentially overwritten before being used have been fixed.
+L<[perl #123748]|https://rt.perl.org/Ticket/Display.html?id=123748>
+
+=item *
+
+Patterns starting with C</.*/> are now fast again. [rt.perl.org #123743]
+
+=item *
+
+The original visible value of C<$/> is now preserved when it is set to
+an invalid value.  Previously if you set C<$/> to a reference to an
+array, for example, perl would produce a runtime error and not set
+C<PL_rs>, but perl code that checked C<$/> would see the array
+reference.  [rt.perl.org #123218]
+
+=item *
+
+In a regular expression pattern, a POSIX class, like C<[:ascii:]>, must
+be inside a bracketed character class, like C</qr[[:ascii:]]>.  A
+warning is issued when something looking like a POSIX class is not
+inside a bracketed class.  That warning wasn't getting generated when
+the POSIX class was negated: C<[:^ascii:]>.  This is now fixed.
+
+=item *
+
+Fix a couple of other size calculation overflows.  [rt.perl.org #123554]
+
+=item *
+
+A bug introduced in 5.21.6, C<dump LABEL> acted the same as C<goto
+LABEL>.  This has been fixed.  [rt.perl.org #123836]
+
+=item *
+
+Perl 5.14.0 introduced a bug whereby C<eval { LABEL: }> would crash.  This
+has been fixed.  [rt.perl.org #123652]
+
+=item *
+
+Various crashes due to the parser getting confused by syntax errors have
+been fixed.  [rt.perl.org #123617] [rt.perl.org #123737]
+[rt.perl.org #123753] [rt.perl.org #123677]
+
+=item *
+
+Code like C</$a[/> used to read the next line of input and treat it as
+though it came immediately after the opening bracket.  Some invalid code
+consequently would parse and run, but some code caused crashes, so this is
+now disallowed.  [rt.perl.org #123712]
+
+=item *
+
+Fix argument underflow for C<pack>.  [rt.perl.org #123874]
+
+=item *
+
+Fix handling of non-strict C<\x{}>. Now C<\x{}> is equivalent to C<\x{0}>
+instead of faulting.
+
+=item *
+
+C<stat -t> is now no longer treated as stackable, just like C<-t stat>.
+[rt.perl.org #123816]
+
+=item *
+
+The following no longer causes a SEGV: C<qr{x+(y(?0))*}>.
+
+=item *
+
+Fixed infinite loop in parsing backrefs in regexp patterns.
+
+=item *
+
+Several minor bug fixes in behavior of Inf and NaN, including
+warnings when stringifying Inf-like or NaN-like strings. For example,
+"NaNcy" doesn't numify to NaN anymore.
+
+=item *
+
+Only stringy classnames are now shared. This fixes some failures in L<autobox>.  [rt.cpan.org #100819]
+
+=item *
+
+A bug in regular expression patterns that could lead to segfaults and
+other crashes has been fixed.  This occurred only in patterns compiled
+with C<"/i">, while taking into account the current POSIX locale (this usually
+means they have to be compiled within the scope of C<S<"use locale">>),
+and there must be a string of at least 128 consecutive bytes to match.
+[perl #123539]
+
+=item *
+
+C<s///> now works on very long strings instead of dying with 'Substitution
+loop'.  [perl #103260] [perl #123071]
+
+=item *
+
+C<gmtime> no longer crashes with not-a-number values.  [perl #123495]
+
+=item *
+
+C<\()> (reference to an empty list) and C<y///> with lexical $_ in scope
+could do a bad write past the end of the stack.  They have been fixed
+to extend the stack first.
+
+=item *
+
+C<prototype()> with no arguments used to read the previous item on the
+stack, so C<print "foo", prototype()> would print foo's prototype.  It has
+been fixed to infer $_ instead.  [perl #123514]
+
+=item *
+
+Some cases of lexical state subs inside predeclared subs could crash but no
+longer do.
+
+=item *
+
+Some cases of nested lexical state subs inside anonymous subs could cause
+'Bizarre copy' errors or possibly even crash.
+
+=item *
+
+When trying to emit warnings, perl's default debugger (F<perl5db.pl>) was
+sometimes giving 'Undefined subroutine &DB::db_warn called' instead.  This
+bug, which started to occur in Perl 5.18, has been fixed.  [perl #123553]
+
+=item *
+
+Certain syntax errors in substitutions, such as C<< s/${E<lt>E<gt>{})// >>, would
+crash, and had done so since Perl 5.10.  (In some cases the crash did not
+start happening till 5.16.)  The crash has, of course, been fixed.
+[perl #123542]
+
+=item *
+
+A repeat expression like C<33 x ~3> could cause a large buffer
+overflow since the new output buffer size was not correctly handled by
+SvGROW().  An expression like this now properly produces a memory wrap
+panic.  [perl 123554]
+
+=item *
+
+C<< formline("@...", "a"); >> would crash.  The C<FF_CHECKNL> case in
+pp_formline() didn't set the pointer used to mark the chop position,
+which led to the C<FF_MORE> case crashing with a segmentation fault.
+This has been fixed.  [perl #123538]
+
+=item *
+
+A possible buffer overrun and crash when parsing a literal pattern during
+regular expression compilation has been fixed.  [perl #123604]
+
+=item *
+
+fchmod() and futimes() now set C<$!> when they fail due to being
+passed a closed file handle.  [perl #122703]
+
+=item *
+
+Perl now comes with a corrected Unicode 7.0 for the erratum issued on
+October 21, 2014 (see L<http://www.unicode.org/errata/#current_errata>),
+dealing with glyph shaping in Arabic.
+
+=item *
+
+op_free() no longer crashes due to a stack overflow when freeing a
+deeply recursive op tree. [perl #108276]
+
+=item *
+
+scalarvoid() would crash due to a stack overflow when processing a
+deeply recursive op tree. [perl #108276]
+
+=item *
+
+In Perl 5.20.0, C<$^N> accidentally had the internal UTF8 flag turned off
+if accessed from a code block within a regular expression, effectively
+UTF8-encoding the value.  This has been fixed.  [perl #123135]
+
+=item *
+
+A failed C<semctl> call no longer overwrites existing items on the stack,
+causing C<(semctl(-1,0,0,0))[0]> to give an "uninitialized" warning.
+
+=item *
+
+C<else{foo()}> with no space before C<foo> is now better at assigning the
+right line number to that statement.  [perl #122695]
+
+=item *
+
+Sometimes the assignment in C<@array = split> gets optimised and C<split>
+itself writes directly to the array.  This caused a bug, preventing this
+assignment from being used in lvalue context.  So
+C<(@a=split//,"foo")=bar()> was an error.  (This bug probably goes back to
+Perl 3, when the optimisation was added.)  This optimisation, and the bug,
+started to happen in more cases in 5.21.5.  It has now been fixed.
+[perl #123057]
+
+=item *
+
+When argument lists that fail the checks installed by subroutine
+signatures, the resulting error messages now give the file and line number
+of the caller, not of the called subroutine.  [perl #121374]
+
+=item *
+
+Flip-flop operators (C<..> and C<...> in scalar context) used to maintain
+a separate state for each recursion level (the number of times the
+enclosing sub was called recursively), contrary to the documentation.  Now
+each closure has one internal state for each flip-flop.  [perl #122829]
+
+=item *
+
+C<use>, C<no>, statement labels, special blocks (C<BEGIN>) and pod are now
+permitted as the first thing in a C<map> or C<grep> block, the block after
+C<print> or C<say> (or other functions) returning a handle, and within
+C<${...}>, C<@{...}>, etc.  [perl #122782]
+
+=item *
+
+The repetition operator C<x> now propagates lvalue context to its left-hand
+argument when used in contexts like C<foreach>.  That allows
+C<for(($#that_array)x2) { ... }> to work as expected if the loop modifies
+$_.
+
+=item *
+
+C<(...) x ...> in scalar context used to corrupt the stack if one operand
+were an object with "x" overloading, causing erratic behaviour.
+[perl #121827]
+
+=item *
+
+Assignment to a lexical scalar is often optimised away (as mentioned under
+L</Performance Enhancements>).  Various bugs related to this optimisation
+have been fixed.  Certain operators on the right-hand side would sometimes
+fail to assign the value at all or assign the wrong value, or would call
+STORE twice or not at all on tied variables.  The operators affected were
+C<$foo++>, C<$foo-->, and C<-$foo> under C<use integer>, C<chomp>, C<chr>
+and C<setpgrp>.
+
+=item *
+
+List assignments were sometimes buggy if the same scalar ended up on both
+sides of the assignment due to used of C<tied>, C<values> or C<each>.  The
+result would be the wrong value getting assigned.
+
+=item *
+
+C<setpgrp($nonzero)> (with one argument) was accidentally changed in 5.16
+to mean C<setpgrp(0)>.  This has been fixed.
+
+=item *
+
+C<__SUB__> could return the wrong value or even corrupt memory under the
+debugger (the B<-d> switch) and in subs containing C<eval $string>.
+
+=item *
+
+When C<sub () { $var }> becomes inlinable, it now returns a different
+scalar each time, just as a non-inlinable sub would, though Perl still
+optimises the copy away in cases where it would make no observable
+difference.
+
+=item *
+
+C<my sub f () { $var }> and C<sub () : attr { $var }> are no longer
+eligible for inlining.  The former would crash; the latter would just
+throw the attributes away.  An exception is made for the little-known
+":method" attribute, which does nothing much.
+
+=item *
+
+Inlining of subs with an empty prototype is now more consistent than
+before.  Previously, a sub with multiple statements, all but the last
+optimised away, would be inlinable only if it were an anonymous sub
+containing a string C<eval> or C<state> declaration or closing over an
+outer lexical variable (or any anonymous sub under the debugger).  Now any
+sub that gets folded to a single constant after statements have been
+optimised away is eligible for inlining.  This applies to things like C<sub
+() { jabber() if DEBUG; 42 }>.
+
+Some subroutines with an explicit C<return> were being made inlinable,
+contrary to the documentation,  Now C<return> always prevents inlining.
+
+=item *
+
+On some systems, such as VMS, C<crypt> can return a non-ASCII string.  If a
+scalar assigned to had contained a UTF8 string previously, then C<crypt>
+would not turn off the UTF8 flag, thus corrupting the return value.  This
+would happen with C<$lexical = crypt ...>.
+
+=item *
+
+C<crypt> no longer calls C<FETCH> twice on a tied first argument.
+
+=item *
+
+An unterminated here-doc on the last line of a quote-like operator
+(C<qq[${ <<END }]>, C</(?{ <<END })/>) no longer causes a double free.  It
+started doing so in 5.18.
+
+=item *
+
+Fixed two assertion failures introduced into C<-DPERL_OP_PARENT>
+builds. [perl #108276]
+
+=item *
+
+index() and rindex() no longer crash when used on strings over 2GB in
+size.
+L<[perl #121562]|https://rt.perl.org/Ticket/Display.html?id=121562>.
+
+=item *
+
+A small previously intentional memory leak in PERL_SYS_INIT/PERL_SYS_INIT3 on
+Win32 builds was fixed. This might affect embedders who repeatedly create and
+destroy perl engines within the same process.
+
+=item *
+
+C<POSIX::localeconv()> now returns the data for the program's underlying
+locale even when called from outside the scope of S<C<use locale>>.
+
+=item *
+
+C<POSIX::localeconv()> now works properly on platforms which don't have
+C<LC_NUMERIC> and/or C<LC_MONETARY>, or for which Perl has been compiled
+to disregard either or both of these locale categories.  In such
+circumstances, there are now no entries for the corresponding values in
+the hash returned by C<localeconv()>.
+
+=item *
+
+C<POSIX::localeconv()> now marks appropriately the values it returns as
+UTF-8 or not.  Previously they were always returned as a bytes, even if
+they were supposed to be encoded as UTF-8.
+
+=item *
+
+On Microsoft Windows, within the scope of C<S<use locale>>, the following
+POSIX character classes gave results for many locales that did not
+conform to the POSIX standard:
+C<[[:alnum:]]>,
+C<[[:alpha:]]>,
+C<[[:blank:]]>,
+C<[[:digit:]]>,
+C<[[:graph:]]>,
+C<[[:lower:]]>,
+C<[[:print:]]>,
+C<[[:punct:]]>,
+C<[[:upper:]]>,
+C<[[:word:]]>,
+and
+C<[[:xdigit:]]>.
+These are because the underlying Microsoft implementation does not
+follow the standard.  Perl now takes special precautions to correct for
+this.
+
+=item *
+
+Many issues have been detected by L<Coverity|http://www.coverity.com/> and
+fixed.
+
+=item *
+
+system() and friends should now work properly on more Android builds.
+
+Due to an oversight, the value specified through -Dtargetsh to Configure
+would end up being ignored by some of the build process.  This caused perls
+cross-compiled for Android to end up with defective versions of system(),
+exec() and backticks: the commands would end up looking for C</bin/sh>
+instead of C</system/bin/sh>, and so would fail for the vast majority
+of devices, leaving C<$!> as C<ENOENT>.
+
+=item *
+
+C<qr(...\(...\)...)>,
+C<qr[...\[...\]...]>,
+and
+C<qr{...\{...\}...}>
+now work.  Previously it was impossible to escape these three
+left-characters with a backslash within a regular expression pattern
+where otherwise they would be considered metacharacters, and the pattern
+opening delimiter was the character, and the closing delimiter was its
+mirror character.
+
+=item *
+
+C<< s///e >> on tainted utf8 strings got C<< pos() >> messed up. This bug,
+introduced in 5.20, is now fixed. [RT #122148]
+
+=item *
+
+A non-word boundary in a regular expression (C<< \B >>) did not always
+match the end of the string; in particular C<< q{} =~ /\B/ >> did not
+match. This bug, introduced in perl 5.14, is now fixed. [RT #122090]
+
+=item *
+
+C<< " P" =~ /(?=.*P)P/ >> should match, but did not. This is now fixed.
+[RT #122171].
+
+=item *
+
+Failing to compile C<use Foo> in an eval could leave a spurious
+C<BEGIN> subroutine definition, which would produce a "Subroutine
+BEGIN redefined" warning on the next use of C<use>, or other C<BEGIN>
+block.  [perl #122107]
+
+=item *
+
+C<method { BLOCK } ARGS> syntax now correctly parses the arguments if they
+begin with an opening brace.  [perl #46947]
+
+=item *
+
+External libraries and Perl may have different ideas of what the locale is.
+This is problematic when parsing version strings if the locale's numeric
+separator has been changed.  Version parsing has been patched to ensure
+it handles the locales correctly.  [perl #121930]
+
+=item *
+
+A bug has been fixed where zero-length assertions and code blocks inside of a
+regex could cause C<pos> to see an incorrect value.  [perl #122460]
+
+=item *
+
+Constant dereferencing now works correctly for typeglob constants.  Previously
+the glob was stringified and its name looked up.  Now the glob itself is used.
+L<[perl #69456]|https://rt.perl.org/Ticket/Display.html?id=69456>
+
+=item *
+
+When parsing a funny character ($ @ % &) followed by braces, the parser no
+longer tries to guess whether it is a block or a hash constructor (causing a
+syntax error when it guesses the latter), since it can only be a block.
+
+=item *
+
+C<undef $reference> now frees the referent immediately, instead of hanging on
+to it until the next statement.
+L<[perl #122556]|https://rt.perl.org/Ticket/Display.html?id=122556>
+
+=item *
+
+Various cases where the name of a sub is used (autoload, overloading, error
+messages) used to crash for lexical subs, but have been fixed.
+
+=item *
+
+Bareword lookup now tries to avoid vivifying packages if it turns out the
+bareword is not going to be a subroutine name.
+
+=item *
+
+Compilation of anonymous constants (e.g., C<sub () { 3 }>) no longer deletes
+any subroutine named C<__ANON__> in the current package.  Not only was
+C<*__ANON__{CODE}> cleared, but there was a memory leak, too.  This bug goes
+back to Perl 5.8.0.
+
+=item *
+
+Stub declarations like C<sub f;> and C<sub f ();> no longer wipe out constants
+of the same name declared by C<use constant>.  This bug was introduced in Perl
+5.10.0.
+
+=item *
+
+Under some conditions a warning raised in compilation of regular expression
+patterns could be displayed multiple times.  This is now fixed.
+
+=item *
+
+C<qr/[\N{named sequence}]/> now works properly in many instances.  Some names
+known to C<\N{...}> refer to a sequence of multiple characters, instead of the
+usual single character.  Bracketed character classes generally only match
+single characters, but now special handling has been added so that they can
+match named sequences, but not if the class is inverted or the sequence is
+specified as the beginning or end of a range.  In these cases, the only
+behavior change from before is a slight rewording of the fatal error message
+given when this class is part of a C<?[...])> construct.  When the C<[...]>
+stands alone, the same non-fatal warning as before is raised, and only the
+first character in the sequence is used, again just as before.
+
+=item *
+
+Tainted constants evaluated at compile time no longer cause unrelated
+statements to become tainted.
+L<[perl #122669]|https://rt.perl.org/Ticket/Display.html?id=122669>
+
+=item *
+
+C<open $$fh, ...>, which vivifies a handle with a name like "main::_GEN_0", was
+not giving the handle the right reference count, so a double free could happen.
+
+=item *
+
+When deciding that a bareword was a method name, the parser would get confused
+if an "our" sub with the same name existed, and look up the method in the
+package of the "our" sub, instead of the package of the invocant.
+
+=item *
+
+The parser no longer gets confused by C<\U=> within a double-quoted string.  It
+used to produce a syntax error, but now compiles it correctly.
+L<[perl #80368]|https://rt.perl.org/Ticket/Display.html?id=80368>
+
+=item *
+
+It has always been the intention for the C<-B> and C<-T> file test operators to
+treat UTF-8 encoded files as text.  (L<perlfunc|perlfunc/-X FILEHANDLE> has
+been updated to say this.)  Previously, it was possible for some files to be
+considered UTF-8 that actually weren't valid UTF-8.  This is now fixed.  The
+operators now work on EBCDIC platforms as well.
+
+=item *
+
+Under some conditions warning messages raised during regular expression pattern
+compilation were being output more than once.  This has now been fixed.
+
+=item *
+
+A regression has been fixed that was introduced in Perl 5.20.0 (fixed in Perl
+5.20.1 as well as here) in which a UTF-8 encoded regular expression pattern
+that contains a single ASCII lowercase letter does not match its uppercase
+counterpart.
+L<[perl #122655]|https://rt.perl.org/Ticket/Display.html?id=122655>
+
+=item *
+
+Constant folding could incorrectly suppress warnings if lexical warnings (C<use
+warnings> or C<no warnings>) were not in effect and C<$^W> were false at
+compile time and true at run time.
+
+=item *
+
+Loading UTF8 tables during a regular expression match could cause assertion
+failures under debugging builds if the previous match used the very same
+regular expression.
+L<[perl #122747]|https://rt.perl.org/Ticket/Display.html?id=122747>
+
+=item *
+
+Thread cloning used to work incorrectly for lexical subs, possibly causing
+crashes or double frees on exit.
+
+=item *
+
+Since Perl 5.14.0, deleting C<$SomePackage::{__ANON__}> and then undefining an
+anonymous subroutine could corrupt things internally, resulting in
+L<Devel::Peek> crashing or L<B.pm|B> giving nonsensical data.  This has been
+fixed.
+
+=item *
+
+C<(caller $n)[3]> now reports names of lexical subs, instead of treating them
+as "(unknown)".
+
+=item *
+
+C<sort subname LIST> now supports lexical subs for the comparison routine.
+
+=item *
+
+Aliasing (e.g., via C<*x = *y>) could confuse list assignments that mention the
+two names for the same variable on either side, causing wrong values to be
+assigned.
+L<[perl #15667]|https://rt.perl.org/Ticket/Display.html?id=15667>
+
+=item *
+
+Long here-doc terminators could cause a bad read on short lines of input.  This
+has been fixed.  It is doubtful that any crash could have occurred.  This bug
+goes back to when here-docs were introduced in Perl 3.000 twenty-five years
+ago.
+
+=item *
+
+An optimization in C<split> to treat C<split/^/> like C<split/^/m> had the
+unfortunate side-effect of also treating C<split/\A/> like C<split/^/m>, which
+it should not.  This has been fixed.  (Note, however, that C<split/^x/> does
+not behave like C<split/^x/m>, which is also considered to be a bug and will be
+fixed in a future version.)
+L<[perl #122761]|https://rt.perl.org/Ticket/Display.html?id=122761>
+
+=item *
+
+The little-known C<my Class $var> syntax (see L<fields> and L<attributes>)
+could get confused in the scope of C<use utf8> if C<Class> were a constant
+whose value contained Latin-1 characters.
+
+=item *
+
+Locking and unlocking values via L<Hash::Util> or C<Internals::SvREADONLY>
+no longer has any effect on values that are read-only to begin.
+Previously, unlocking such values could result in crashes, hangs or
+other erratic behaviour.
+
+=item *
+
+The internal C<looks_like_number> function (which L<Scalar::Util> provides
+access to) began erroneously to return true for "-e1" in 5.21.4, affecting
+also C<-'-e1'>.  This has been fixed.
+
+=item *
+
+The flip-flop operator (C<..> in scalar context) would return the same
+scalar each time, unless the containing subroutine was called recursively.
+Now it always returns a new scalar.  [perl #122829]
+
+=item *
+
+Some unterminated C<(?(...)...)> constructs in regular expressions would
+either crash or give erroneous error messages.  C</(?(1)/> is one such
+example.
+
+=item *
+
+C<pack "w", $tied> no longer calls FETCH twice.
+
+=item *
+
+List assignments like C<($x, $z) = (1, $y)> now work correctly if $x and $y
+have been aliased by C<foreach>.
+
+=item *
+
+Some patterns including code blocks with syntax errors, such as
+C</ (?{(^{})/>, would hang or fail assertions on debugging builds.  Now
+they produce errors.
+
+=item *
+
+An assertion failure when parsing C<sort> with debugging enabled has been
+fixed.  [perl #122771]
+
+=item *
+
+C<*a = *b; @a = split //, $b[1]> could do a bad read and produce junk
+results.
+
+=item *
+
+In C<() = @array = split>, the C<() => at the beginning no longer confuses
+the optimizer, making it assume a limit of 1.
+
+=item *
+
+Fatal warnings no longer prevent the output of syntax errors.
+[perl #122966]
+
+=item *
+
+Fixed a NaN double to long double conversion error on VMS. For quiet NaNs
+(and only on Itanium, not Alpha) negative infinity instead of NaN was
+produced.
+
+=item *
+
+Fixed the issue that caused C<< make distclean >> to leave files behind
+that shouldn't. [perl #122820]
+
+=item *
+
+AIX now sets the length in C<< getsockopt >> correctly. [perl #120835],
+[rt #91183], [rt #85570].
+
+=item *
+
+During the pattern optimization phase, we no longer recurse into
+GOSUB/GOSTART when not SCF_DO_SUBSTR. This prevents the optimizer
+to run "forever" and exhaust all memory. [perl #122283]
+
+=item *
+
+F<< t/op/crypt.t >> now performs SHA-256 algorithm if the default one
+is disabled. [perl #121591]
+
+=item *
+
+Fixed an off-by-one error when setting the size of shared array.
+[perl #122950]
+
+=item *
+
+Fixed a bug that could cause perl to execute an infinite loop during
+compilation. [perl #122995]
+
+=item *
+
+On Win32, restoring in a child pseudo-process a variable that was
+C<local()>ed in a parent pseudo-process before the C<fork> happened caused
+memory corruption and a crash in the child pseudo-process (and therefore OS
+process).  [perl #40565]
+
+=item *
+
+Calling C<write> on a format with a C<^**> field could produce a panic
+in sv_chop() if there were insufficient arguments or if the variable
+used to fill the field was empty.  [perl #123245]
+
+=item *
+
+Non-ASCII lexical sub names (use in error messages) on longer have extra
+junk on the end.
+
+=item *
+
+The C<\@> subroutine prototype no longer flattens parenthesized arrays
+(taking a reference to each element), but takes a reference to the array
+itself.  [perl #47363]
+
+=item *
+
+A block containing nothing except a C-style C<for> loop could corrupt the
+stack, causing lists outside the block to lose elements or have elements
+overwritten.  This could happen with C<map { for(...){...} } ...> and with
+lists containing C<do { for(...){...} }>.  [perl #123286]
+
+=item *
+
+C<scalar()> now propagates lvalue context, so that
+C<for(scalar($#foo)) { ... }> can modify C<$#foo> through C<$_>.
+
+=item *
+
+C<qr/@array(?{block})/> no longer dies with "Bizarre copy of ARRAY".
+[#123344]
+
+=item *
+
+C<eval '$variable'> in nested named subroutines would sometimes look up a
+global variable even with a lexical variable in scope.
+
+=item *
+
+In perl 5.20.0, C<sort CORE::fake> where 'fake' is anything other than a
+keyword started chopping of the last 6 characters and treating the result
+as a sort sub name.  The previous behaviour of treating "CORE::fake" as a
+sort sub name has been restored.  [perl #123410]
+
+=item *
+
+Outside of C<use utf8>, a single-character Latin-1 lexical variable is
+disallowed.  The error message for it, "Can't use global $foo...", was
+giving garbage instead of the variable name.
+
+=item *
+
+C<readline> on a nonexistent handle was causing C<${^LAST_FH}> to produce a
+reference to an undefined scalar (or fail an assertion).  Now
+C<${^LAST_FH}> ends up undefined.
+
+=item *
+
+C<(...)x...> in void context now applies scalar context to the left-hand
+argument, instead of the context the current sub was called in.
+[perl #123020]
 
 =back
 
 =head1 Known Problems
 
-XXX Descriptions of platform agnostic bugs we know we can't fix go here.  Any
-tests that had to be C<TODO>ed for the release would be noted here.  Unfixed
-platform specific bugs also go here.
+=over 4
+
+=item *
+
+A goal is for Perl to be able to be recompiled to work reasonably well on any
+Unicode version.  In Perl 5.22, though, the earliest such version is Unicode
+5.1 (current is 7.0).
+
+=item *
 
-[ List each fix as a =item entry ]
+EBCDIC platforms
 
 =over 4
 
 =item *
 
-XXX
+Encode and encoding are mostly broken.
+
+=item *
+
+Many cpan modules that are shipped with core show failing tests.
+
+=item *
+
+C<pack>/C<unpack> with C<"U0"> format may not work properly.
 
 =back
 
-=head1 Errata From Previous Releases
+=item *
+
+The following modules are known to have test failures with this version of
+Perl.  Patches have been submitted, so there will hopefully be new releases
+soon:
 
-=over 4
+=over
 
 =item *
 
-XXX Add anything here that we forgot to add, or were mistaken about, in
-the perldelta of a previous release.
+L<B::Generate> version 1.50
 
-=back
+=item *
+
+L<B::Utils> version 0.25
+
+=item *
 
-=head1 Obituary
+L<Dancer> version 1.3130
 
-XXX If any significant core contributor has died, we've added a short obituary
-here.
+=item *
+
+L<Data::Alias> version 1.18
+
+=item *
+
+L<Data::Util> version 0.63
+
+=item *
+
+L<Lexical::Var> version 0.009
+
+=item *
+
+L<Mason> version 2.22
+
+=item *
+
+L<Padre> version 1.00
+
+=item *
+
+L<Parse::Keyword> 0.08
+
+=back
+
+=back
 
 =head1 Acknowledgements
 
 XXX Generate this with:
 
-  perl Porting/acknowledgements.pl v5.21.11..HEAD
+  perl Porting/acknowledgements.pl v5.20.0..HEAD
 
 =head1 Reporting Bugs
 
diff --git a/vms/descrip_mms.template b/vms/descrip_mms.template
index 6a29954873..4075dad447 100644
--- a/vms/descrip_mms.template
+++ b/vms/descrip_mms.template
@@ -307,7 +307,7 @@ utils : $(utils1) $(utils2) $(utils3) $(utils4) $(utils5)
 extra.pods : miniperl
 	@ @extra_pods.com
 
-PERLDELTA_CURRENT = [.pod]perl52112delta.pod
+PERLDELTA_CURRENT = [.pod]perl5220delta.pod
 
 $(PERLDELTA_CURRENT) : [.pod]perldelta.pod
 	Copy/NoConfirm/Log $(MMS$SOURCE) $(PERLDELTA_CURRENT)
diff --git a/win32/Makefile b/win32/Makefile
index b1332fd690..6d41e16757 100644
--- a/win32/Makefile
+++ b/win32/Makefile
@@ -1176,7 +1176,7 @@ utils: $(PERLEXE) ..\utils\Makefile
 	copy ..\README.tw       ..\pod\perltw.pod
 	copy ..\README.vos      ..\pod\perlvos.pod
 	copy ..\README.win32    ..\pod\perlwin32.pod
-	copy ..\pod\perldelta.pod ..\pod\perl52112delta.pod
+	copy ..\pod\perldelta.pod ..\pod\perl5220delta.pod
 	cd ..\win32
 	$(PERLEXE) $(PL2BAT) $(UTILS)
 	$(MINIPERL) -I..\lib ..\autodoc.pl ..
@@ -1272,7 +1272,7 @@ distclean: realclean
 	-if exist $(LIBDIR)\Win32API rmdir /s /q $(LIBDIR)\Win32API
 	-if exist $(LIBDIR)\XS rmdir /s /q $(LIBDIR)\XS
 	-cd $(PODDIR) && del /f *.html *.bat roffitall \
-	    perl52112delta.pod perlaix.pod perlamiga.pod perlandroid.pod \
+	    perl5220delta.pod perlaix.pod perlamiga.pod perlandroid.pod \
 	    perlapi.pod perlbs2000.pod perlce.pod perlcn.pod perlcygwin.pod \
 	    perldos.pod perlfreebsd.pod perlhaiku.pod perlhpux.pod \
 	    perlhurd.pod perlintern.pod perlirix.pod perljp.pod perlko.pod \
diff --git a/win32/makefile.mk b/win32/makefile.mk
index 8660835a30..8c4b2fee4a 100644
--- a/win32/makefile.mk
+++ b/win32/makefile.mk
@@ -1468,7 +1468,7 @@ utils: $(PERLEXE) ..\utils\Makefile
 	copy ..\README.tw       ..\pod\perltw.pod
 	copy ..\README.vos      ..\pod\perlvos.pod
 	copy ..\README.win32    ..\pod\perlwin32.pod
-	copy ..\pod\perldelta.pod ..\pod\perl52112delta.pod
+	copy ..\pod\perldelta.pod ..\pod\perl5220delta.pod
 	$(PERLEXE) $(PL2BAT) $(UTILS)
 	$(MINIPERL) -I..\lib ..\autodoc.pl ..
 	$(MINIPERL) -I..\lib ..\pod\perlmodlib.PL -q ..
@@ -1563,7 +1563,7 @@ distclean: realclean
 	-if exist $(LIBDIR)\Win32API rmdir /s /q $(LIBDIR)\Win32API
 	-if exist $(LIBDIR)\XS rmdir /s /q $(LIBDIR)\XS
 	-cd $(PODDIR) && del /f *.html *.bat roffitall \
-	    perl52112delta.pod perlaix.pod perlamiga.pod perlandroid.pod \
+	    perl5220delta.pod perlaix.pod perlamiga.pod perlandroid.pod \
 	    perlapi.pod perlbs2000.pod perlce.pod perlcn.pod perlcygwin.pod \
 	    perldos.pod perlfreebsd.pod perlhaiku.pod perlhpux.pod \
 	    perlhurd.pod perlintern.pod perlirix.pod perljp.pod perlko.pod \
diff --git a/win32/pod.mak b/win32/pod.mak
index 49f90598f0..07aa3e1893 100644
--- a/win32/pod.mak
+++ b/win32/pod.mak
@@ -42,7 +42,6 @@ POD = perl.pod	\
 	perl5210delta.pod	\
 	perl52110delta.pod	\
 	perl52111delta.pod	\
-	perl52112delta.pod	\
 	perl5211delta.pod	\
 	perl5212delta.pod	\
 	perl5213delta.pod	\
@@ -52,6 +51,7 @@ POD = perl.pod	\
 	perl5217delta.pod	\
 	perl5218delta.pod	\
 	perl5219delta.pod	\
+	perl5220delta.pod	\
 	perl561delta.pod	\
 	perl56delta.pod	\
 	perl581delta.pod	\
@@ -188,7 +188,6 @@ MAN = perl.man	\
 	perl5210delta.man	\
 	perl52110delta.man	\
 	perl52111delta.man	\
-	perl52112delta.man	\
 	perl5211delta.man	\
 	perl5212delta.man	\
 	perl5213delta.man	\
@@ -198,6 +197,7 @@ MAN = perl.man	\
 	perl5217delta.man	\
 	perl5218delta.man	\
 	perl5219delta.man	\
+	perl5220delta.man	\
 	perl561delta.man	\
 	perl56delta.man	\
 	perl581delta.man	\
@@ -334,7 +334,6 @@ HTML = perl.html	\
 	perl5210delta.html	\
 	perl52110delta.html	\
 	perl52111delta.html	\
-	perl52112delta.html	\
 	perl5211delta.html	\
 	perl5212delta.html	\
 	perl5213delta.html	\
@@ -344,6 +343,7 @@ HTML = perl.html	\
 	perl5217delta.html	\
 	perl5218delta.html	\
 	perl5219delta.html	\
+	perl5220delta.html	\
 	perl561delta.html	\
 	perl56delta.html	\
 	perl581delta.html	\
@@ -480,7 +480,6 @@ TEX = perl.tex	\
 	perl5210delta.tex	\
 	perl52110delta.tex	\
 	perl52111delta.tex	\
-	perl52112delta.tex	\
 	perl5211delta.tex	\
 	perl5212delta.tex	\
 	perl5213delta.tex	\
@@ -490,6 +489,7 @@ TEX = perl.tex	\
 	perl5217delta.tex	\
 	perl5218delta.tex	\
 	perl5219delta.tex	\
+	perl5220delta.tex	\
 	perl561delta.tex	\
 	perl56delta.tex	\
 	perl581delta.tex	\