This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
https://perl5.git.perl.org / perl5.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Extract _DB__handle_m_command.
[perl5.git] / dump.c
diff --git a/dump.c b/dump.c
index a83e17f..c74c003 100644 (file)
--- a/dump.c
+++ b/dump.c
@@ -1,7 +1,7 @@
 /*    dump.c
  *
 /*    dump.c
  *
- *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- *    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, by Larry Wall and others
+ *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+ *    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
  *
  *    You may distribute under the terms of either the GNU General Public
  *    License or the Artistic License, as specified in the README file.
  *
  *    You may distribute under the terms of either the GNU General Public
  *    License or the Artistic License, as specified in the README file.
@@ -9,8 +9,10 @@
  */
 
 /*
  */
 
 /*
- * "'You have talked long in your sleep, Frodo,' said Gandalf gently, 'and
- * it has not been hard for me to read your mind and memory.'"
+ *  'You have talked long in your sleep, Frodo,' said Gandalf gently, 'and
+ *   it has not been hard for me to read your mind and memory.'
+ *
+ *     [p.220 of _The Lord of the Rings_, II/i: "Many Meetings"]
  */
 
 /* This file contains utility routines to dump the contents of SV and OP
  */
 
 /* This file contains utility routines to dump the contents of SV and OP
@@ -32,11 +34,11 @@ static const char* const svtypenames[SVt_LAST] = {
     "BIND",
     "IV",
     "NV",
     "BIND",
     "IV",
     "NV",
-    "RV",
     "PV",
     "PVIV",
     "PVNV",
     "PVMG",
     "PV",
     "PVIV",
     "PVNV",
     "PVMG",
+    "REGEXP",
     "PVGV",
     "PVLV",
     "PVAV",
     "PVGV",
     "PVLV",
     "PVAV",
@@ -52,11 +54,11 @@ static const char* const svshorttypenames[SVt_LAST] = {
     "BIND",
     "IV",
     "NV",
     "BIND",
     "IV",
     "NV",
-    "RV",
     "PV",
     "PVIV",
     "PVNV",
     "PVMG",
     "PV",
     "PVIV",
     "PVNV",
     "PVMG",
+    "REGEXP",
     "GV",
     "PVLV",
     "AV",
     "GV",
     "PVLV",
     "AV",
@@ -66,12 +68,31 @@ static const char* const svshorttypenames[SVt_LAST] = {
     "IO"
 };
 
     "IO"
 };
 
-#define Sequence PL_op_sequence
+struct flag_to_name {
+    U32 flag;
+    const char *name;
+};
+
+static void
+S_append_flags(pTHX_ SV *sv, U32 flags, const struct flag_to_name *start,
+              const struct flag_to_name *const end)
+{
+    do {
+       if (flags & start->flag)
+           sv_catpv(sv, start->name);
+    } while (++start < end);
+}
+
+#define append_flags(sv, f, flags) \
+    S_append_flags(aTHX_ (sv), (f), (flags), C_ARRAY_END(flags))
+
+
 
 void
 Perl_dump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
 {
     va_list args;
 
 void
 Perl_dump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
 {
     va_list args;
+    PERL_ARGS_ASSERT_DUMP_INDENT;
     va_start(args, pat);
     dump_vindent(level, file, pat, &args);
     va_end(args);
     va_start(args, pat);
     dump_vindent(level, file, pat, &args);
     va_end(args);
@@ -81,6 +102,7 @@ void
 Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args)
 {
     dVAR;
 Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args)
 {
     dVAR;
+    PERL_ARGS_ASSERT_DUMP_VINDENT;
     PerlIO_printf(file, "%*s", (int)(level*PL_dumpindent), "");
     PerlIO_vprintf(file, pat, *args);
 }
     PerlIO_printf(file, "%*s", (int)(level*PL_dumpindent), "");
     PerlIO_vprintf(file, pat, *args);
 }
@@ -88,35 +110,51 @@ Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args)
 void
 Perl_dump_all(pTHX)
 {
 void
 Perl_dump_all(pTHX)
 {
+    dump_all_perl(FALSE);
+}
+
+void
+Perl_dump_all_perl(pTHX_ bool justperl)
+{
+
     dVAR;
     PerlIO_setlinebuf(Perl_debug_log);
     if (PL_main_root)
        op_dump(PL_main_root);
     dVAR;
     PerlIO_setlinebuf(Perl_debug_log);
     if (PL_main_root)
        op_dump(PL_main_root);
-    dump_packsubs(PL_defstash);
+    dump_packsubs_perl(PL_defstash, justperl);
 }
 
 void
 Perl_dump_packsubs(pTHX_ const HV *stash)
 {
 }
 
 void
 Perl_dump_packsubs(pTHX_ const HV *stash)
 {
+    PERL_ARGS_ASSERT_DUMP_PACKSUBS;
+    dump_packsubs_perl(stash, FALSE);
+}
+
+void
+Perl_dump_packsubs_perl(pTHX_ const HV *stash, bool justperl)
+{
     dVAR;
     I32        i;
 
     dVAR;
     I32        i;
 
+    PERL_ARGS_ASSERT_DUMP_PACKSUBS_PERL;
+
     if (!HvARRAY(stash))
        return;
     for (i = 0; i <= (I32) HvMAX(stash); i++) {
         const HE *entry;
        for (entry = HvARRAY(stash)[i]; entry; entry = HeNEXT(entry)) {
     if (!HvARRAY(stash))
        return;
     for (i = 0; i <= (I32) HvMAX(stash); i++) {
         const HE *entry;
        for (entry = HvARRAY(stash)[i]; entry; entry = HeNEXT(entry)) {
-           const GV * const gv = (GV*)HeVAL(entry);
+           const GV * const gv = (const GV *)HeVAL(entry);
            if (SvTYPE(gv) != SVt_PVGV || !GvGP(gv))
                continue;
            if (GvCVu(gv))
            if (SvTYPE(gv) != SVt_PVGV || !GvGP(gv))
                continue;
            if (GvCVu(gv))
-               dump_sub(gv);
+               dump_sub_perl(gv, justperl);
            if (GvFORM(gv))
                dump_form(gv);
            if (HeKEY(entry)[HeKLEN(entry)-1] == ':') {
                const HV * const hv = GvHV(gv);
                if (hv && (hv != PL_defstash))
            if (GvFORM(gv))
                dump_form(gv);
            if (HeKEY(entry)[HeKLEN(entry)-1] == ':') {
                const HV * const hv = GvHV(gv);
                if (hv && (hv != PL_defstash))
-                   dump_packsubs(hv);          /* nested package */
+                   dump_packsubs_perl(hv, justperl); /* nested package */
            }
        }
     }
            }
        }
     }
@@ -125,8 +163,21 @@ Perl_dump_packsubs(pTHX_ const HV *stash)
 void
 Perl_dump_sub(pTHX_ const GV *gv)
 {
 void
 Perl_dump_sub(pTHX_ const GV *gv)
 {
-    SV * const sv = sv_newmortal();
+    PERL_ARGS_ASSERT_DUMP_SUB;
+    dump_sub_perl(gv, FALSE);
+}
+
+void
+Perl_dump_sub_perl(pTHX_ const GV *gv, bool justperl)
+{
+    SV * sv;
+
+    PERL_ARGS_ASSERT_DUMP_SUB_PERL;
 
 
+    if (justperl && (CvISXSUB(GvCV(gv)) || !CvROOT(GvCV(gv))))
+       return;
+
+    sv = sv_newmortal();
     gv_fullname3(sv, gv, NULL);
     Perl_dump_indent(aTHX_ 0, Perl_debug_log, "\nSUB %s = ", SvPVX_const(sv));
     if (CvISXSUB(GvCV(gv)))
     gv_fullname3(sv, gv, NULL);
     Perl_dump_indent(aTHX_ 0, Perl_debug_log, "\nSUB %s = ", SvPVX_const(sv));
     if (CvISXSUB(GvCV(gv)))
@@ -144,6 +195,8 @@ Perl_dump_form(pTHX_ const GV *gv)
 {
     SV * const sv = sv_newmortal();
 
 {
     SV * const sv = sv_newmortal();
 
+    PERL_ARGS_ASSERT_DUMP_FORM;
+
     gv_fullname3(sv, gv, NULL);
     Perl_dump_indent(aTHX_ 0, Perl_debug_log, "\nFORMAT %s = ", SvPVX_const(sv));
     if (CvROOT(GvFORM(gv)))
     gv_fullname3(sv, gv, NULL);
     Perl_dump_indent(aTHX_ 0, Perl_debug_log, "\nFORMAT %s = ", SvPVX_const(sv));
     if (CvROOT(GvFORM(gv)))
@@ -161,9 +214,7 @@ Perl_dump_eval(pTHX)
 
 
 /*
 
 
 /*
-=for apidoc Apd|char*|pv_escape|NN SV *dsv|NN const char const *str\
-               |const STRLEN count|const STRLEN max
-               |STRLEN const *escaped, const U32 flags
+=for apidoc pv_escape
 
 Escapes at most the first "count" chars of pv and puts the results into
 dsv such that the size of the escaped string will not exceed "max" chars
 
 Escapes at most the first "count" chars of pv and puts the results into
 dsv such that the size of the escaped string will not exceed "max" chars
@@ -175,23 +226,23 @@ will also be escaped.
 Normally the SV will be cleared before the escaped string is prepared,
 but when PERL_PV_ESCAPE_NOCLEAR is set this will not occur.
 
 Normally the SV will be cleared before the escaped string is prepared,
 but when PERL_PV_ESCAPE_NOCLEAR is set this will not occur.
 
-If PERL_PV_ESCAPE_UNI is set then the input string is treated as unicode,
+If PERL_PV_ESCAPE_UNI is set then the input string is treated as Unicode,
 if PERL_PV_ESCAPE_UNI_DETECT is set then the input string is scanned
 if PERL_PV_ESCAPE_UNI_DETECT is set then the input string is scanned
-using C<is_utf8_string()> to determine if it is unicode.
+using C<is_utf8_string()> to determine if it is Unicode.
 
 If PERL_PV_ESCAPE_ALL is set then all input chars will be output
 
 If PERL_PV_ESCAPE_ALL is set then all input chars will be output
-using C<\x01F1> style escapes, otherwise only chars above 255 will be
-escaped using this style, other non printable chars will use octal or
-common escaped patterns like C<\n>. If PERL_PV_ESCAPE_NOBACKSLASH
-then all chars below 255 will be treated as printable and 
+using C<\x01F1> style escapes, otherwise if PERL_PV_ESCAPE_NONASCII is set, only
+chars above 127 will be escaped using this style; otherwise, only chars above
+255 will be so escaped; other non printable chars will use octal or
+common escaped patterns like C<\n>. Otherwise, if PERL_PV_ESCAPE_NOBACKSLASH
+then all chars below 255 will be treated as printable and
 will be output as literals.
 
 If PERL_PV_ESCAPE_FIRSTCHAR is set then only the first char of the
 will be output as literals.
 
 If PERL_PV_ESCAPE_FIRSTCHAR is set then only the first char of the
-string will be escaped, regardles of max. If the string is utf8 and 
-the chars value is >255 then it will be returned as a plain hex 
-sequence. Thus the output will either be a single char, 
-an octal escape sequence, a special escape like C<\n> or a 3 or 
-more digit hex value. 
+string will be escaped, regardless of max. If the output is to be in hex,
+then it will be returned as a plain hex
+sequence. Thus the output will either be a single char,
+an octal escape sequence, a special escape like C<\n> or a hex value.
 
 If PERL_PV_ESCAPE_RE is set then the escape char used will be a '%' and
 not a '\\'. This is because regexes very often contain backslashed
 
 If PERL_PV_ESCAPE_RE is set then the escape char used will be a '%' and
 not a '\\'. This is because regexes very often contain backslashed
@@ -214,22 +265,29 @@ Perl_pv_escape( pTHX_ SV *dsv, char const * const str,
     STRLEN wrote = 0;    /* chars written so far */
     STRLEN chsize = 0;   /* size of data to be written */
     STRLEN readsize = 1; /* size of data just read */
     STRLEN wrote = 0;    /* chars written so far */
     STRLEN chsize = 0;   /* size of data to be written */
     STRLEN readsize = 1; /* size of data just read */
-    bool isuni= flags & PERL_PV_ESCAPE_UNI ? 1 : 0; /* is this unicode */
+    bool isuni= flags & PERL_PV_ESCAPE_UNI ? 1 : 0; /* is this Unicode */
     const char *pv  = str;
     const char * const end = pv + count; /* end of string */
     octbuf[0] = esc;
 
     const char *pv  = str;
     const char * const end = pv + count; /* end of string */
     octbuf[0] = esc;
 
-    if (!flags & PERL_PV_ESCAPE_NOCLEAR) 
-           sv_setpvn(dsv, "", 0);
+    PERL_ARGS_ASSERT_PV_ESCAPE;
+
+    if (!(flags & PERL_PV_ESCAPE_NOCLEAR)) {
+           /* This won't alter the UTF-8 flag */
+           sv_setpvs(dsv, "");
+    }
     
     if ((flags & PERL_PV_ESCAPE_UNI_DETECT) && is_utf8_string((U8*)pv, count))
         isuni = 1;
     
     for ( ; (pv < end && (!max || (wrote < max))) ; pv += readsize ) {
     
     if ((flags & PERL_PV_ESCAPE_UNI_DETECT) && is_utf8_string((U8*)pv, count))
         isuni = 1;
     
     for ( ; (pv < end && (!max || (wrote < max))) ; pv += readsize ) {
-        const UV u= (isuni) ? utf8_to_uvchr((U8*)pv, &readsize) : (U8)*pv;            
+        const UV u= (isuni) ? utf8_to_uvchr_buf((U8*)pv, (U8*) end, &readsize) : (U8)*pv;
         const U8 c = (U8)u & 0xFF;
         
         const U8 c = (U8)u & 0xFF;
         
-        if ( ( u > 255 ) || (flags & PERL_PV_ESCAPE_ALL)) {
+        if ( ( u > 255 )
+         || (flags & PERL_PV_ESCAPE_ALL)
+         || (( u > 127 ) && (flags & PERL_PV_ESCAPE_NONASCII)))
+       {
             if (flags & PERL_PV_ESCAPE_FIRSTCHAR) 
                 chsize = my_snprintf( octbuf, PV_ESCAPE_OCTBUFSIZE, 
                                       "%"UVxf, u);
             if (flags & PERL_PV_ESCAPE_FIRSTCHAR) 
                 chsize = my_snprintf( octbuf, PV_ESCAPE_OCTBUFSIZE, 
                                       "%"UVxf, u);
@@ -262,7 +320,7 @@ Perl_pv_escape( pTHX_ SV *dsv, char const * const str,
                             chsize = 1;
                         break;
                default:
                             chsize = 1;
                         break;
                default:
-                        if ( (pv < end) && isDIGIT((U8)*(pv+readsize)) )
+                        if ( (pv+readsize < end) && isDIGIT((U8)*(pv+readsize)) )
                             chsize = my_snprintf( octbuf, PV_ESCAPE_OCTBUFSIZE, 
                                                   "%c%03o", esc, c);
                        else
                             chsize = my_snprintf( octbuf, PV_ESCAPE_OCTBUFSIZE, 
                                                   "%c%03o", esc, c);
                        else
@@ -279,6 +337,12 @@ Perl_pv_escape( pTHX_ SV *dsv, char const * const str,
             sv_catpvn(dsv, octbuf, chsize);
             wrote += chsize;
        } else {
             sv_catpvn(dsv, octbuf, chsize);
             wrote += chsize;
        } else {
+           /* If PERL_PV_ESCAPE_NOBACKSLASH is set then bytes in the range
+              128-255 can be appended raw to the dsv. If dsv happens to be
+              UTF-8 then we need catpvf to upgrade them for us.
+              Or add a new API call sv_catpvc(). Think about that name, and
+              how to keep it clear that it's unlike the s of catpvs, which is
+              really an array octets, not a string.  */
             Perl_sv_catpvf( aTHX_ dsv, "%c", c);
            wrote++;
        }
             Perl_sv_catpvf( aTHX_ dsv, "%c", c);
            wrote++;
        }
@@ -290,30 +354,27 @@ Perl_pv_escape( pTHX_ SV *dsv, char const * const str,
     return SvPVX(dsv);
 }
 /*
     return SvPVX(dsv);
 }
 /*
-=for apidoc Apd|char *|pv_pretty|NN SV *dsv|NN const char const *str\
-           |const STRLEN count|const STRLEN max\
-           |const char const *start_color| const char const *end_color\
-           |const U32 flags
+=for apidoc pv_pretty
 
 Converts a string into something presentable, handling escaping via
 
 Converts a string into something presentable, handling escaping via
-pv_escape() and supporting quoting and elipses. 
+pv_escape() and supporting quoting and ellipses.
 
 If the PERL_PV_PRETTY_QUOTE flag is set then the result will be 
 double quoted with any double quotes in the string escaped. Otherwise
 if the PERL_PV_PRETTY_LTGT flag is set then the result be wrapped in
 angle brackets. 
 
 If the PERL_PV_PRETTY_QUOTE flag is set then the result will be 
 double quoted with any double quotes in the string escaped. Otherwise
 if the PERL_PV_PRETTY_LTGT flag is set then the result be wrapped in
 angle brackets. 
-           
-If the PERL_PV_PRETTY_ELIPSES flag is set and not all characters in
-string were output then an elipses C<...> will be appended to the 
+
+If the PERL_PV_PRETTY_ELLIPSES flag is set and not all characters in
+string were output then an ellipsis C<...> will be appended to the
 string. Note that this happens AFTER it has been quoted.
 string. Note that this happens AFTER it has been quoted.
-           
+
 If start_color is non-null then it will be inserted after the opening
 quote (if there is one) but before the escaped text. If end_color
 is non-null then it will be inserted after the escaped text but before
 If start_color is non-null then it will be inserted after the opening
 quote (if there is one) but before the escaped text. If end_color
 is non-null then it will be inserted after the escaped text but before
-any quotes or elipses.
+any quotes or ellipses.
 
 Returns a pointer to the prettified text as held by dsv.
 
 Returns a pointer to the prettified text as held by dsv.
-           
+
 =cut           
 */
 
 =cut           
 */
 
@@ -324,29 +385,34 @@ Perl_pv_pretty( pTHX_ SV *dsv, char const * const str, const STRLEN count,
 {
     const U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%';
     STRLEN escaped;
 {
     const U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%';
     STRLEN escaped;
-    
+ 
+    PERL_ARGS_ASSERT_PV_PRETTY;
+   
+    if (!(flags & PERL_PV_PRETTY_NOCLEAR)) {
+           /* This won't alter the UTF-8 flag */
+           sv_setpvs(dsv, "");
+    }
+
     if ( dq == '"' )
     if ( dq == '"' )
-        sv_setpvn(dsv, "\"", 1);
+        sv_catpvs(dsv, "\"");
     else if ( flags & PERL_PV_PRETTY_LTGT )
     else if ( flags & PERL_PV_PRETTY_LTGT )
-        sv_setpvn(dsv, "<", 1);
-    else 
-        sv_setpvn(dsv, "", 0);
+        sv_catpvs(dsv, "<");
         
     if ( start_color != NULL ) 
         
     if ( start_color != NULL ) 
-        Perl_sv_catpv( aTHX_ dsv, start_color);
+        sv_catpv(dsv, start_color);
     
     pv_escape( dsv, str, count, max, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR );    
     
     if ( end_color != NULL ) 
     
     pv_escape( dsv, str, count, max, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR );    
     
     if ( end_color != NULL ) 
-        Perl_sv_catpv( aTHX_ dsv, end_color);
+        sv_catpv(dsv, end_color);
 
     if ( dq == '"' ) 
 
     if ( dq == '"' ) 
-       sv_catpvn( dsv, "\"", 1 );
+       sv_catpvs( dsv, "\"");
     else if ( flags & PERL_PV_PRETTY_LTGT )
     else if ( flags & PERL_PV_PRETTY_LTGT )
-        sv_catpvn( dsv, ">", 1);         
+        sv_catpvs(dsv, ">");         
     
     
-    if ( (flags & PERL_PV_PRETTY_ELIPSES) && ( escaped < count ) )
-           sv_catpvn( dsv, "...", 3 );
+    if ( (flags & PERL_PV_PRETTY_ELLIPSES) && ( escaped < count ) )
+           sv_catpvs(dsv, "...");
  
     return SvPVX(dsv);
 }
  
     return SvPVX(dsv);
 }
@@ -354,9 +420,6 @@ Perl_pv_pretty( pTHX_ SV *dsv, char const * const str, const STRLEN count,
 /*
 =for apidoc pv_display
 
 /*
 =for apidoc pv_display
 
-  char *pv_display(SV *dsv, const char *pv, STRLEN cur, STRLEN len,
-                   STRLEN pvlim, U32 flags)
-
 Similar to
 
   pv_escape(dsv,pv,cur,pvlim,PERL_PV_ESCAPE_QUOTE);
 Similar to
 
   pv_escape(dsv,pv,cur,pvlim,PERL_PV_ESCAPE_QUOTE);
@@ -372,9 +435,11 @@ Note that the final string may be up to 7 chars longer than pvlim.
 char *
 Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)
 {
 char *
 Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)
 {
+    PERL_ARGS_ASSERT_PV_DISPLAY;
+
     pv_pretty( dsv, pv, cur, pvlim, NULL, NULL, PERL_PV_PRETTY_DUMP);
     if (len > cur && pv[cur] == '\0')
     pv_pretty( dsv, pv, cur, pvlim, NULL, NULL, PERL_PV_PRETTY_DUMP);
     if (len > cur && pv[cur] == '\0')
-            sv_catpvn( dsv, "\\0", 2 );
+            sv_catpvs( dsv, "\\0");
     return SvPVX(dsv);
 }
 
     return SvPVX(dsv);
 }
 
@@ -386,13 +451,13 @@ Perl_sv_peek(pTHX_ SV *sv)
     int unref = 0;
     U32 type;
 
     int unref = 0;
     U32 type;
 
-    sv_setpvn(t, "", 0);
+    sv_setpvs(t, "");
   retry:
     if (!sv) {
        sv_catpv(t, "VOID");
        goto finish;
     }
   retry:
     if (!sv) {
        sv_catpv(t, "VOID");
        goto finish;
     }
-    else if (sv == (SV*)0x55555555 || SvTYPE(sv) == 'U') {
+    else if (sv == (const SV *)0x55555555 || SvTYPE(sv) == 'U') {
        sv_catpv(t, "WILD");
        goto finish;
     }
        sv_catpv(t, "WILD");
        goto finish;
     }
@@ -463,7 +528,7 @@ Perl_sv_peek(pTHX_ SV *sv)
            sv_catpv(t, "...");
            goto finish;
        }
            sv_catpv(t, "...");
            goto finish;
        }
-       sv = (SV*)SvRV(sv);
+       sv = SvRV(sv);
        goto retry;
     }
     type = SvTYPE(sv);
        goto retry;
     }
     type = SvTYPE(sv);
@@ -486,12 +551,15 @@ Perl_sv_peek(pTHX_ SV *sv)
        else {
            SV * const tmp = newSVpvs("");
            sv_catpv(t, "(");
        else {
            SV * const tmp = newSVpvs("");
            sv_catpv(t, "(");
-           if (SvOOK(sv))
-               Perl_sv_catpvf(aTHX_ t, "[%s]", pv_display(tmp, SvPVX_const(sv)-SvIVX(sv), SvIVX(sv), 0, 127));
+           if (SvOOK(sv)) {
+               STRLEN delta;
+               SvOOK_offset(sv, delta);
+               Perl_sv_catpvf(aTHX_ t, "[%s]", pv_display(tmp, SvPVX_const(sv)-delta, delta, 0, 127));
+           }
            Perl_sv_catpvf(aTHX_ t, "%s)", pv_display(tmp, SvPVX_const(sv), SvCUR(sv), SvLEN(sv), 127));
            if (SvUTF8(sv))
                Perl_sv_catpvf(aTHX_ t, " [UTF8 \"%s\"]",
            Perl_sv_catpvf(aTHX_ t, "%s)", pv_display(tmp, SvPVX_const(sv), SvCUR(sv), SvLEN(sv), 127));
            if (SvUTF8(sv))
                Perl_sv_catpvf(aTHX_ t, " [UTF8 \"%s\"]",
-                              sv_uni_display(tmp, sv, 8 * sv_len_utf8(sv),
+                              sv_uni_display(tmp, sv, 6 * SvCUR(sv),
                                              UNI_DISPLAY_QQ));
            SvREFCNT_dec(tmp);
        }
                                              UNI_DISPLAY_QQ));
            SvREFCNT_dec(tmp);
        }
@@ -513,6 +581,8 @@ Perl_sv_peek(pTHX_ SV *sv)
   finish:
     while (unref--)
        sv_catpv(t, ")");
   finish:
     while (unref--)
        sv_catpv(t, ")");
+    if (TAINTING_get && SvTAINTED(sv))
+       sv_catpv(t, " [tainted]");
     return SvPV_nolen(t);
 }
 
     return SvPV_nolen(t);
 }
 
@@ -521,6 +591,8 @@ Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm)
 {
     char ch;
 
 {
     char ch;
 
+    PERL_ARGS_ASSERT_DO_PMOP_DUMP;
+
     if (!pm) {
        Perl_dump_indent(aTHX_ level, file, "{}\n");
        return;
     if (!pm) {
        Perl_dump_indent(aTHX_ level, file, "{}\n");
        return;
@@ -533,7 +605,7 @@ Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm)
        ch = '/';
     if (PM_GETRE(pm))
        Perl_dump_indent(aTHX_ level, file, "PMf_PRE %c%s%c%s\n",
        ch = '/';
     if (PM_GETRE(pm))
        Perl_dump_indent(aTHX_ level, file, "PMf_PRE %c%s%c%s\n",
-            ch, PM_GETRE(pm)->precomp, ch,
+            ch, RX_PRECOMP(PM_GETRE(pm)), ch,
             (pm->op_private & OPpRUNTIME) ? " (RUNTIME)" : "");
     else
        Perl_dump_indent(aTHX_ level, file, "PMf_PRE (RUNTIME)\n");
             (pm->op_private & OPpRUNTIME) ? " (RUNTIME)" : "");
     else
        Perl_dump_indent(aTHX_ level, file, "PMf_PRE (RUNTIME)\n");
@@ -541,7 +613,16 @@ Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm)
        Perl_dump_indent(aTHX_ level, file, "PMf_REPL = ");
        op_dump(pm->op_pmreplrootu.op_pmreplroot);
     }
        Perl_dump_indent(aTHX_ level, file, "PMf_REPL = ");
        op_dump(pm->op_pmreplrootu.op_pmreplroot);
     }
-    if (pm->op_pmflags || (PM_GETRE(pm) && PM_GETRE(pm)->check_substr)) {
+    if (pm->op_code_list) {
+       if (pm->op_pmflags & PMf_CODELIST_PRIVATE) {
+           Perl_dump_indent(aTHX_ level, file, "CODE_LIST =\n");
+           do_op_dump(level, file, pm->op_code_list);
+       }
+       else
+           Perl_dump_indent(aTHX_ level, file, "CODE_LIST = 0x%"UVxf"\n",
+                                   PTR2UV(pm->op_code_list));
+    }
+    if (pm->op_pmflags || (PM_GETRE(pm) && RX_CHECK_SUBSTR(PM_GETRE(pm)))) {
        SV * const tmpsv = pm_description(pm);
        Perl_dump_indent(aTHX_ level, file, "PMFLAGS = (%s)\n", SvCUR(tmpsv) ? SvPVX_const(tmpsv) + 1 : "");
        SvREFCNT_dec(tmpsv);
        SV * const tmpsv = pm_description(pm);
        Perl_dump_indent(aTHX_ level, file, "PMFLAGS = (%s)\n", SvCUR(tmpsv) ? SvPVX_const(tmpsv) + 1 : "");
        SvREFCNT_dec(tmpsv);
@@ -550,6 +631,19 @@ Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm)
     Perl_dump_indent(aTHX_ level-1, file, "}\n");
 }
 
     Perl_dump_indent(aTHX_ level-1, file, "}\n");
 }
 
+const struct flag_to_name pmflags_flags_names[] = {
+    {PMf_CONST, ",CONST"},
+    {PMf_KEEP, ",KEEP"},
+    {PMf_GLOBAL, ",GLOBAL"},
+    {PMf_CONTINUE, ",CONTINUE"},
+    {PMf_RETAINT, ",RETAINT"},
+    {PMf_EVAL, ",EVAL"},
+    {PMf_NONDESTRUCT, ",NONDESTRUCT"},
+    {PMf_HAS_CV, ",HAS_CV"},
+    {PMf_CODELIST_PRIVATE, ",CODELIST_PRIVATE"},
+    {PMf_IS_QR, ",IS_QR"}
+};
+
 static SV *
 S_pm_description(pTHX_ const PMOP *pm)
 {
 static SV *
 S_pm_description(pTHX_ const PMOP *pm)
 {
@@ -557,6 +651,8 @@ S_pm_description(pTHX_ const PMOP *pm)
     const REGEXP * const regex = PM_GETRE(pm);
     const U32 pmflags = pm->op_pmflags;
 
     const REGEXP * const regex = PM_GETRE(pm);
     const U32 pmflags = pm->op_pmflags;
 
+    PERL_ARGS_ASSERT_PM_DESCRIPTION;
+
     if (pmflags & PMf_ONCE)
        sv_catpv(desc, ",ONCE");
 #ifdef USE_ITHREADS
     if (pmflags & PMf_ONCE)
        sv_catpv(desc, ",ONCE");
 #ifdef USE_ITHREADS
@@ -568,30 +664,17 @@ S_pm_description(pTHX_ const PMOP *pm)
 #endif
 
     if (regex) {
 #endif
 
     if (regex) {
-        if (regex->extflags & RXf_TAINTED)
+        if (RX_ISTAINTED(regex))
             sv_catpv(desc, ",TAINTED");
             sv_catpv(desc, ",TAINTED");
-        if (regex->check_substr) {
-            if (!(regex->extflags & RXf_NOSCAN))
+        if (RX_CHECK_SUBSTR(regex)) {
+            if (!(RX_EXTFLAGS(regex) & RXf_NOSCAN))
                 sv_catpv(desc, ",SCANFIRST");
                 sv_catpv(desc, ",SCANFIRST");
-            if (regex->extflags & RXf_CHECK_ALL)
+            if (RX_EXTFLAGS(regex) & RXf_CHECK_ALL)
                 sv_catpv(desc, ",ALL");
         }
                 sv_catpv(desc, ",ALL");
         }
-        if (regex->extflags & RXf_SKIPWHITE)
-            sv_catpv(desc, ",SKIPWHITE");
-    }
-
-    if (pmflags & PMf_CONST)
-       sv_catpv(desc, ",CONST");
-    if (pmflags & PMf_KEEP)
-       sv_catpv(desc, ",KEEP");
-    if (pmflags & PMf_GLOBAL)
-       sv_catpv(desc, ",GLOBAL");
-    if (pmflags & PMf_CONTINUE)
-       sv_catpv(desc, ",CONTINUE");
-    if (pmflags & PMf_RETAINT)
-       sv_catpv(desc, ",RETAINT");
-    if (pmflags & PMf_EVAL)
-       sv_catpv(desc, ",EVAL");
+    }
+
+    append_flags(desc, pmflags, pmflags_flags_names);
     return desc;
 }
 
     return desc;
 }
 
@@ -601,118 +684,155 @@ Perl_pmop_dump(pTHX_ PMOP *pm)
     do_pmop_dump(0, Perl_debug_log, pm);
 }
 
     do_pmop_dump(0, Perl_debug_log, pm);
 }
 
-/* An op sequencer.  We visit the ops in the order they're to execute. */
+/* Return a unique integer to represent the address of op o.
+ * If it already exists in PL_op_sequence, just return it;
+ * otherwise add it.
+ *  *** Note that this isn't thread-safe */
 
 
-STATIC void
-S_sequence(pTHX_ register const OP *o)
+STATIC UV
+S_sequence_num(pTHX_ const OP *o)
 {
     dVAR;
 {
     dVAR;
-    const OP *oldop = NULL;
-
+    SV     *op,
+          **seq;
+    const char *key;
+    STRLEN  len;
     if (!o)
     if (!o)
-       return;
-
-#ifdef PERL_MAD
-    if (o->op_next == 0)
-       return;
-#endif
+       return 0;
+    op = newSVuv(PTR2UV(o));
+    sv_2mortal(op);
+    key = SvPV_const(op, len);
+    if (!PL_op_sequence)
+       PL_op_sequence = newHV();
+    seq = hv_fetch(PL_op_sequence, key, len, 0);
+    if (seq)
+       return SvUV(*seq);
+    (void)hv_store(PL_op_sequence, key, len, newSVuv(++PL_op_seq), 0);
+    return PL_op_seq;
+}
 
 
-    if (!Sequence)
-       Sequence = newHV();
+const struct flag_to_name op_flags_names[] = {
+    {OPf_KIDS, ",KIDS"},
+    {OPf_PARENS, ",PARENS"},
+    {OPf_REF, ",REF"},
+    {OPf_MOD, ",MOD"},
+    {OPf_STACKED, ",STACKED"},
+    {OPf_SPECIAL, ",SPECIAL"}
+};
 
 
-    for (; o; o = o->op_next) {
-       STRLEN len;
-       SV * const op = newSVuv(PTR2UV(o));
-       const char * const key = SvPV_const(op, len);
+const struct flag_to_name op_trans_names[] = {
+    {OPpTRANS_FROM_UTF, ",FROM_UTF"},
+    {OPpTRANS_TO_UTF, ",TO_UTF"},
+    {OPpTRANS_IDENTICAL, ",IDENTICAL"},
+    {OPpTRANS_SQUASH, ",SQUASH"},
+    {OPpTRANS_COMPLEMENT, ",COMPLEMENT"},
+    {OPpTRANS_GROWS, ",GROWS"},
+    {OPpTRANS_DELETE, ",DELETE"}
+};
 
 
-       if (hv_exists(Sequence, key, len))
-           break;
+const struct flag_to_name op_entersub_names[] = {
+    {OPpENTERSUB_DB, ",DB"},
+    {OPpENTERSUB_HASTARG, ",HASTARG"},
+    {OPpENTERSUB_AMPER, ",AMPER"},
+    {OPpENTERSUB_NOPAREN, ",NOPAREN"},
+    {OPpENTERSUB_INARGS, ",INARGS"}
+};
 
 
-       switch (o->op_type) {
-       case OP_STUB:
-           if ((o->op_flags & OPf_WANT) != OPf_WANT_LIST) {
-               hv_store(Sequence, key, len, newSVuv(++PL_op_seq), 0);
-               break;
-           }
-           goto nothin;
-       case OP_NULL:
-#ifdef PERL_MAD
-           if (o == o->op_next)
-               return;
-#endif
-           if (oldop && o->op_next)
-               continue;
-           break;
-       case OP_SCALAR:
-       case OP_LINESEQ:
-       case OP_SCOPE:
-         nothin:
-           if (oldop && o->op_next)
-               continue;
-           hv_store(Sequence, key, len, newSVuv(++PL_op_seq), 0);
-           break;
+const struct flag_to_name op_const_names[] = {
+    {OPpCONST_NOVER, ",NOVER"},
+    {OPpCONST_SHORTCIRCUIT, ",SHORTCIRCUIT"},
+    {OPpCONST_STRICT, ",STRICT"},
+    {OPpCONST_ENTERED, ",ENTERED"},
+    {OPpCONST_FOLDED, ",FOLDED"},
+    {OPpCONST_BARE, ",BARE"}
+};
 
 
-       case OP_MAPWHILE:
-       case OP_GREPWHILE:
-       case OP_AND:
-       case OP_OR:
-       case OP_DOR:
-       case OP_ANDASSIGN:
-       case OP_ORASSIGN:
-       case OP_DORASSIGN:
-       case OP_COND_EXPR:
-       case OP_RANGE:
-           hv_store(Sequence, key, len, newSVuv(++PL_op_seq), 0);
-           sequence_tail(cLOGOPo->op_other);
-           break;
+const struct flag_to_name op_sort_names[] = {
+    {OPpSORT_NUMERIC, ",NUMERIC"},
+    {OPpSORT_INTEGER, ",INTEGER"},
+    {OPpSORT_REVERSE, ",REVERSE"},
+    {OPpSORT_INPLACE, ",INPLACE"},
+    {OPpSORT_DESCEND, ",DESCEND"},
+    {OPpSORT_QSORT, ",QSORT"},
+    {OPpSORT_STABLE, ",STABLE"}
+};
 
 
-       case OP_ENTERLOOP:
-       case OP_ENTERITER:
-           hv_store(Sequence, key, len, newSVuv(++PL_op_seq), 0);
-           sequence_tail(cLOOPo->op_redoop);
-           sequence_tail(cLOOPo->op_nextop);
-           sequence_tail(cLOOPo->op_lastop);
-           break;
+const struct flag_to_name op_open_names[] = {
+    {OPpOPEN_IN_RAW, ",IN_RAW"},
+    {OPpOPEN_IN_CRLF, ",IN_CRLF"},
+    {OPpOPEN_OUT_RAW, ",OUT_RAW"},
+    {OPpOPEN_OUT_CRLF, ",OUT_CRLF"}
+};
 
 
-       case OP_SUBST:
-           hv_store(Sequence, key, len, newSVuv(++PL_op_seq), 0);
-           sequence_tail(cPMOPo->op_pmstashstartu.op_pmreplstart);
-           break;
+const struct flag_to_name op_exit_names[] = {
+    {OPpEXIT_VMSISH, ",EXIT_VMSISH"},
+    {OPpHUSH_VMSISH, ",HUSH_VMSISH"}
+};
 
 
-       case OP_QR:
-       case OP_MATCH:
-       case OP_HELEM:
-           break;
+#define OP_PRIVATE_ONCE(op, flag, name) \
+    const struct flag_to_name CAT2(op, _names)[] = {   \
+       {(flag), (name)} \
+    }
+
+OP_PRIVATE_ONCE(op_aassign, OPpASSIGN_COMMON, ",COMMON");
+OP_PRIVATE_ONCE(op_leavesub, OPpREFCOUNTED, ",REFCOUNTED");
+OP_PRIVATE_ONCE(op_sassign, OPpASSIGN_BACKWARDS, ",BACKWARDS");
+OP_PRIVATE_ONCE(op_repeat, OPpREPEAT_DOLIST, ",DOLIST");
+OP_PRIVATE_ONCE(op_reverse, OPpREVERSE_INPLACE, ",INPLACE");
+OP_PRIVATE_ONCE(op_rv2cv, OPpLVAL_INTRO, ",INTRO");
+OP_PRIVATE_ONCE(op_flip, OPpFLIP_LINENUM, ",LINENUM");
+OP_PRIVATE_ONCE(op_gv, OPpEARLY_CV, ",EARLY_CV");
+OP_PRIVATE_ONCE(op_list, OPpLIST_GUESSED, ",GUESSED");
+OP_PRIVATE_ONCE(op_delete, OPpSLICE, ",SLICE");
+OP_PRIVATE_ONCE(op_exists, OPpEXISTS_SUB, ",EXISTS_SUB");
+OP_PRIVATE_ONCE(op_die, OPpHUSH_VMSISH, ",HUSH_VMSISH");
+
+struct op_private_by_op {
+    U16 op_type;
+    U16 len;
+    const struct flag_to_name *start;
+};
 
 
-       default:
-           hv_store(Sequence, key, len, newSVuv(++PL_op_seq), 0);
-           break;
-       }
-       oldop = o;
-    }
-}
+const struct op_private_by_op op_private_names[] = {
+    {OP_LEAVESUB, C_ARRAY_LENGTH(op_leavesub_names), op_leavesub_names },
+    {OP_LEAVE, C_ARRAY_LENGTH(op_leavesub_names), op_leavesub_names },
+    {OP_LEAVESUBLV, C_ARRAY_LENGTH(op_leavesub_names), op_leavesub_names },
+    {OP_LEAVEWRITE, C_ARRAY_LENGTH(op_leavesub_names), op_leavesub_names },
+    {OP_AASSIGN, C_ARRAY_LENGTH(op_aassign_names), op_aassign_names },
+    {OP_DIE, C_ARRAY_LENGTH(op_die_names), op_die_names },
+    {OP_DELETE, C_ARRAY_LENGTH(op_delete_names), op_delete_names },
+    {OP_EXISTS, C_ARRAY_LENGTH(op_exists_names), op_exists_names },
+    {OP_EXIT, C_ARRAY_LENGTH(op_exit_names), op_exit_names },
+    {OP_FLIP, C_ARRAY_LENGTH(op_flip_names), op_flip_names },
+    {OP_FLOP, C_ARRAY_LENGTH(op_flip_names), op_flip_names },
+    {OP_GV, C_ARRAY_LENGTH(op_gv_names), op_gv_names },
+    {OP_LIST, C_ARRAY_LENGTH(op_list_names), op_list_names },
+    {OP_SASSIGN, C_ARRAY_LENGTH(op_sassign_names), op_sassign_names },
+    {OP_REPEAT, C_ARRAY_LENGTH(op_repeat_names), op_repeat_names },
+    {OP_RV2CV, C_ARRAY_LENGTH(op_rv2cv_names), op_rv2cv_names },
+    {OP_TRANS, C_ARRAY_LENGTH(op_trans_names), op_trans_names },
+    {OP_CONST, C_ARRAY_LENGTH(op_const_names), op_const_names },
+    {OP_SORT, C_ARRAY_LENGTH(op_sort_names), op_sort_names },
+    {OP_OPEN, C_ARRAY_LENGTH(op_open_names), op_open_names },
+    {OP_BACKTICK, C_ARRAY_LENGTH(op_open_names), op_open_names }
+};
 
 
-static void
-S_sequence_tail(pTHX_ const OP *o)
-{
-    while (o && (o->op_type == OP_NULL))
-       o = o->op_next;
-    sequence(o);
-}
+static bool
+S_op_private_to_names(pTHX_ SV *tmpsv, U32 optype, U32 op_private) {
+    const struct op_private_by_op *start = op_private_names;
+    const struct op_private_by_op *const end
+       = op_private_names + C_ARRAY_LENGTH(op_private_names);
 
 
-STATIC UV
-S_sequence_num(pTHX_ const OP *o)
-{
-    dVAR;
-    SV     *op,
-          **seq;
-    const char *key;
-    STRLEN  len;
-    if (!o) return 0;
-    op = newSVuv(PTR2UV(o));
-    key = SvPV_const(op, len);
-    seq = hv_fetch(Sequence, key, len, 0);
-    return seq ? SvUV(*seq): 0;
+    /* This is a linear search, but no worse than the code that it replaced.
+       It's debugging code - size is more important than speed.  */
+    do {
+       if (optype == start->op_type) {
+           S_append_flags(aTHX_ tmpsv, op_private, start->start,
+                          start->start + start->len);
+           return TRUE;
+       }
+    } while (++start < end);
+    return FALSE;
 }
 
 void
 }
 
 void
@@ -722,22 +842,24 @@ Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o)
     UV      seq;
     const OPCODE optype = o->op_type;
 
     UV      seq;
     const OPCODE optype = o->op_type;
 
-    sequence(o);
+    PERL_ARGS_ASSERT_DO_OP_DUMP;
+
     Perl_dump_indent(aTHX_ level, file, "{\n");
     level++;
     seq = sequence_num(o);
     if (seq)
        PerlIO_printf(file, "%-4"UVuf, seq);
     else
     Perl_dump_indent(aTHX_ level, file, "{\n");
     level++;
     seq = sequence_num(o);
     if (seq)
        PerlIO_printf(file, "%-4"UVuf, seq);
     else
-       PerlIO_printf(file, "    ");
+       PerlIO_printf(file, "????");
     PerlIO_printf(file,
                  "%*sTYPE = %s  ===> ",
                  (int)(PL_dumpindent*level-4), "", OP_NAME(o));
     if (o->op_next)
     PerlIO_printf(file,
                  "%*sTYPE = %s  ===> ",
                  (int)(PL_dumpindent*level-4), "", OP_NAME(o));
     if (o->op_next)
-       PerlIO_printf(file, seq ? "%"UVuf"\n" : "(%"UVuf")\n",
+       PerlIO_printf(file,
+                       o->op_type == OP_NULL ? "(%"UVuf")\n" : "%"UVuf"\n",
                                sequence_num(o->op_next));
     else
                                sequence_num(o->op_next));
     else
-       PerlIO_printf(file, "DONE\n");
+       PerlIO_printf(file, "NULL\n");
     if (o->op_targ) {
        if (optype == OP_NULL) {
            Perl_dump_indent(aTHX_ level, file, "  (was %s)\n", PL_op_name[o->op_targ]);
     if (o->op_targ) {
        if (optype == OP_NULL) {
            Perl_dump_indent(aTHX_ level, file, "  (was %s)\n", PL_op_name[o->op_targ]);
@@ -748,9 +870,9 @@ Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o)
                if (CopSTASHPV(cCOPo))
                    Perl_dump_indent(aTHX_ level, file, "PACKAGE = \"%s\"\n",
                                     CopSTASHPV(cCOPo));
                if (CopSTASHPV(cCOPo))
                    Perl_dump_indent(aTHX_ level, file, "PACKAGE = \"%s\"\n",
                                     CopSTASHPV(cCOPo));
-               if (cCOPo->cop_label)
+               if (CopLABEL(cCOPo))
                    Perl_dump_indent(aTHX_ level, file, "LABEL = \"%s\"\n",
                    Perl_dump_indent(aTHX_ level, file, "LABEL = \"%s\"\n",
-                                    cCOPo->cop_label);
+                                    CopLABEL(cCOPo));
            }
        }
        else
            }
        }
        else
@@ -759,7 +881,7 @@ Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o)
 #ifdef DUMPADDR
     Perl_dump_indent(aTHX_ level, file, "ADDR = 0x%"UVxf" => 0x%"UVxf"\n", (UV)o, (UV)o->op_next);
 #endif
 #ifdef DUMPADDR
     Perl_dump_indent(aTHX_ level, file, "ADDR = 0x%"UVxf" => 0x%"UVxf"\n", (UV)o, (UV)o->op_next);
 #endif
-    if (o->op_flags || o->op_latefree || o->op_latefreed || o->op_attached) {
+    if (o->op_flags || o->op_slabbed || o->op_savefree) {
        SV * const tmpsv = newSVpvs("");
        switch (o->op_flags & OPf_WANT) {
        case OPf_WANT_VOID:
        SV * const tmpsv = newSVpvs("");
        switch (o->op_flags & OPf_WANT) {
        case OPf_WANT_VOID:
@@ -775,86 +897,30 @@ Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o)
            sv_catpv(tmpsv, ",UNKNOWN");
            break;
        }
            sv_catpv(tmpsv, ",UNKNOWN");
            break;
        }
-       if (o->op_flags & OPf_KIDS)
-           sv_catpv(tmpsv, ",KIDS");
-       if (o->op_flags & OPf_PARENS)
-           sv_catpv(tmpsv, ",PARENS");
-       if (o->op_flags & OPf_STACKED)
-           sv_catpv(tmpsv, ",STACKED");
-       if (o->op_flags & OPf_REF)
-           sv_catpv(tmpsv, ",REF");
-       if (o->op_flags & OPf_MOD)
-           sv_catpv(tmpsv, ",MOD");
-       if (o->op_flags & OPf_SPECIAL)
-           sv_catpv(tmpsv, ",SPECIAL");
-       if (o->op_latefree)
-           sv_catpv(tmpsv, ",LATEFREE");
-       if (o->op_latefreed)
-           sv_catpv(tmpsv, ",LATEFREED");
-       if (o->op_attached)
-           sv_catpv(tmpsv, ",ATTACHED");
+       append_flags(tmpsv, o->op_flags, op_flags_names);
+       if (o->op_slabbed)  sv_catpvs(tmpsv, ",SLABBED");
+       if (o->op_savefree) sv_catpvs(tmpsv, ",SAVEFREE");
        Perl_dump_indent(aTHX_ level, file, "FLAGS = (%s)\n", SvCUR(tmpsv) ? SvPVX_const(tmpsv) + 1 : "");
        SvREFCNT_dec(tmpsv);
     }
     if (o->op_private) {
        SV * const tmpsv = newSVpvs("");
        Perl_dump_indent(aTHX_ level, file, "FLAGS = (%s)\n", SvCUR(tmpsv) ? SvPVX_const(tmpsv) + 1 : "");
        SvREFCNT_dec(tmpsv);
     }
     if (o->op_private) {
        SV * const tmpsv = newSVpvs("");
+
        if (PL_opargs[optype] & OA_TARGLEX) {
            if (o->op_private & OPpTARGET_MY)
                sv_catpv(tmpsv, ",TARGET_MY");
        }
        if (PL_opargs[optype] & OA_TARGLEX) {
            if (o->op_private & OPpTARGET_MY)
                sv_catpv(tmpsv, ",TARGET_MY");
        }
-       else if (optype == OP_LEAVESUB ||
-                optype == OP_LEAVE ||
-                optype == OP_LEAVESUBLV ||
-                optype == OP_LEAVEWRITE) {
-           if (o->op_private & OPpREFCOUNTED)
-               sv_catpv(tmpsv, ",REFCOUNTED");
-       }
-        else if (optype == OP_AASSIGN) {
-           if (o->op_private & OPpASSIGN_COMMON)
-               sv_catpv(tmpsv, ",COMMON");
-       }
-       else if (optype == OP_SASSIGN) {
-           if (o->op_private & OPpASSIGN_BACKWARDS)
-               sv_catpv(tmpsv, ",BACKWARDS");
-       }
-       else if (optype == OP_TRANS) {
-           if (o->op_private & OPpTRANS_SQUASH)
-               sv_catpv(tmpsv, ",SQUASH");
-           if (o->op_private & OPpTRANS_DELETE)
-               sv_catpv(tmpsv, ",DELETE");
-           if (o->op_private & OPpTRANS_COMPLEMENT)
-               sv_catpv(tmpsv, ",COMPLEMENT");
-           if (o->op_private & OPpTRANS_IDENTICAL)
-               sv_catpv(tmpsv, ",IDENTICAL");
-           if (o->op_private & OPpTRANS_GROWS)
-               sv_catpv(tmpsv, ",GROWS");
-       }
-       else if (optype == OP_REPEAT) {
-           if (o->op_private & OPpREPEAT_DOLIST)
-               sv_catpv(tmpsv, ",DOLIST");
-       }
        else if (optype == OP_ENTERSUB ||
        else if (optype == OP_ENTERSUB ||
-                optype == OP_RV2SV ||
-                optype == OP_GVSV ||
-                optype == OP_RV2AV ||
-                optype == OP_RV2HV ||
-                optype == OP_RV2GV ||
-                optype == OP_AELEM ||
-                optype == OP_HELEM )
+           optype == OP_RV2SV ||
+           optype == OP_GVSV ||
+           optype == OP_RV2AV ||
+           optype == OP_RV2HV ||
+           optype == OP_RV2GV ||
+           optype == OP_AELEM ||
+           optype == OP_HELEM )
        {
            if (optype == OP_ENTERSUB) {
        {
            if (optype == OP_ENTERSUB) {
-               if (o->op_private & OPpENTERSUB_AMPER)
-                   sv_catpv(tmpsv, ",AMPER");
-               if (o->op_private & OPpENTERSUB_DB)
-                   sv_catpv(tmpsv, ",DB");
-               if (o->op_private & OPpENTERSUB_HASTARG)
-                   sv_catpv(tmpsv, ",HASTARG");
-               if (o->op_private & OPpENTERSUB_NOPAREN)
-                   sv_catpv(tmpsv, ",NOPAREN");
-               if (o->op_private & OPpENTERSUB_INARGS)
-                   sv_catpv(tmpsv, ",INARGS");
-               if (o->op_private & OPpENTERSUB_NOMOD)
-                   sv_catpv(tmpsv, ",NOMOD");
+               append_flags(tmpsv, o->op_private, op_entersub_names);
            }
            else {
                switch (o->op_private & OPpDEREF) {
            }
            else {
                switch (o->op_private & OPpDEREF) {
@@ -871,10 +937,17 @@ Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o)
                if (o->op_private & OPpMAYBE_LVSUB)
                    sv_catpv(tmpsv, ",MAYBE_LVSUB");
            }
                if (o->op_private & OPpMAYBE_LVSUB)
                    sv_catpv(tmpsv, ",MAYBE_LVSUB");
            }
+
            if (optype == OP_AELEM || optype == OP_HELEM) {
                if (o->op_private & OPpLVAL_DEFER)
                    sv_catpv(tmpsv, ",LVAL_DEFER");
            }
            if (optype == OP_AELEM || optype == OP_HELEM) {
                if (o->op_private & OPpLVAL_DEFER)
                    sv_catpv(tmpsv, ",LVAL_DEFER");
            }
+           else if (optype == OP_RV2HV || optype == OP_PADHV) {
+             if (o->op_private & OPpMAYBE_TRUEBOOL)
+               sv_catpvs(tmpsv, ",OPpMAYBE_TRUEBOOL");
+             if (o->op_private & OPpTRUEBOOL)
+               sv_catpvs(tmpsv, ",OPpTRUEBOOL");
+           }
            else {
                if (o->op_private & HINT_STRICT_REFS)
                    sv_catpv(tmpsv, ",STRICT_REFS");
            else {
                if (o->op_private & HINT_STRICT_REFS)
                    sv_catpv(tmpsv, ",STRICT_REFS");
@@ -882,96 +955,39 @@ Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o)
                    sv_catpv(tmpsv, ",OUR_INTRO");
            }
        }
                    sv_catpv(tmpsv, ",OUR_INTRO");
            }
        }
-       else if (optype == OP_CONST) {
-           if (o->op_private & OPpCONST_BARE)
-               sv_catpv(tmpsv, ",BARE");
-           if (o->op_private & OPpCONST_STRICT)
-               sv_catpv(tmpsv, ",STRICT");
-           if (o->op_private & OPpCONST_ARYBASE)
-               sv_catpv(tmpsv, ",ARYBASE");
-           if (o->op_private & OPpCONST_WARNING)
-               sv_catpv(tmpsv, ",WARNING");
-           if (o->op_private & OPpCONST_ENTERED)
-               sv_catpv(tmpsv, ",ENTERED");
-       }
-       else if (optype == OP_FLIP) {
-           if (o->op_private & OPpFLIP_LINENUM)
-               sv_catpv(tmpsv, ",LINENUM");
-       }
-       else if (optype == OP_FLOP) {
-           if (o->op_private & OPpFLIP_LINENUM)
-               sv_catpv(tmpsv, ",LINENUM");
-       }
-       else if (optype == OP_RV2CV) {
-           if (o->op_private & OPpLVAL_INTRO)
-               sv_catpv(tmpsv, ",INTRO");
-       }
-       else if (optype == OP_GV) {
-           if (o->op_private & OPpEARLY_CV)
-               sv_catpv(tmpsv, ",EARLY_CV");
-       }
-       else if (optype == OP_LIST) {
-           if (o->op_private & OPpLIST_GUESSED)
-               sv_catpv(tmpsv, ",GUESSED");
-       }
-       else if (optype == OP_DELETE) {
-           if (o->op_private & OPpSLICE)
-               sv_catpv(tmpsv, ",SLICE");
-       }
-       else if (optype == OP_EXISTS) {
-           if (o->op_private & OPpEXISTS_SUB)
-               sv_catpv(tmpsv, ",EXISTS_SUB");
-       }
-       else if (optype == OP_SORT) {
-           if (o->op_private & OPpSORT_NUMERIC)
-               sv_catpv(tmpsv, ",NUMERIC");
-           if (o->op_private & OPpSORT_INTEGER)
-               sv_catpv(tmpsv, ",INTEGER");
-           if (o->op_private & OPpSORT_REVERSE)
-               sv_catpv(tmpsv, ",REVERSE");
-       }
-       else if (optype == OP_OPEN || optype == OP_BACKTICK) {
-           if (o->op_private & OPpOPEN_IN_RAW)
-               sv_catpv(tmpsv, ",IN_RAW");
-           if (o->op_private & OPpOPEN_IN_CRLF)
-               sv_catpv(tmpsv, ",IN_CRLF");
-           if (o->op_private & OPpOPEN_OUT_RAW)
-               sv_catpv(tmpsv, ",OUT_RAW");
-           if (o->op_private & OPpOPEN_OUT_CRLF)
-               sv_catpv(tmpsv, ",OUT_CRLF");
-       }
-       else if (optype == OP_EXIT) {
-           if (o->op_private & OPpEXIT_VMSISH)
-               sv_catpv(tmpsv, ",EXIT_VMSISH");
-           if (o->op_private & OPpHUSH_VMSISH)
-               sv_catpv(tmpsv, ",HUSH_VMSISH");
-       }
-       else if (optype == OP_DIE) {
-           if (o->op_private & OPpHUSH_VMSISH)
-               sv_catpv(tmpsv, ",HUSH_VMSISH");
+       else if (S_op_private_to_names(aTHX_ tmpsv, optype, o->op_private)) {
        }
        }
-       else if (PL_check[optype] != MEMBER_TO_FPTR(Perl_ck_ftst)) {
-           if (OP_IS_FILETEST_ACCESS(o) && o->op_private & OPpFT_ACCESS)
+       else if (PL_check[optype] != Perl_ck_ftst) {
+           if (OP_IS_FILETEST_ACCESS(o->op_type) && o->op_private & OPpFT_ACCESS)
                sv_catpv(tmpsv, ",FT_ACCESS");
            if (o->op_private & OPpFT_STACKED)
                sv_catpv(tmpsv, ",FT_STACKED");
        }
                sv_catpv(tmpsv, ",FT_ACCESS");
            if (o->op_private & OPpFT_STACKED)
                sv_catpv(tmpsv, ",FT_STACKED");
        }
+
        if (o->op_flags & OPf_MOD && o->op_private & OPpLVAL_INTRO)
            sv_catpv(tmpsv, ",INTRO");
        if (o->op_flags & OPf_MOD && o->op_private & OPpLVAL_INTRO)
            sv_catpv(tmpsv, ",INTRO");
+
+       if (o->op_type == OP_PADRANGE)
+           Perl_sv_catpvf(aTHX_ tmpsv, ",COUNT=%"UVuf,
+                (UV)(o->op_private & OPpPADRANGE_COUNTMASK));
+
        if (SvCUR(tmpsv))
            Perl_dump_indent(aTHX_ level, file, "PRIVATE = (%s)\n", SvPVX_const(tmpsv) + 1);
        if (SvCUR(tmpsv))
            Perl_dump_indent(aTHX_ level, file, "PRIVATE = (%s)\n", SvPVX_const(tmpsv) + 1);
+        else
+           Perl_dump_indent(aTHX_ level, file, "PRIVATE = (0x%"UVxf")\n",
+                                (UV)o->op_private);
        SvREFCNT_dec(tmpsv);
     }
 
 #ifdef PERL_MAD
     if (PL_madskills && o->op_madprop) {
        SvREFCNT_dec(tmpsv);
     }
 
 #ifdef PERL_MAD
     if (PL_madskills && o->op_madprop) {
-       SV * const tmpsv = newSVpvn("", 0);
+       SV * const tmpsv = newSVpvs("");
        MADPROP* mp = o->op_madprop;
        Perl_dump_indent(aTHX_ level, file, "MADPROPS = {\n");
        level++;
        while (mp) {
            const char tmp = mp->mad_key;
        MADPROP* mp = o->op_madprop;
        Perl_dump_indent(aTHX_ level, file, "MADPROPS = {\n");
        level++;
        while (mp) {
            const char tmp = mp->mad_key;
-           sv_setpvn(tmpsv,"'",1);
+           sv_setpvs(tmpsv,"'");
            if (tmp)
                sv_catpvn(tmpsv, &tmp, 1);
            sv_catpv(tmpsv, "'=");
            if (tmp)
                sv_catpvn(tmpsv, &tmp, 1);
            sv_catpv(tmpsv, "'=");
@@ -1013,7 +1029,7 @@ Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o)
 #ifdef USE_ITHREADS
        Perl_dump_indent(aTHX_ level, file, "PADIX = %" IVdf "\n", (IV)cPADOPo->op_padix);
 #else
 #ifdef USE_ITHREADS
        Perl_dump_indent(aTHX_ level, file, "PADIX = %" IVdf "\n", (IV)cPADOPo->op_padix);
 #else
-       if ( ! PL_op->op_flags & OPf_SPECIAL) { /* not lexical */
+       if ( ! (o->op_flags & OPf_SPECIAL)) { /* not lexical */
            if (cSVOPo->op_sv) {
                SV * const tmpsv = newSV(0);
                ENTER;
            if (cSVOPo->op_sv) {
                SV * const tmpsv = newSV(0);
                ENTER;
@@ -1023,7 +1039,7 @@ Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o)
                   UTF-8 cleanliness of the dump file handle?  */
                SvUTF8_on(tmpsv);
 #endif
                   UTF-8 cleanliness of the dump file handle?  */
                SvUTF8_on(tmpsv);
 #endif
-               gv_fullname3(tmpsv, (GV*)cSVOPo->op_sv, NULL);
+               gv_fullname3(tmpsv, MUTABLE_GV(cSVOPo->op_sv), NULL);
                Perl_dump_indent(aTHX_ level, file, "GV = %s\n",
                                 SvPV_nolen_const(tmpsv));
                LEAVE;
                Perl_dump_indent(aTHX_ level, file, "GV = %s\n",
                                 SvPV_nolen_const(tmpsv));
                LEAVE;
@@ -1034,6 +1050,7 @@ Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o)
 #endif
        break;
     case OP_CONST:
 #endif
        break;
     case OP_CONST:
+    case OP_HINTSEVAL:
     case OP_METHOD_NAMED:
 #ifndef USE_ITHREADS
        /* with ITHREADS, consts are stored in the pad, and the right pad
     case OP_METHOD_NAMED:
 #ifndef USE_ITHREADS
        /* with ITHREADS, consts are stored in the pad, and the right pad
@@ -1041,7 +1058,6 @@ Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o)
        Perl_dump_indent(aTHX_ level, file, "SV = %s\n", SvPEEK(cSVOPo_sv));
 #endif
        break;
        Perl_dump_indent(aTHX_ level, file, "SV = %s\n", SvPEEK(cSVOPo_sv));
 #endif
        break;
-    case OP_SETSTATE:
     case OP_NEXTSTATE:
     case OP_DBSTATE:
        if (CopLINE(cCOPo))
     case OP_NEXTSTATE:
     case OP_DBSTATE:
        if (CopLINE(cCOPo))
@@ -1050,9 +1066,9 @@ Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o)
        if (CopSTASHPV(cCOPo))
            Perl_dump_indent(aTHX_ level, file, "PACKAGE = \"%s\"\n",
                             CopSTASHPV(cCOPo));
        if (CopSTASHPV(cCOPo))
            Perl_dump_indent(aTHX_ level, file, "PACKAGE = \"%s\"\n",
                             CopSTASHPV(cCOPo));
-       if (cCOPo->cop_label)
+       if (CopLABEL(cCOPo))
            Perl_dump_indent(aTHX_ level, file, "LABEL = \"%s\"\n",
            Perl_dump_indent(aTHX_ level, file, "LABEL = \"%s\"\n",
-                            cCOPo->cop_label);
+                            CopLABEL(cCOPo));
        break;
     case OP_ENTERLOOP:
        Perl_dump_indent(aTHX_ level, file, "REDO ===> ");
        break;
     case OP_ENTERLOOP:
        Perl_dump_indent(aTHX_ level, file, "REDO ===> ");
@@ -1112,6 +1128,7 @@ Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o)
 void
 Perl_op_dump(pTHX_ const OP *o)
 {
 void
 Perl_op_dump(pTHX_ const OP *o)
 {
+    PERL_ARGS_ASSERT_OP_DUMP;
     do_op_dump(0, Perl_debug_log, o);
 }
 
     do_op_dump(0, Perl_debug_log, o);
 }
 
@@ -1120,6 +1137,8 @@ Perl_gv_dump(pTHX_ GV *gv)
 {
     SV *sv;
 
 {
     SV *sv;
 
+    PERL_ARGS_ASSERT_GV_DUMP;
+
     if (!gv) {
        PerlIO_printf(Perl_debug_log, "{}\n");
        return;
     if (!gv) {
        PerlIO_printf(Perl_debug_log, "{}\n");
        return;
@@ -1142,49 +1161,7 @@ Perl_gv_dump(pTHX_ GV *gv)
  */
 
 static const struct { const char type; const char *name; } magic_names[] = {
  */
 
 static const struct { const char type; const char *name; } magic_names[] = {
-       { PERL_MAGIC_sv,             "sv(\\0)" },
-       { PERL_MAGIC_arylen,         "arylen(#)" },
-       { PERL_MAGIC_rhash,          "rhash(%)" },
-       { PERL_MAGIC_pos,            "pos(.)" },
-       { PERL_MAGIC_symtab,         "symtab(:)" },
-       { PERL_MAGIC_backref,        "backref(<)" },
-       { PERL_MAGIC_arylen_p,       "arylen_p(@)" },
-       { PERL_MAGIC_overload,       "overload(A)" },
-       { PERL_MAGIC_bm,             "bm(B)" },
-       { PERL_MAGIC_regdata,        "regdata(D)" },
-       { PERL_MAGIC_env,            "env(E)" },
-       { PERL_MAGIC_hints,          "hints(H)" },
-       { PERL_MAGIC_isa,            "isa(I)" },
-       { PERL_MAGIC_dbfile,         "dbfile(L)" },
-       { PERL_MAGIC_shared,         "shared(N)" },
-       { PERL_MAGIC_tied,           "tied(P)" },
-       { PERL_MAGIC_sig,            "sig(S)" },
-       { PERL_MAGIC_uvar,           "uvar(U)" },
-       { PERL_MAGIC_overload_elem,  "overload_elem(a)" },
-       { PERL_MAGIC_overload_table, "overload_table(c)" },
-       { PERL_MAGIC_regdatum,       "regdatum(d)" },
-       { PERL_MAGIC_envelem,        "envelem(e)" },
-       { PERL_MAGIC_fm,             "fm(f)" },
-       { PERL_MAGIC_regex_global,   "regex_global(g)" },
-       { PERL_MAGIC_hintselem,      "hintselem(h)" },
-       { PERL_MAGIC_isaelem,        "isaelem(i)" },
-       { PERL_MAGIC_nkeys,          "nkeys(k)" },
-       { PERL_MAGIC_dbline,         "dbline(l)" },
-       { PERL_MAGIC_mutex,          "mutex(m)" },
-       { PERL_MAGIC_shared_scalar,  "shared_scalar(n)" },
-       { PERL_MAGIC_collxfrm,       "collxfrm(o)" },
-       { PERL_MAGIC_tiedelem,       "tiedelem(p)" },
-       { PERL_MAGIC_tiedscalar,     "tiedscalar(q)" },
-       { PERL_MAGIC_qr,             "qr(r)" },
-       { PERL_MAGIC_sigelem,        "sigelem(s)" },
-       { PERL_MAGIC_taint,          "taint(t)" },
-       { PERL_MAGIC_uvar_elem,      "uvar_elem(v)" },
-       { PERL_MAGIC_vec,            "vec(v)" },
-       { PERL_MAGIC_vstring,        "vstring(V)" },
-       { PERL_MAGIC_utf8,           "utf8(w)" },
-       { PERL_MAGIC_substr,         "substr(x)" },
-       { PERL_MAGIC_defelem,        "defelem(y)" },
-       { PERL_MAGIC_ext,            "ext(~)" },
+#include "mg_names.c"
        /* this null string terminates the list */
        { 0,                         NULL },
 };
        /* this null string terminates the list */
        { 0,                         NULL },
 };
@@ -1192,44 +1169,18 @@ static const struct { const char type; const char *name; } magic_names[] = {
 void
 Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim)
 {
 void
 Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim)
 {
+    PERL_ARGS_ASSERT_DO_MAGIC_DUMP;
+
     for (; mg; mg = mg->mg_moremagic) {
        Perl_dump_indent(aTHX_ level, file,
                         "  MAGIC = 0x%"UVxf"\n", PTR2UV(mg));
        if (mg->mg_virtual) {
             const MGVTBL * const v = mg->mg_virtual;
     for (; mg; mg = mg->mg_moremagic) {
        Perl_dump_indent(aTHX_ level, file,
                         "  MAGIC = 0x%"UVxf"\n", PTR2UV(mg));
        if (mg->mg_virtual) {
             const MGVTBL * const v = mg->mg_virtual;
-           const char *s;
-           if      (v == &PL_vtbl_sv)         s = "sv";
-            else if (v == &PL_vtbl_env)        s = "env";
-            else if (v == &PL_vtbl_envelem)    s = "envelem";
-            else if (v == &PL_vtbl_sig)        s = "sig";
-            else if (v == &PL_vtbl_sigelem)    s = "sigelem";
-            else if (v == &PL_vtbl_pack)       s = "pack";
-            else if (v == &PL_vtbl_packelem)   s = "packelem";
-            else if (v == &PL_vtbl_dbline)     s = "dbline";
-            else if (v == &PL_vtbl_isa)        s = "isa";
-            else if (v == &PL_vtbl_arylen)     s = "arylen";
-            else if (v == &PL_vtbl_mglob)      s = "mglob";
-            else if (v == &PL_vtbl_nkeys)      s = "nkeys";
-            else if (v == &PL_vtbl_taint)      s = "taint";
-            else if (v == &PL_vtbl_substr)     s = "substr";
-            else if (v == &PL_vtbl_vec)        s = "vec";
-            else if (v == &PL_vtbl_pos)        s = "pos";
-            else if (v == &PL_vtbl_bm)         s = "bm";
-            else if (v == &PL_vtbl_fm)         s = "fm";
-            else if (v == &PL_vtbl_uvar)       s = "uvar";
-            else if (v == &PL_vtbl_defelem)    s = "defelem";
-#ifdef USE_LOCALE_COLLATE
-           else if (v == &PL_vtbl_collxfrm)   s = "collxfrm";
-#endif
-           else if (v == &PL_vtbl_amagic)     s = "amagic";
-           else if (v == &PL_vtbl_amagicelem) s = "amagicelem";
-           else if (v == &PL_vtbl_backref)    s = "backref";
-           else if (v == &PL_vtbl_utf8)       s = "utf8";
-            else if (v == &PL_vtbl_arylen_p)   s = "arylen_p";
-            else if (v == &PL_vtbl_hintselem)  s = "hintselem";
-           else                               s = NULL;
-           if (s)
-               Perl_dump_indent(aTHX_ level, file, "    MG_VIRTUAL = &PL_vtbl_%s\n", s);
+           if (v >= PL_magic_vtables
+               && v < PL_magic_vtables + magic_vtable_max) {
+               const U32 i = v - PL_magic_vtables;
+               Perl_dump_indent(aTHX_ level, file, "    MG_VIRTUAL = &PL_vtbl_%s\n", PL_magic_vtable_names[i]);
+           }
            else
                Perl_dump_indent(aTHX_ level, file, "    MG_VIRTUAL = 0x%"UVxf"\n", PTR2UV(v));
         }
            else
                Perl_dump_indent(aTHX_ level, file, "    MG_VIRTUAL = 0x%"UVxf"\n", PTR2UV(v));
         }
@@ -1261,28 +1212,35 @@ Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32
            if (mg->mg_type == PERL_MAGIC_envelem &&
                mg->mg_flags & MGf_TAINTEDDIR)
                Perl_dump_indent(aTHX_ level, file, "      TAINTEDDIR\n");
            if (mg->mg_type == PERL_MAGIC_envelem &&
                mg->mg_flags & MGf_TAINTEDDIR)
                Perl_dump_indent(aTHX_ level, file, "      TAINTEDDIR\n");
+           if (mg->mg_type == PERL_MAGIC_regex_global &&
+               mg->mg_flags & MGf_MINMATCH)
+               Perl_dump_indent(aTHX_ level, file, "      MINMATCH\n");
            if (mg->mg_flags & MGf_REFCOUNTED)
                Perl_dump_indent(aTHX_ level, file, "      REFCOUNTED\n");
             if (mg->mg_flags & MGf_GSKIP)
                Perl_dump_indent(aTHX_ level, file, "      GSKIP\n");
            if (mg->mg_flags & MGf_REFCOUNTED)
                Perl_dump_indent(aTHX_ level, file, "      REFCOUNTED\n");
             if (mg->mg_flags & MGf_GSKIP)
                Perl_dump_indent(aTHX_ level, file, "      GSKIP\n");
-           if (mg->mg_type == PERL_MAGIC_regex_global &&
-               mg->mg_flags & MGf_MINMATCH)
-               Perl_dump_indent(aTHX_ level, file, "      MINMATCH\n");
+           if (mg->mg_flags & MGf_COPY)
+               Perl_dump_indent(aTHX_ level, file, "      COPY\n");
+           if (mg->mg_flags & MGf_DUP)
+               Perl_dump_indent(aTHX_ level, file, "      DUP\n");
+           if (mg->mg_flags & MGf_LOCAL)
+               Perl_dump_indent(aTHX_ level, file, "      LOCAL\n");
         }
        if (mg->mg_obj) {
         }
        if (mg->mg_obj) {
-           Perl_dump_indent(aTHX_ level, file, "    MG_OBJ = 0x%"UVxf"\n", 
+           Perl_dump_indent(aTHX_ level, file, "    MG_OBJ = 0x%"UVxf"\n",
                PTR2UV(mg->mg_obj));
             if (mg->mg_type == PERL_MAGIC_qr) {
                PTR2UV(mg->mg_obj));
             if (mg->mg_type == PERL_MAGIC_qr) {
-               const regexp * const re = (regexp *)mg->mg_obj;
+               REGEXP* const re = (REGEXP *)mg->mg_obj;
                SV * const dsv = sv_newmortal();
                SV * const dsv = sv_newmortal();
-                const char * const s =  pv_pretty(dsv, re->wrapped, re->wraplen, 
+                const char * const s
+                   = pv_pretty(dsv, RX_WRAPPED(re), RX_WRAPLEN(re),
                     60, NULL, NULL,
                     60, NULL, NULL,
-                    ( PERL_PV_PRETTY_QUOTE | PERL_PV_ESCAPE_RE | PERL_PV_PRETTY_ELIPSES |
-                    ((re->extflags & RXf_UTF8) ? PERL_PV_ESCAPE_UNI : 0))
+                    ( PERL_PV_PRETTY_QUOTE | PERL_PV_ESCAPE_RE | PERL_PV_PRETTY_ELLIPSES |
+                    (RX_UTF8(re) ? PERL_PV_ESCAPE_UNI : 0))
                 );
                Perl_dump_indent(aTHX_ level+1, file, "    PAT = %s\n", s);
                Perl_dump_indent(aTHX_ level+1, file, "    REFCNT = %"IVdf"\n",
                 );
                Perl_dump_indent(aTHX_ level+1, file, "    PAT = %s\n", s);
                Perl_dump_indent(aTHX_ level+1, file, "    REFCNT = %"IVdf"\n",
-                       (IV)re->refcnt);
+                       (IV)RX_REFCNT(re));
             }
             if (mg->mg_flags & MGf_REFCOUNTED)
                do_sv_dump(level+2, file, mg->mg_obj, nest+1, maxnest, dumpops, pvlim); /* MG is already +1 */
             }
             if (mg->mg_flags & MGf_REFCOUNTED)
                do_sv_dump(level+2, file, mg->mg_obj, nest+1, maxnest, dumpops, pvlim); /* MG is already +1 */
@@ -1300,11 +1258,17 @@ Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32
             }
            else if (mg->mg_len == HEf_SVKEY) {
                PerlIO_puts(file, " => HEf_SVKEY\n");
             }
            else if (mg->mg_len == HEf_SVKEY) {
                PerlIO_puts(file, " => HEf_SVKEY\n");
-               do_sv_dump(level+2, file, (SV*)((mg)->mg_ptr), nest+1, maxnest, dumpops, pvlim); /* MG is already +1 */
+               do_sv_dump(level+2, file, MUTABLE_SV(((mg)->mg_ptr)), nest+1,
+                          maxnest, dumpops, pvlim); /* MG is already +1 */
                continue;
            }
                continue;
            }
+           else if (mg->mg_len == -1 && mg->mg_type == PERL_MAGIC_utf8);
            else
            else
-               PerlIO_puts(file, " ???? - please notify IZ");
+               PerlIO_puts(
+                 file,
+                " ???? - " __FILE__
+                " does not know how to handle this MG_LEN"
+               );
             PerlIO_putc(file, '\n');
         }
        if (mg->mg_type == PERL_MAGIC_utf8) {
             PerlIO_putc(file, '\n');
         }
        if (mg->mg_type == PERL_MAGIC_utf8) {
@@ -1332,9 +1296,19 @@ void
 Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv)
 {
     const char *hvname;
 Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv)
 {
     const char *hvname;
+
+    PERL_ARGS_ASSERT_DO_HV_DUMP;
+
     Perl_dump_indent(aTHX_ level, file, "%s = 0x%"UVxf, name, PTR2UV(sv));
     if (sv && (hvname = HvNAME_get(sv)))
     Perl_dump_indent(aTHX_ level, file, "%s = 0x%"UVxf, name, PTR2UV(sv));
     if (sv && (hvname = HvNAME_get(sv)))
-       PerlIO_printf(file, "\t\"%s\"\n", hvname);
+    {
+       /* we have to use pv_display and HvNAMELEN_get() so that we display the real package
+           name which quite legally could contain insane things like tabs, newlines, nulls or
+           other scary crap - this should produce sane results - except maybe for unicode package
+           names - but we will wait for someone to file a bug on that - demerphq */
+        SV * const tmpsv = newSVpvs("");
+        PerlIO_printf(file, "\t%s\n", pv_display(tmpsv, hvname, HvNAMELEN_get(sv), 0, 1024));
+    }
     else
        PerlIO_putc(file, '\n');
 }
     else
        PerlIO_putc(file, '\n');
 }
@@ -1342,6 +1316,8 @@ Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv)
 void
 Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv)
 {
 void
 Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv)
 {
+    PERL_ARGS_ASSERT_DO_GV_DUMP;
+
     Perl_dump_indent(aTHX_ level, file, "%s = 0x%"UVxf, name, PTR2UV(sv));
     if (sv && GvNAME(sv))
        PerlIO_printf(file, "\t\"%s\"\n", GvNAME(sv));
     Perl_dump_indent(aTHX_ level, file, "%s = 0x%"UVxf, name, PTR2UV(sv));
     if (sv && GvNAME(sv))
        PerlIO_printf(file, "\t\"%s\"\n", GvNAME(sv));
@@ -1352,6 +1328,8 @@ Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv)
 void
 Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv)
 {
 void
 Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv)
 {
+    PERL_ARGS_ASSERT_DO_GVGV_DUMP;
+
     Perl_dump_indent(aTHX_ level, file, "%s = 0x%"UVxf, name, PTR2UV(sv));
     if (sv && GvNAME(sv)) {
        const char *hvname;
     Perl_dump_indent(aTHX_ level, file, "%s = 0x%"UVxf, name, PTR2UV(sv));
     if (sv && GvNAME(sv)) {
        const char *hvname;
@@ -1364,6 +1342,97 @@ Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv)
        PerlIO_putc(file, '\n');
 }
 
        PerlIO_putc(file, '\n');
 }
 
+const struct flag_to_name first_sv_flags_names[] = {
+    {SVs_TEMP, "TEMP,"},
+    {SVs_OBJECT, "OBJECT,"},
+    {SVs_GMG, "GMG,"},
+    {SVs_SMG, "SMG,"},
+    {SVs_RMG, "RMG,"},
+    {SVf_IOK, "IOK,"},
+    {SVf_NOK, "NOK,"},
+    {SVf_POK, "POK,"}
+};
+
+const struct flag_to_name second_sv_flags_names[] = {
+    {SVf_OOK, "OOK,"},
+    {SVf_FAKE, "FAKE,"},
+    {SVf_READONLY, "READONLY,"},
+    {SVf_BREAK, "BREAK,"},
+    {SVf_AMAGIC, "OVERLOAD,"},
+    {SVp_IOK, "pIOK,"},
+    {SVp_NOK, "pNOK,"},
+    {SVp_POK, "pPOK,"}
+};
+
+const struct flag_to_name cv_flags_names[] = {
+    {CVf_ANON, "ANON,"},
+    {CVf_UNIQUE, "UNIQUE,"},
+    {CVf_CLONE, "CLONE,"},
+    {CVf_CLONED, "CLONED,"},
+    {CVf_CONST, "CONST,"},
+    {CVf_NODEBUG, "NODEBUG,"},
+    {CVf_LVALUE, "LVALUE,"},
+    {CVf_METHOD, "METHOD,"},
+    {CVf_WEAKOUTSIDE, "WEAKOUTSIDE,"},
+    {CVf_CVGV_RC, "CVGV_RC,"},
+    {CVf_DYNFILE, "DYNFILE,"},
+    {CVf_AUTOLOAD, "AUTOLOAD,"},
+    {CVf_HASEVAL, "HASEVAL"},
+    {CVf_SLABBED, "SLABBED,"},
+    {CVf_ISXSUB, "ISXSUB,"}
+};
+
+const struct flag_to_name hv_flags_names[] = {
+    {SVphv_SHAREKEYS, "SHAREKEYS,"},
+    {SVphv_LAZYDEL, "LAZYDEL,"},
+    {SVphv_HASKFLAGS, "HASKFLAGS,"},
+    {SVphv_REHASH, "REHASH,"},
+    {SVphv_CLONEABLE, "CLONEABLE,"}
+};
+
+const struct flag_to_name gp_flags_names[] = {
+    {GVf_INTRO, "INTRO,"},
+    {GVf_MULTI, "MULTI,"},
+    {GVf_ASSUMECV, "ASSUMECV,"},
+    {GVf_IN_PAD, "IN_PAD,"}
+};
+
+const struct flag_to_name gp_flags_imported_names[] = {
+    {GVf_IMPORTED_SV, " SV"},
+    {GVf_IMPORTED_AV, " AV"},
+    {GVf_IMPORTED_HV, " HV"},
+    {GVf_IMPORTED_CV, " CV"},
+};
+
+const struct flag_to_name regexp_flags_names[] = {
+    {RXf_PMf_MULTILINE,   "PMf_MULTILINE,"},
+    {RXf_PMf_SINGLELINE,  "PMf_SINGLELINE,"},
+    {RXf_PMf_FOLD,        "PMf_FOLD,"},
+    {RXf_PMf_EXTENDED,    "PMf_EXTENDED,"},
+    {RXf_PMf_KEEPCOPY,    "PMf_KEEPCOPY,"},
+    {RXf_ANCH_BOL,        "ANCH_BOL,"},
+    {RXf_ANCH_MBOL,       "ANCH_MBOL,"},
+    {RXf_ANCH_SBOL,       "ANCH_SBOL,"},
+    {RXf_ANCH_GPOS,       "ANCH_GPOS,"},
+    {RXf_GPOS_SEEN,       "GPOS_SEEN,"},
+    {RXf_GPOS_FLOAT,      "GPOS_FLOAT,"},
+    {RXf_LOOKBEHIND_SEEN, "LOOKBEHIND_SEEN,"},
+    {RXf_EVAL_SEEN,       "EVAL_SEEN,"},
+    {RXf_CANY_SEEN,       "CANY_SEEN,"},
+    {RXf_NOSCAN,          "NOSCAN,"},
+    {RXf_CHECK_ALL,       "CHECK_ALL,"},
+    {RXf_MATCH_UTF8,      "MATCH_UTF8,"},
+    {RXf_USE_INTUIT_NOML, "USE_INTUIT_NOML,"},
+    {RXf_USE_INTUIT_ML,   "USE_INTUIT_ML,"},
+    {RXf_INTUIT_TAIL,     "INTUIT_TAIL,"},
+    {RXf_COPY_DONE,       "COPY_DONE,"},
+    {RXf_TAINTED_SEEN,    "TAINTED_SEEN,"},
+    {RXf_TAINTED,         "TAINTED,"},
+    {RXf_START_ONLY,      "START_ONLY,"},
+    {RXf_WHITE,           "WHITE,"},
+    {RXf_NULL,            "NULL,"},
+};
+
 void
 Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim)
 {
 void
 Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim)
 {
@@ -1373,6 +1442,8 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
     U32 flags;
     U32 type;
 
     U32 flags;
     U32 type;
 
+    PERL_ARGS_ASSERT_DO_SV_DUMP;
+
     if (!sv) {
        Perl_dump_indent(aTHX_ level, file, "SV = 0\n");
        return;
     if (!sv) {
        Perl_dump_indent(aTHX_ level, file, "SV = 0\n");
        return;
@@ -1381,41 +1452,30 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
     flags = SvFLAGS(sv);
     type = SvTYPE(sv);
 
     flags = SvFLAGS(sv);
     type = SvTYPE(sv);
 
+    /* process general SV flags */
+
     d = Perl_newSVpvf(aTHX_
                   "(0x%"UVxf") at 0x%"UVxf"\n%*s  REFCNT = %"IVdf"\n%*s  FLAGS = (",
                   PTR2UV(SvANY(sv)), PTR2UV(sv),
                   (int)(PL_dumpindent*level), "", (IV)SvREFCNT(sv),
                   (int)(PL_dumpindent*level), "");
 
     d = Perl_newSVpvf(aTHX_
                   "(0x%"UVxf") at 0x%"UVxf"\n%*s  REFCNT = %"IVdf"\n%*s  FLAGS = (",
                   PTR2UV(SvANY(sv)), PTR2UV(sv),
                   (int)(PL_dumpindent*level), "", (IV)SvREFCNT(sv),
                   (int)(PL_dumpindent*level), "");
 
-    if (!(flags & SVpad_NAME && (type == SVt_PVMG || type == SVt_PVNV))) {
-       if (flags & SVs_PADSTALE)       sv_catpv(d, "PADSTALE,");
+    if (!((flags & SVpad_NAME) == SVpad_NAME
+         && (type == SVt_PVMG || type == SVt_PVNV))) {
+       if ((flags & SVs_PADMY) && (flags & SVs_PADSTALE))
+           sv_catpv(d, "PADSTALE,");
     }
     }
-    if (!(flags & SVpad_NAME && type == SVt_PVMG)) {
-       if (flags & SVs_PADTMP) sv_catpv(d, "PADTMP,");
+    if (!((flags & SVpad_NAME) == SVpad_NAME && type == SVt_PVMG)) {
+       if (!(flags & SVs_PADMY) && (flags & SVs_PADTMP))
+           sv_catpv(d, "PADTMP,");
        if (flags & SVs_PADMY)  sv_catpv(d, "PADMY,");
     }
        if (flags & SVs_PADMY)  sv_catpv(d, "PADMY,");
     }
-    if (flags & SVs_TEMP)      sv_catpv(d, "TEMP,");
-    if (flags & SVs_OBJECT)    sv_catpv(d, "OBJECT,");
-    if (flags & SVs_GMG)       sv_catpv(d, "GMG,");
-    if (flags & SVs_SMG)       sv_catpv(d, "SMG,");
-    if (flags & SVs_RMG)       sv_catpv(d, "RMG,");
-
-    if (flags & SVf_IOK)       sv_catpv(d, "IOK,");
-    if (flags & SVf_NOK)       sv_catpv(d, "NOK,");
-    if (flags & SVf_POK)       sv_catpv(d, "POK,");
+    append_flags(d, flags, first_sv_flags_names);
     if (flags & SVf_ROK)  {    
                                sv_catpv(d, "ROK,");
        if (SvWEAKREF(sv))      sv_catpv(d, "WEAKREF,");
     }
     if (flags & SVf_ROK)  {    
                                sv_catpv(d, "ROK,");
        if (SvWEAKREF(sv))      sv_catpv(d, "WEAKREF,");
     }
-    if (flags & SVf_OOK)       sv_catpv(d, "OOK,");
-    if (flags & SVf_FAKE)      sv_catpv(d, "FAKE,");
-    if (flags & SVf_READONLY)  sv_catpv(d, "READONLY,");
-    if (flags & SVf_BREAK)     sv_catpv(d, "BREAK,");
-
-    if (flags & SVf_AMAGIC)    sv_catpv(d, "OVERLOAD,");
-    if (flags & SVp_IOK)       sv_catpv(d, "pIOK,");
-    if (flags & SVp_NOK)       sv_catpv(d, "pNOK,");
-    if (flags & SVp_POK)       sv_catpv(d, "pPOK,");
+    append_flags(d, flags, second_sv_flags_names);
     if (flags & SVp_SCREAM && type != SVt_PVHV && !isGV_with_GP(sv)) {
        if (SvPCS_IMPORTED(sv))
                                sv_catpv(d, "PCS_IMPORTED,");
     if (flags & SVp_SCREAM && type != SVt_PVHV && !isGV_with_GP(sv)) {
        if (SvPCS_IMPORTED(sv))
                                sv_catpv(d, "PCS_IMPORTED,");
@@ -1423,36 +1483,20 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
                                sv_catpv(d, "SCREAM,");
     }
 
                                sv_catpv(d, "SCREAM,");
     }
 
+    /* process type-specific SV flags */
+
     switch (type) {
     case SVt_PVCV:
     case SVt_PVFM:
     switch (type) {
     case SVt_PVCV:
     case SVt_PVFM:
-       if (CvANON(sv))         sv_catpv(d, "ANON,");
-       if (CvUNIQUE(sv))       sv_catpv(d, "UNIQUE,");
-       if (CvCLONE(sv))        sv_catpv(d, "CLONE,");
-       if (CvCLONED(sv))       sv_catpv(d, "CLONED,");
-       if (CvCONST(sv))        sv_catpv(d, "CONST,");
-       if (CvNODEBUG(sv))      sv_catpv(d, "NODEBUG,");
-       if (SvCOMPILED(sv))     sv_catpv(d, "COMPILED,");
-       if (CvLVALUE(sv))       sv_catpv(d, "LVALUE,");
-       if (CvMETHOD(sv))       sv_catpv(d, "METHOD,");
-       if (CvLOCKED(sv))       sv_catpv(d, "LOCKED,");
-       if (CvWEAKOUTSIDE(sv))  sv_catpv(d, "WEAKOUTSIDE,");
+       append_flags(d, CvFLAGS(sv), cv_flags_names);
        break;
     case SVt_PVHV:
        break;
     case SVt_PVHV:
-       if (HvSHAREKEYS(sv))    sv_catpv(d, "SHAREKEYS,");
-       if (HvLAZYDEL(sv))      sv_catpv(d, "LAZYDEL,");
-       if (HvHASKFLAGS(sv))    sv_catpv(d, "HASKFLAGS,");
-       if (HvREHASH(sv))       sv_catpv(d, "REHASH,");
-       if (flags & SVphv_CLONEABLE) sv_catpv(d, "CLONEABLE,");
+       append_flags(d, flags, hv_flags_names);
        break;
     case SVt_PVGV:
     case SVt_PVLV:
        if (isGV_with_GP(sv)) {
        break;
     case SVt_PVGV:
     case SVt_PVLV:
        if (isGV_with_GP(sv)) {
-           if (GvINTRO(sv))    sv_catpv(d, "INTRO,");
-           if (GvMULTI(sv))    sv_catpv(d, "MULTI,");
-           if (GvUNIQUE(sv))   sv_catpv(d, "UNIQUE,");
-           if (GvASSUMECV(sv)) sv_catpv(d, "ASSUMECV,");
-           if (GvIN_PAD(sv))   sv_catpv(d, "IN_PAD,");
+           append_flags(d, GvFLAGS(sv), gp_flags_names);
        }
        if (isGV_with_GP(sv) && GvIMPORTED(sv)) {
            sv_catpv(d, "IMPORT");
        }
        if (isGV_with_GP(sv) && GvIMPORTED(sv)) {
            sv_catpv(d, "IMPORT");
@@ -1460,15 +1504,10 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
                sv_catpv(d, "ALL,");
            else {
                sv_catpv(d, "(");
                sv_catpv(d, "ALL,");
            else {
                sv_catpv(d, "(");
-               if (GvIMPORTED_SV(sv))  sv_catpv(d, " SV");
-               if (GvIMPORTED_AV(sv))  sv_catpv(d, " AV");
-               if (GvIMPORTED_HV(sv))  sv_catpv(d, " HV");
-               if (GvIMPORTED_CV(sv))  sv_catpv(d, " CV");
+               append_flags(d, GvFLAGS(sv), gp_flags_imported_names);
                sv_catpv(d, " ),");
            }
        }
                sv_catpv(d, " ),");
            }
        }
-       if (SvTAIL(sv))         sv_catpv(d, "TAIL,");
-       if (SvVALID(sv))        sv_catpv(d, "VALID,");
        /* FALL THROUGH */
     default:
     evaled_or_uv:
        /* FALL THROUGH */
     default:
     evaled_or_uv:
@@ -1476,6 +1515,8 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
        if (SvIsUV(sv) && !(flags & SVf_ROK))   sv_catpv(d, "IsUV,");
        break;
     case SVt_PVMG:
        if (SvIsUV(sv) && !(flags & SVf_ROK))   sv_catpv(d, "IsUV,");
        break;
     case SVt_PVMG:
+       if (SvTAIL(sv))         sv_catpv(d, "TAIL,");
+       if (SvVALID(sv))        sv_catpv(d, "VALID,");
        if (SvPAD_TYPED(sv))    sv_catpv(d, "TYPED,");
        if (SvPAD_OUR(sv))      sv_catpv(d, "OUR,");
        /* FALL THROUGH */
        if (SvPAD_TYPED(sv))    sv_catpv(d, "TYPED,");
        if (SvPAD_OUR(sv))      sv_catpv(d, "OUR,");
        /* FALL THROUGH */
@@ -1496,15 +1537,23 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
     sv_catpv(d, ")");
     s = SvPVX_const(d);
 
     sv_catpv(d, ")");
     s = SvPVX_const(d);
 
+    /* dump initial SV details */
+
 #ifdef DEBUG_LEAKING_SCALARS
 #ifdef DEBUG_LEAKING_SCALARS
-    Perl_dump_indent(aTHX_ level, file, "ALLOCATED at %s:%d %s %s%s\n",
+    Perl_dump_indent(aTHX_ level, file,
+       "ALLOCATED at %s:%d %s %s (parent 0x%"UVxf"); serial %"UVuf"\n",
        sv->sv_debug_file ? sv->sv_debug_file : "(unknown)",
        sv->sv_debug_line,
        sv->sv_debug_inpad ? "for" : "by",
        sv->sv_debug_optype ? PL_op_name[sv->sv_debug_optype]: "(none)",
        sv->sv_debug_file ? sv->sv_debug_file : "(unknown)",
        sv->sv_debug_line,
        sv->sv_debug_inpad ? "for" : "by",
        sv->sv_debug_optype ? PL_op_name[sv->sv_debug_optype]: "(none)",
-       sv->sv_debug_cloned ? " (cloned)" : "");
+       PTR2UV(sv->sv_debug_parent),
+       sv->sv_debug_serial
+    );
 #endif
     Perl_dump_indent(aTHX_ level, file, "SV = ");
 #endif
     Perl_dump_indent(aTHX_ level, file, "SV = ");
+
+    /* Dump SV type */
+
     if (type < SVt_LAST) {
        PerlIO_printf(file, "%s%s\n", svtypenames[type], s);
 
     if (type < SVt_LAST) {
        PerlIO_printf(file, "%s%s\n", svtypenames[type], s);
 
@@ -1517,9 +1566,13 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
        SvREFCNT_dec(d);
        return;
     }
        SvREFCNT_dec(d);
        return;
     }
+
+    /* Dump general SV fields */
+
     if ((type >= SVt_PVIV && type != SVt_PVAV && type != SVt_PVHV
     if ((type >= SVt_PVIV && type != SVt_PVAV && type != SVt_PVHV
-        && type != SVt_PVCV && !isGV_with_GP(sv))
-       || type == SVt_IV) {
+        && type != SVt_PVCV && type != SVt_PVFM && type != SVt_PVIO
+        && type != SVt_REGEXP && !isGV_with_GP(sv) && !SvVALID(sv))
+       || (type == SVt_IV && !SvROK(sv))) {
        if (SvIsUV(sv)
 #ifdef PERL_OLD_COPY_ON_WRITE
                       || SvIsCOW(sv)
        if (SvIsUV(sv)
 #ifdef PERL_OLD_COPY_ON_WRITE
                       || SvIsCOW(sv)
@@ -1528,8 +1581,6 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
            Perl_dump_indent(aTHX_ level, file, "  UV = %"UVuf, (UV)SvUVX(sv));
        else
            Perl_dump_indent(aTHX_ level, file, "  IV = %"IVdf, (IV)SvIVX(sv));
            Perl_dump_indent(aTHX_ level, file, "  UV = %"UVuf, (UV)SvUVX(sv));
        else
            Perl_dump_indent(aTHX_ level, file, "  IV = %"IVdf, (IV)SvIVX(sv));
-       if (SvOOK(sv))
-           PerlIO_printf(file, "  (OFFSET)");
 #ifdef PERL_OLD_COPY_ON_WRITE
        if (SvIsCOW_shared_hash(sv))
            PerlIO_printf(file, "  (HASH)");
 #ifdef PERL_OLD_COPY_ON_WRITE
        if (SvIsCOW_shared_hash(sv))
            PerlIO_printf(file, "  (HASH)");
@@ -1538,14 +1589,16 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
 #endif
        PerlIO_putc(file, '\n');
     }
 #endif
        PerlIO_putc(file, '\n');
     }
-    if ((type == SVt_PVNV || type == SVt_PVMG) && SvFLAGS(sv) & SVpad_NAME) {
+
+    if ((type == SVt_PVNV || type == SVt_PVMG)
+       && (SvFLAGS(sv) & SVpad_NAME) == SVpad_NAME) {
        Perl_dump_indent(aTHX_ level, file, "  COP_LOW = %"UVuf"\n",
                         (UV) COP_SEQ_RANGE_LOW(sv));
        Perl_dump_indent(aTHX_ level, file, "  COP_HIGH = %"UVuf"\n",
                         (UV) COP_SEQ_RANGE_HIGH(sv));
     } else if ((type >= SVt_PVNV && type != SVt_PVAV && type != SVt_PVHV
        Perl_dump_indent(aTHX_ level, file, "  COP_LOW = %"UVuf"\n",
                         (UV) COP_SEQ_RANGE_LOW(sv));
        Perl_dump_indent(aTHX_ level, file, "  COP_HIGH = %"UVuf"\n",
                         (UV) COP_SEQ_RANGE_HIGH(sv));
     } else if ((type >= SVt_PVNV && type != SVt_PVAV && type != SVt_PVHV
-               && type != SVt_PVCV && type != SVt_PVFM && !isGV_with_GP(sv)
-               && !SvVALID(sv))
+               && type != SVt_PVCV && type != SVt_PVFM  && type != SVt_REGEXP
+               && type != SVt_PVIO && !isGV_with_GP(sv) && !SvVALID(sv))
               || type == SVt_NV) {
        STORE_NUMERIC_LOCAL_SET_STANDARD();
        /* %Vg doesn't work? --jhi */
               || type == SVt_NV) {
        STORE_NUMERIC_LOCAL_SET_STANDARD();
        /* %Vg doesn't work? --jhi */
@@ -1556,30 +1609,52 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
 #endif
        RESTORE_NUMERIC_LOCAL();
     }
 #endif
        RESTORE_NUMERIC_LOCAL();
     }
+
     if (SvROK(sv)) {
        Perl_dump_indent(aTHX_ level, file, "  RV = 0x%"UVxf"\n", PTR2UV(SvRV(sv)));
        if (nest < maxnest)
            do_sv_dump(level+1, file, SvRV(sv), nest+1, maxnest, dumpops, pvlim);
     }
     if (SvROK(sv)) {
        Perl_dump_indent(aTHX_ level, file, "  RV = 0x%"UVxf"\n", PTR2UV(SvRV(sv)));
        if (nest < maxnest)
            do_sv_dump(level+1, file, SvRV(sv), nest+1, maxnest, dumpops, pvlim);
     }
+
     if (type < SVt_PV) {
        SvREFCNT_dec(d);
        return;
     }
     if (type < SVt_PV) {
        SvREFCNT_dec(d);
        return;
     }
+
     if (type <= SVt_PVLV && !isGV_with_GP(sv)) {
     if (type <= SVt_PVLV && !isGV_with_GP(sv)) {
-       if (SvPVX_const(sv)) {
-           Perl_dump_indent(aTHX_ level, file,"  PV = 0x%"UVxf" ", PTR2UV(SvPVX_const(sv)));
-           if (SvOOK(sv))
-               PerlIO_printf(file, "( %s . ) ", pv_display(d, SvPVX_const(sv)-SvIVX(sv), SvIVX(sv), 0, pvlim));
-           PerlIO_printf(file, "%s", pv_display(d, SvPVX_const(sv), SvCUR(sv), SvLEN(sv), pvlim));
-           if (SvUTF8(sv)) /* the 8?  \x{....} */
-               PerlIO_printf(file, " [UTF8 \"%s\"]", sv_uni_display(d, sv, 8 * sv_len_utf8(sv), UNI_DISPLAY_QQ));
+       const bool re = isREGEXP(sv);
+       const char * const ptr =
+           re ? RX_WRAPPED((REGEXP*)sv) : SvPVX_const(sv);
+       if (ptr) {
+           STRLEN delta;
+           if (SvOOK(sv)) {
+               SvOOK_offset(sv, delta);
+               Perl_dump_indent(aTHX_ level, file,"  OFFSET = %"UVuf"\n",
+                                (UV) delta);
+           } else {
+               delta = 0;
+           }
+           Perl_dump_indent(aTHX_ level, file,"  PV = 0x%"UVxf" ", PTR2UV(ptr));
+           if (SvOOK(sv)) {
+               PerlIO_printf(file, "( %s . ) ",
+                             pv_display(d, ptr - delta, delta, 0,
+                                        pvlim));
+           }
+           PerlIO_printf(file, "%s", pv_display(d, ptr, SvCUR(sv),
+                                                re ? 0 : SvLEN(sv),
+                                                pvlim));
+           if (SvUTF8(sv)) /* the 6?  \x{....} */
+               PerlIO_printf(file, " [UTF8 \"%s\"]", sv_uni_display(d, sv, 6 * SvCUR(sv), UNI_DISPLAY_QQ));
            PerlIO_printf(file, "\n");
            Perl_dump_indent(aTHX_ level, file, "  CUR = %"IVdf"\n", (IV)SvCUR(sv));
            PerlIO_printf(file, "\n");
            Perl_dump_indent(aTHX_ level, file, "  CUR = %"IVdf"\n", (IV)SvCUR(sv));
-           Perl_dump_indent(aTHX_ level, file, "  LEN = %"IVdf"\n", (IV)SvLEN(sv));
+           if (!re)
+               Perl_dump_indent(aTHX_ level, file, "  LEN = %"IVdf"\n",
+                                      (IV)SvLEN(sv));
        }
        else
            Perl_dump_indent(aTHX_ level, file, "  PV = 0\n");
     }
        }
        else
            Perl_dump_indent(aTHX_ level, file, "  PV = 0\n");
     }
+
     if (type >= SVt_PVMG) {
        if (type == SVt_PVMG && SvPAD_OUR(sv)) {
            HV * const ost = SvOURSTASH(sv);
     if (type >= SVt_PVMG) {
        if (type == SVt_PVMG && SvPAD_OUR(sv)) {
            HV * const ost = SvOURSTASH(sv);
@@ -1587,11 +1662,20 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
                do_hv_dump(level, file, "  OURSTASH", ost);
        } else {
            if (SvMAGIC(sv))
                do_hv_dump(level, file, "  OURSTASH", ost);
        } else {
            if (SvMAGIC(sv))
-               do_magic_dump(level, file, SvMAGIC(sv), nest, maxnest, dumpops, pvlim);
+               do_magic_dump(level, file, SvMAGIC(sv), nest+1, maxnest, dumpops, pvlim);
        }
        if (SvSTASH(sv))
            do_hv_dump(level, file, "  STASH", SvSTASH(sv));
        }
        if (SvSTASH(sv))
            do_hv_dump(level, file, "  STASH", SvSTASH(sv));
+
+       if ((type == SVt_PVMG || type == SVt_PVLV) && SvVALID(sv)) {
+           Perl_dump_indent(aTHX_ level, file, "  RARE = %u\n", (U8)BmRARE(sv));
+           Perl_dump_indent(aTHX_ level, file, "  PREVIOUS = %"UVuf"\n", (UV)BmPREVIOUS(sv));
+           Perl_dump_indent(aTHX_ level, file, "  USEFUL = %"IVdf"\n", (IV)BmUSEFUL(sv));
+       }
     }
     }
+
+    /* Dump type-specific SV fields */
+
     switch (type) {
     case SVt_PVAV:
        Perl_dump_indent(aTHX_ level, file, "  ARRAY = 0x%"UVxf, PTR2UV(AvARRAY(sv)));
     switch (type) {
     case SVt_PVAV:
        Perl_dump_indent(aTHX_ level, file, "  ARRAY = 0x%"UVxf, PTR2UV(AvARRAY(sv)));
@@ -1604,15 +1688,15 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
        Perl_dump_indent(aTHX_ level, file, "  FILL = %"IVdf"\n", (IV)AvFILLp(sv));
        Perl_dump_indent(aTHX_ level, file, "  MAX = %"IVdf"\n", (IV)AvMAX(sv));
        Perl_dump_indent(aTHX_ level, file, "  ARYLEN = 0x%"UVxf"\n", SvMAGIC(sv) ? PTR2UV(AvARYLEN(sv)) : 0);
        Perl_dump_indent(aTHX_ level, file, "  FILL = %"IVdf"\n", (IV)AvFILLp(sv));
        Perl_dump_indent(aTHX_ level, file, "  MAX = %"IVdf"\n", (IV)AvMAX(sv));
        Perl_dump_indent(aTHX_ level, file, "  ARYLEN = 0x%"UVxf"\n", SvMAGIC(sv) ? PTR2UV(AvARYLEN(sv)) : 0);
-       sv_setpvn(d, "", 0);
+       sv_setpvs(d, "");
        if (AvREAL(sv)) sv_catpv(d, ",REAL");
        if (AvREIFY(sv))        sv_catpv(d, ",REIFY");
        Perl_dump_indent(aTHX_ level, file, "  FLAGS = (%s)\n",
                         SvCUR(d) ? SvPVX_const(d) + 1 : "");
        if (AvREAL(sv)) sv_catpv(d, ",REAL");
        if (AvREIFY(sv))        sv_catpv(d, ",REIFY");
        Perl_dump_indent(aTHX_ level, file, "  FLAGS = (%s)\n",
                         SvCUR(d) ? SvPVX_const(d) + 1 : "");
-       if (nest < maxnest && av_len((AV*)sv) >= 0) {
+       if (nest < maxnest && av_len(MUTABLE_AV(sv)) >= 0) {
            int count;
            int count;
-           for (count = 0; count <=  av_len((AV*)sv) && count < maxnest; count++) {
-               SV** const elt = av_fetch((AV*)sv,count,0);
+           for (count = 0; count <=  av_len(MUTABLE_AV(sv)) && count < maxnest; count++) {
+               SV** const elt = av_fetch(MUTABLE_AV(sv),count,0);
 
                Perl_dump_indent(aTHX_ level + 1, file, "Elt No. %"IVdf"\n", (IV)count);
                if (elt)
 
                Perl_dump_indent(aTHX_ level + 1, file, "Elt No. %"IVdf"\n", (IV)count);
                if (elt)
@@ -1622,13 +1706,13 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
        break;
     case SVt_PVHV:
        Perl_dump_indent(aTHX_ level, file, "  ARRAY = 0x%"UVxf, PTR2UV(HvARRAY(sv)));
        break;
     case SVt_PVHV:
        Perl_dump_indent(aTHX_ level, file, "  ARRAY = 0x%"UVxf, PTR2UV(HvARRAY(sv)));
-       if (HvARRAY(sv) && HvKEYS(sv)) {
+       if (HvARRAY(sv) && HvUSEDKEYS(sv)) {
            /* Show distribution of HEs in the ARRAY */
            int freq[200];
 #define FREQ_MAX ((int)(sizeof freq / sizeof freq[0] - 1))
            int i;
            int max = 0;
            /* Show distribution of HEs in the ARRAY */
            int freq[200];
 #define FREQ_MAX ((int)(sizeof freq / sizeof freq[0] - 1))
            int i;
            int max = 0;
-           U32 pow2 = 2, keys = HvKEYS(sv);
+           U32 pow2 = 2, keys = HvUSEDKEYS(sv);
            NV theoret, sum = 0;
 
            PerlIO_printf(file, "  (");
            NV theoret, sum = 0;
 
            PerlIO_printf(file, "  (");
@@ -1670,13 +1754,13 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
             }
            while ((keys = keys >> 1))
                pow2 = pow2 << 1;
             }
            while ((keys = keys >> 1))
                pow2 = pow2 << 1;
-           theoret = HvKEYS(sv);
+           theoret = HvUSEDKEYS(sv);
            theoret += theoret * (theoret-1)/pow2;
            PerlIO_putc(file, '\n');
            Perl_dump_indent(aTHX_ level, file, "  hash quality = %.1"NVff"%%", theoret/sum*100);
        }
        PerlIO_putc(file, '\n');
            theoret += theoret * (theoret-1)/pow2;
            PerlIO_putc(file, '\n');
            Perl_dump_indent(aTHX_ level, file, "  hash quality = %.1"NVff"%%", theoret/sum*100);
        }
        PerlIO_putc(file, '\n');
-       Perl_dump_indent(aTHX_ level, file, "  KEYS = %"IVdf"\n", (IV)HvKEYS(sv));
+       Perl_dump_indent(aTHX_ level, file, "  KEYS = %"IVdf"\n", (IV)HvUSEDKEYS(sv));
        Perl_dump_indent(aTHX_ level, file, "  FILL = %"IVdf"\n", (IV)HvFILL(sv));
        Perl_dump_indent(aTHX_ level, file, "  MAX = %"IVdf"\n", (IV)HvMAX(sv));
        Perl_dump_indent(aTHX_ level, file, "  RITER = %"IVdf"\n", (IV)HvRITER_get(sv));
        Perl_dump_indent(aTHX_ level, file, "  FILL = %"IVdf"\n", (IV)HvFILL(sv));
        Perl_dump_indent(aTHX_ level, file, "  MAX = %"IVdf"\n", (IV)HvMAX(sv));
        Perl_dump_indent(aTHX_ level, file, "  RITER = %"IVdf"\n", (IV)HvRITER_get(sv));
@@ -1693,45 +1777,134 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
                Perl_dump_indent(aTHX_ level, file, "  NAME = \"%s\"\n", hvname);
        }
        if (SvOOK(sv)) {
                Perl_dump_indent(aTHX_ level, file, "  NAME = \"%s\"\n", hvname);
        }
        if (SvOOK(sv)) {
-           const AV * const backrefs = *Perl_hv_backreferences_p(aTHX_ (HV*)sv);
+           AV * const backrefs
+               = *Perl_hv_backreferences_p(aTHX_ MUTABLE_HV(sv));
+           struct mro_meta * const meta = HvAUX(sv)->xhv_mro_meta;
+           if (HvAUX(sv)->xhv_name_count)
+               Perl_dump_indent(aTHX_
+                level, file, "  NAMECOUNT = %"IVdf"\n",
+                (IV)HvAUX(sv)->xhv_name_count
+               );
+           if (HvAUX(sv)->xhv_name_u.xhvnameu_name && HvENAME_HEK_NN(sv)) {
+               const I32 count = HvAUX(sv)->xhv_name_count;
+               if (count) {
+                   SV * const names = newSVpvs_flags("", SVs_TEMP);
+                   /* The starting point is the first element if count is
+                      positive and the second element if count is negative. */
+                   HEK *const *hekp = HvAUX(sv)->xhv_name_u.xhvnameu_names
+                       + (count < 0 ? 1 : 0);
+                   HEK *const *const endp = HvAUX(sv)->xhv_name_u.xhvnameu_names
+                       + (count < 0 ? -count : count);
+                   while (hekp < endp) {
+                       if (*hekp) {
+                           sv_catpvs(names, ", \"");
+                           sv_catpvn(names, HEK_KEY(*hekp), HEK_LEN(*hekp));
+                           sv_catpvs(names, "\"");
+                       } else {
+                           /* This should never happen. */
+                           sv_catpvs(names, ", (null)");
+                       }
+                       ++hekp;
+                   }
+                   Perl_dump_indent(aTHX_
+                    level, file, "  ENAME = %s\n", SvPV_nolen(names)+2
+                   );
+               }
+               else
+                   Perl_dump_indent(aTHX_
+                    level, file, "  ENAME = \"%s\"\n", HvENAME_get(sv)
+                   );
+           }
            if (backrefs) {
                Perl_dump_indent(aTHX_ level, file, "  BACKREFS = 0x%"UVxf"\n",
                                 PTR2UV(backrefs));
            if (backrefs) {
                Perl_dump_indent(aTHX_ level, file, "  BACKREFS = 0x%"UVxf"\n",
                                 PTR2UV(backrefs));
-               do_sv_dump(level+1, file, (SV*)backrefs, nest+1, maxnest,
+               do_sv_dump(level+1, file, MUTABLE_SV(backrefs), nest+1, maxnest,
+                          dumpops, pvlim);
+           }
+           if (meta) {
+               /* FIXME - mro_algs kflags can signal a UTF-8 name.  */
+               Perl_dump_indent(aTHX_ level, file, "  MRO_WHICH = \"%.*s\" (0x%"UVxf")\n",
+                                (int)meta->mro_which->length,
+                                meta->mro_which->name,
+                                PTR2UV(meta->mro_which));
+               Perl_dump_indent(aTHX_ level, file, "  CACHE_GEN = 0x%"UVxf"\n",
+                                (UV)meta->cache_gen);
+               Perl_dump_indent(aTHX_ level, file, "  PKG_GEN = 0x%"UVxf"\n",
+                                (UV)meta->pkg_gen);
+               if (meta->mro_linear_all) {
+                   Perl_dump_indent(aTHX_ level, file, "  MRO_LINEAR_ALL = 0x%"UVxf"\n",
+                                PTR2UV(meta->mro_linear_all));
+               do_sv_dump(level+1, file, MUTABLE_SV(meta->mro_linear_all), nest+1, maxnest,
+                          dumpops, pvlim);
+               }
+               if (meta->mro_linear_current) {
+                   Perl_dump_indent(aTHX_ level, file, "  MRO_LINEAR_CURRENT = 0x%"UVxf"\n",
+                                PTR2UV(meta->mro_linear_current));
+               do_sv_dump(level+1, file, MUTABLE_SV(meta->mro_linear_current), nest+1, maxnest,
+                          dumpops, pvlim);
+               }
+               if (meta->mro_nextmethod) {
+                   Perl_dump_indent(aTHX_ level, file, "  MRO_NEXTMETHOD = 0x%"UVxf"\n",
+                                PTR2UV(meta->mro_nextmethod));
+               do_sv_dump(level+1, file, MUTABLE_SV(meta->mro_nextmethod), nest+1, maxnest,
+                          dumpops, pvlim);
+               }
+               if (meta->isa) {
+                   Perl_dump_indent(aTHX_ level, file, "  ISA = 0x%"UVxf"\n",
+                                PTR2UV(meta->isa));
+               do_sv_dump(level+1, file, MUTABLE_SV(meta->isa), nest+1, maxnest,
                           dumpops, pvlim);
                           dumpops, pvlim);
+               }
            }
        }
            }
        }
-       if (nest < maxnest && !HvEITER_get(sv)) { /* Try to preserve iterator */
+       if (nest < maxnest) {
+           HV * const hv = MUTABLE_HV(sv);
+           STRLEN i;
            HE *he;
            HE *he;
-           HV * const hv = (HV*)sv;
-           int count = maxnest - nest;
 
 
-           hv_iterinit(hv);
-           while ((he = hv_iternext_flags(hv, HV_ITERNEXT_WANTPLACEHOLDERS))
-                   && count--) {
+           if (HvARRAY(hv)) {
+               int count = maxnest - nest;
+               for (i=0; i <= HvMAX(hv); i++) {
+                   for (he = HvARRAY(hv)[i]; he; he = HeNEXT(he)) {
+                       U32 hash;
+                       SV * keysv;
+                       const char * keypv;
+                       SV * elt;
                STRLEN len;
                STRLEN len;
-               const U32 hash = HeHASH(he);
-               SV * const keysv = hv_iterkeysv(he);
-               const char * const keypv = SvPV_const(keysv, len);
-               SV * const elt = hv_iterval(hv, he);
+
+                       if (count-- <= 0) goto DONEHV;
+
+                       hash = HeHASH(he);
+                       keysv = hv_iterkeysv(he);
+                       keypv = SvPV_const(keysv, len);
+                       elt = HeVAL(he);
 
                Perl_dump_indent(aTHX_ level+1, file, "Elt %s ", pv_display(d, keypv, len, 0, pvlim));
                if (SvUTF8(keysv))
 
                Perl_dump_indent(aTHX_ level+1, file, "Elt %s ", pv_display(d, keypv, len, 0, pvlim));
                if (SvUTF8(keysv))
-                   PerlIO_printf(file, "[UTF8 \"%s\"] ", sv_uni_display(d, keysv, 8 * sv_len_utf8(keysv), UNI_DISPLAY_QQ));
+                   PerlIO_printf(file, "[UTF8 \"%s\"] ", sv_uni_display(d, keysv, 6 * SvCUR(keysv), UNI_DISPLAY_QQ));
+                       if (HvEITER_get(hv) == he)
+                           PerlIO_printf(file, "[CURRENT] ");
                if (HeKREHASH(he))
                    PerlIO_printf(file, "[REHASH] ");
                if (HeKREHASH(he))
                    PerlIO_printf(file, "[REHASH] ");
-               PerlIO_printf(file, "HASH = 0x%"UVxf"\n", (UV)hash);
+                       PerlIO_printf(file, "HASH = 0x%"UVxf"\n", (UV) hash);
                do_sv_dump(level+1, file, elt, nest+1, maxnest, dumpops, pvlim);
            }
                do_sv_dump(level+1, file, elt, nest+1, maxnest, dumpops, pvlim);
            }
-           hv_iterinit(hv);            /* Return to status quo */
+               }
+             DONEHV:;
+           }
        }
        break;
        }
        break;
+
     case SVt_PVCV:
     case SVt_PVCV:
-       if (SvPOK(sv)) {
+       if (CvAUTOLOAD(sv)) {
            STRLEN len;
            STRLEN len;
-           const char *const proto =  SvPV_const(sv, len);
+           const char *const name =  SvPV_const(sv, len);
+           Perl_dump_indent(aTHX_ level, file, "  AUTOLOAD = \"%.*s\"\n",
+                            (int) len, name);
+       }
+       if (SvPOK(sv)) {
            Perl_dump_indent(aTHX_ level, file, "  PROTOTYPE = \"%.*s\"\n",
            Perl_dump_indent(aTHX_ level, file, "  PROTOTYPE = \"%.*s\"\n",
-                            (int) len, proto);
+                            (int) CvPROTOLEN(sv), CvPROTO(sv));
        }
        /* FALL THROUGH */
     case SVt_PVFM:
        }
        /* FALL THROUGH */
     case SVt_PVFM:
@@ -1749,7 +1922,7 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
                do_op_dump(level+1, file, CvROOT(sv));
            }
        } else {
                do_op_dump(level+1, file, CvROOT(sv));
            }
        } else {
-           SV * const constant = cv_const_sv((CV *)sv);
+           SV * const constant = cv_const_sv((const CV *)sv);
 
            Perl_dump_indent(aTHX_ level, file, "  XSUB = 0x%"UVxf"\n", PTR2UV(CvXSUB(sv)));
 
 
            Perl_dump_indent(aTHX_ level, file, "  XSUB = 0x%"UVxf"\n", PTR2UV(CvXSUB(sv)));
 
@@ -1764,13 +1937,14 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
                                 (IV)CvXSUBANY(sv).any_i32);
            }
        }
                                 (IV)CvXSUBANY(sv).any_i32);
            }
        }
-       do_gvgv_dump(level, file, "  GVGV::GV", CvGV(sv));
+       if (CvNAMED(sv))
+           Perl_dump_indent(aTHX_ level, file, "  NAME = \"%s\"\n",
+                                  HEK_KEY(CvNAME_HEK((CV *)sv)));
+       else do_gvgv_dump(level, file, "  GVGV::GV", CvGV(sv));
        Perl_dump_indent(aTHX_ level, file, "  FILE = \"%s\"\n", CvFILE(sv));
        Perl_dump_indent(aTHX_ level, file, "  DEPTH = %"IVdf"\n", (IV)CvDEPTH(sv));
        Perl_dump_indent(aTHX_ level, file, "  FLAGS = 0x%"UVxf"\n", (UV)CvFLAGS(sv));
        Perl_dump_indent(aTHX_ level, file, "  OUTSIDE_SEQ = %"UVuf"\n", (UV)CvOUTSIDE_SEQ(sv));
        Perl_dump_indent(aTHX_ level, file, "  FILE = \"%s\"\n", CvFILE(sv));
        Perl_dump_indent(aTHX_ level, file, "  DEPTH = %"IVdf"\n", (IV)CvDEPTH(sv));
        Perl_dump_indent(aTHX_ level, file, "  FLAGS = 0x%"UVxf"\n", (UV)CvFLAGS(sv));
        Perl_dump_indent(aTHX_ level, file, "  OUTSIDE_SEQ = %"UVuf"\n", (UV)CvOUTSIDE_SEQ(sv));
-       if (type == SVt_PVFM)
-           Perl_dump_indent(aTHX_ level, file, "  LINES = %"IVdf"\n", (IV)FmLINES(sv));
        Perl_dump_indent(aTHX_ level, file, "  PADLIST = 0x%"UVxf"\n", PTR2UV(CvPADLIST(sv)));
        if (nest < maxnest) {
            do_dump_pad(level+1, file, CvPADLIST(sv), 0);
        Perl_dump_indent(aTHX_ level, file, "  PADLIST = 0x%"UVxf"\n", PTR2UV(CvPADLIST(sv)));
        if (nest < maxnest) {
            do_dump_pad(level+1, file, CvPADLIST(sv), 0);
@@ -1786,8 +1960,9 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
                         : CvGV(outside) ? GvNAME(CvGV(outside)) : "UNDEFINED"));
        }
        if (nest < maxnest && (CvCLONE(sv) || CvCLONED(sv)))
                         : CvGV(outside) ? GvNAME(CvGV(outside)) : "UNDEFINED"));
        }
        if (nest < maxnest && (CvCLONE(sv) || CvCLONED(sv)))
-           do_sv_dump(level+1, file, (SV*)CvOUTSIDE(sv), nest+1, maxnest, dumpops, pvlim);
+           do_sv_dump(level+1, file, MUTABLE_SV(CvOUTSIDE(sv)), nest+1, maxnest, dumpops, pvlim);
        break;
        break;
+
     case SVt_PVGV:
     case SVt_PVLV:
        if (type == SVt_PVLV) {
     case SVt_PVGV:
     case SVt_PVLV:
        if (type == SVt_PVLV) {
@@ -1795,16 +1970,12 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
            Perl_dump_indent(aTHX_ level, file, "  TARGOFF = %"IVdf"\n", (IV)LvTARGOFF(sv));
            Perl_dump_indent(aTHX_ level, file, "  TARGLEN = %"IVdf"\n", (IV)LvTARGLEN(sv));
            Perl_dump_indent(aTHX_ level, file, "  TARG = 0x%"UVxf"\n", PTR2UV(LvTARG(sv)));
            Perl_dump_indent(aTHX_ level, file, "  TARGOFF = %"IVdf"\n", (IV)LvTARGOFF(sv));
            Perl_dump_indent(aTHX_ level, file, "  TARGLEN = %"IVdf"\n", (IV)LvTARGLEN(sv));
            Perl_dump_indent(aTHX_ level, file, "  TARG = 0x%"UVxf"\n", PTR2UV(LvTARG(sv)));
+           Perl_dump_indent(aTHX_ level, file, "  FLAGS = %"IVdf"\n", (IV)LvFLAGS(sv));
            if (LvTYPE(sv) != 't' && LvTYPE(sv) != 'T')
                do_sv_dump(level+1, file, LvTARG(sv), nest+1, maxnest,
                    dumpops, pvlim);
        }
            if (LvTYPE(sv) != 't' && LvTYPE(sv) != 'T')
                do_sv_dump(level+1, file, LvTARG(sv), nest+1, maxnest,
                    dumpops, pvlim);
        }
-       if (SvVALID(sv)) {
-           Perl_dump_indent(aTHX_ level, file, "  FLAGS = %u\n", (U8)BmFLAGS(sv));
-           Perl_dump_indent(aTHX_ level, file, "  RARE = %u\n", (U8)BmRARE(sv));
-           Perl_dump_indent(aTHX_ level, file, "  PREVIOUS = %"UVuf"\n", (UV)BmPREVIOUS(sv));
-           Perl_dump_indent(aTHX_ level, file, "  USEFUL = %"IVdf"\n", (IV)BmUSEFUL(sv));
-       }
+       if (isREGEXP(sv)) goto dumpregexp;
        if (!isGV_with_GP(sv))
            break;
        Perl_dump_indent(aTHX_ level, file, "  NAME = \"%s\"\n", GvNAME(sv));
        if (!isGV_with_GP(sv))
            break;
        Perl_dump_indent(aTHX_ level, file, "  NAME = \"%s\"\n", GvNAME(sv));
@@ -1841,8 +2012,8 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
        else {
            Perl_dump_indent(aTHX_ level, file, "  TOP_GV = 0x%"UVxf"\n",
                             PTR2UV(IoTOP_GV(sv)));
        else {
            Perl_dump_indent(aTHX_ level, file, "  TOP_GV = 0x%"UVxf"\n",
                             PTR2UV(IoTOP_GV(sv)));
-           do_sv_dump (level+1, file, (SV *) IoTOP_GV(sv), nest+1, maxnest,
-                       dumpops, pvlim);
+           do_sv_dump (level+1, file, MUTABLE_SV(IoTOP_GV(sv)), nest+1,
+                       maxnest, dumpops, pvlim);
        }
        /* Source filters hide things that are not GVs in these three, so let's
           be careful out there.  */
        }
        /* Source filters hide things that are not GVs in these three, so let's
           be careful out there.  */
@@ -1853,8 +2024,8 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
        else {
            Perl_dump_indent(aTHX_ level, file, "  FMT_GV = 0x%"UVxf"\n",
                             PTR2UV(IoFMT_GV(sv)));
        else {
            Perl_dump_indent(aTHX_ level, file, "  FMT_GV = 0x%"UVxf"\n",
                             PTR2UV(IoFMT_GV(sv)));
-           do_sv_dump (level+1, file, (SV *) IoFMT_GV(sv), nest+1, maxnest,
-                       dumpops, pvlim);
+           do_sv_dump (level+1, file, MUTABLE_SV(IoFMT_GV(sv)), nest+1,
+                       maxnest, dumpops, pvlim);
        }
         if (IoBOTTOM_NAME(sv))
             Perl_dump_indent(aTHX_ level, file, "  BOTTOM_NAME = \"%s\"\n", IoBOTTOM_NAME(sv));
        }
         if (IoBOTTOM_NAME(sv))
             Perl_dump_indent(aTHX_ level, file, "  BOTTOM_NAME = \"%s\"\n", IoBOTTOM_NAME(sv));
@@ -1863,16 +2034,76 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo
        else {
            Perl_dump_indent(aTHX_ level, file, "  BOTTOM_GV = 0x%"UVxf"\n",
                             PTR2UV(IoBOTTOM_GV(sv)));
        else {
            Perl_dump_indent(aTHX_ level, file, "  BOTTOM_GV = 0x%"UVxf"\n",
                             PTR2UV(IoBOTTOM_GV(sv)));
-           do_sv_dump (level+1, file, (SV *) IoBOTTOM_GV(sv), nest+1, maxnest,
-                       dumpops, pvlim);
+           do_sv_dump (level+1, file, MUTABLE_SV(IoBOTTOM_GV(sv)), nest+1,
+                       maxnest, dumpops, pvlim);
        }
        }
-       Perl_dump_indent(aTHX_ level, file, "  SUBPROCESS = %"IVdf"\n", (IV)IoSUBPROCESS(sv));
        if (isPRINT(IoTYPE(sv)))
             Perl_dump_indent(aTHX_ level, file, "  TYPE = '%c'\n", IoTYPE(sv));
        else
             Perl_dump_indent(aTHX_ level, file, "  TYPE = '\\%o'\n", IoTYPE(sv));
        Perl_dump_indent(aTHX_ level, file, "  FLAGS = 0x%"UVxf"\n", (UV)IoFLAGS(sv));
        break;
        if (isPRINT(IoTYPE(sv)))
             Perl_dump_indent(aTHX_ level, file, "  TYPE = '%c'\n", IoTYPE(sv));
        else
             Perl_dump_indent(aTHX_ level, file, "  TYPE = '\\%o'\n", IoTYPE(sv));
        Perl_dump_indent(aTHX_ level, file, "  FLAGS = 0x%"UVxf"\n", (UV)IoFLAGS(sv));
        break;
+    case SVt_REGEXP:
+      dumpregexp:
+       {
+           struct regexp * const r = ReANY((REGEXP*)sv);
+           flags = RX_EXTFLAGS((REGEXP*)sv);
+           sv_setpv(d,"");
+           append_flags(d, flags, regexp_flags_names);
+           if (*(SvEND(d) - 1) == ',') {
+               SvCUR_set(d, SvCUR(d) - 1);
+               SvPVX(d)[SvCUR(d)] = '\0';
+           }
+           Perl_dump_indent(aTHX_ level, file, "  EXTFLAGS = 0x%"UVxf" (%s)\n",
+                               (UV)flags, SvPVX_const(d));
+           Perl_dump_indent(aTHX_ level, file, "  INTFLAGS = 0x%"UVxf"\n",
+                               (UV)(r->intflags));
+           Perl_dump_indent(aTHX_ level, file, "  NPARENS = %"UVuf"\n",
+                               (UV)(r->nparens));
+           Perl_dump_indent(aTHX_ level, file, "  LASTPAREN = %"UVuf"\n",
+                               (UV)(r->lastparen));
+           Perl_dump_indent(aTHX_ level, file, "  LASTCLOSEPAREN = %"UVuf"\n",
+                               (UV)(r->lastcloseparen));
+           Perl_dump_indent(aTHX_ level, file, "  MINLEN = %"IVdf"\n",
+                               (IV)(r->minlen));
+           Perl_dump_indent(aTHX_ level, file, "  MINLENRET = %"IVdf"\n",
+                               (IV)(r->minlenret));
+           Perl_dump_indent(aTHX_ level, file, "  GOFS = %"UVuf"\n",
+                               (UV)(r->gofs));
+           Perl_dump_indent(aTHX_ level, file, "  PRE_PREFIX = %"UVuf"\n",
+                               (UV)(r->pre_prefix));
+           Perl_dump_indent(aTHX_ level, file, "  SUBLEN = %"IVdf"\n",
+                               (IV)(r->sublen));
+           Perl_dump_indent(aTHX_ level, file, "  SUBOFFSET = %"IVdf"\n",
+                               (IV)(r->suboffset));
+           Perl_dump_indent(aTHX_ level, file, "  SUBCOFFSET = %"IVdf"\n",
+                               (IV)(r->subcoffset));
+           if (r->subbeg)
+               Perl_dump_indent(aTHX_ level, file, "  SUBBEG = 0x%"UVxf" %s\n",
+                           PTR2UV(r->subbeg),
+                           pv_display(d, r->subbeg, r->sublen, 50, pvlim));
+           else
+               Perl_dump_indent(aTHX_ level, file, "  SUBBEG = 0x0\n");
+           Perl_dump_indent(aTHX_ level, file, "  ENGINE = 0x%"UVxf"\n",
+                               PTR2UV(r->engine));
+           Perl_dump_indent(aTHX_ level, file, "  MOTHER_RE = 0x%"UVxf"\n",
+                               PTR2UV(r->mother_re));
+           Perl_dump_indent(aTHX_ level, file, "  PAREN_NAMES = 0x%"UVxf"\n",
+                               PTR2UV(r->paren_names));
+           Perl_dump_indent(aTHX_ level, file, "  SUBSTRS = 0x%"UVxf"\n",
+                               PTR2UV(r->substrs));
+           Perl_dump_indent(aTHX_ level, file, "  PPRIVATE = 0x%"UVxf"\n",
+                               PTR2UV(r->pprivate));
+           Perl_dump_indent(aTHX_ level, file, "  OFFS = 0x%"UVxf"\n",
+                               PTR2UV(r->offs));
+           Perl_dump_indent(aTHX_ level, file, "  QR_ANONCV = 0x%"UVxf"\n",
+                               PTR2UV(r->qr_anoncv));
+#ifdef PERL_OLD_COPY_ON_WRITE
+           Perl_dump_indent(aTHX_ level, file, "  SAVED_COPY = 0x%"UVxf"\n",
+                               PTR2UV(r->saved_copy));
+#endif
+       }
+       break;
     }
     SvREFCNT_dec(d);
 }
     }
     SvREFCNT_dec(d);
 }
@@ -1881,7 +2112,13 @@ void
 Perl_sv_dump(pTHX_ SV *sv)
 {
     dVAR;
 Perl_sv_dump(pTHX_ SV *sv)
 {
     dVAR;
-    do_sv_dump(0, Perl_debug_log, sv, 0, 0, 0, 0);
+
+    PERL_ARGS_ASSERT_SV_DUMP;
+
+    if (SvROK(sv))
+       do_sv_dump(0, Perl_debug_log, sv, 0, 4, 0, 0);
+    else
+       do_sv_dump(0, Perl_debug_log, sv, 0, 0, 0, 0);
 }
 
 int
 }
 
 int
@@ -1889,14 +2126,12 @@ Perl_runops_debug(pTHX)
 {
     dVAR;
     if (!PL_op) {
 {
     dVAR;
     if (!PL_op) {
-       if (ckWARN_d(WARN_DEBUGGING))
-           Perl_warner(aTHX_ packWARN(WARN_DEBUGGING), "NULL OP IN RUN");
+       Perl_ck_warner_d(aTHX_ packWARN(WARN_DEBUGGING), "NULL OP IN RUN");
        return 0;
     }
 
     DEBUG_l(Perl_deb(aTHX_ "Entering new RUNOPS level\n"));
     do {
        return 0;
     }
 
     DEBUG_l(Perl_deb(aTHX_ "Entering new RUNOPS level\n"));
     do {
-       PERL_ASYNC_CHECK();
        if (PL_debug) {
            if (PL_watchaddr && (*PL_watchaddr != PL_watchok))
                PerlIO_printf(Perl_debug_log,
        if (PL_debug) {
            if (PL_watchaddr && (*PL_watchaddr != PL_watchok))
                PerlIO_printf(Perl_debug_log,
@@ -1916,7 +2151,9 @@ Perl_runops_debug(pTHX)
            if (DEBUG_t_TEST_) debop(PL_op);
            if (DEBUG_P_TEST_) debprof(PL_op);
        }
            if (DEBUG_t_TEST_) debop(PL_op);
            if (DEBUG_P_TEST_) debprof(PL_op);
        }
-    } while ((PL_op = CALL_FPTR(PL_op->op_ppaddr)(aTHX)));
+
+        OP_ENTRY_PROBE(OP_NAME(PL_op));
+    } while ((PL_op = PL_op->op_ppaddr(aTHX)));
     DEBUG_l(Perl_deb(aTHX_ "leaving RUNOPS level\n"));
 
     TAINT_NOT;
     DEBUG_l(Perl_deb(aTHX_ "leaving RUNOPS level\n"));
 
     TAINT_NOT;
@@ -1927,13 +2164,24 @@ I32
 Perl_debop(pTHX_ const OP *o)
 {
     dVAR;
 Perl_debop(pTHX_ const OP *o)
 {
     dVAR;
+
+    PERL_ARGS_ASSERT_DEBOP;
+
     if (CopSTASH_eq(PL_curcop, PL_debstash) && !DEBUG_J_TEST_)
        return 0;
 
     Perl_deb(aTHX_ "%s", OP_NAME(o));
     switch (o->op_type) {
     case OP_CONST:
     if (CopSTASH_eq(PL_curcop, PL_debstash) && !DEBUG_J_TEST_)
        return 0;
 
     Perl_deb(aTHX_ "%s", OP_NAME(o));
     switch (o->op_type) {
     case OP_CONST:
-       PerlIO_printf(Perl_debug_log, "(%s)", SvPEEK(cSVOPo_sv));
+    case OP_HINTSEVAL:
+       /* With ITHREADS, consts are stored in the pad, and the right pad
+        * may not be active here, so check.
+        * Looks like only during compiling the pads are illegal.
+        */
+#ifdef USE_ITHREADS
+       if ((((SVOP*)o)->op_sv) || !IN_PERL_COMPILETIME)
+#endif
+           PerlIO_printf(Perl_debug_log, "(%s)", SvPEEK(cSVOPo_sv));
        break;
     case OP_GVSV:
     case OP_GV:
        break;
     case OP_GVSV:
     case OP_GV:
@@ -1951,25 +2199,45 @@ Perl_debop(pTHX_ const OP *o)
        else
            PerlIO_printf(Perl_debug_log, "(NULL)");
        break;
        else
            PerlIO_printf(Perl_debug_log, "(NULL)");
        break;
+
+    {
+        int count;
+
     case OP_PADSV:
     case OP_PADAV:
     case OP_PADHV:
     case OP_PADSV:
     case OP_PADAV:
     case OP_PADHV:
-       {
+        count = 1;
+        goto dump_padop;
+    case OP_PADRANGE:
+        count = o->op_private & OPpPADRANGE_COUNTMASK;
+    dump_padop:
        /* print the lexical's name */
        /* print the lexical's name */
-       CV * const cv = deb_curcv(cxstack_ix);
-       SV *sv;
-        if (cv) {
-           AV * const padlist = CvPADLIST(cv);
-            AV * const comppad = (AV*)(*av_fetch(padlist, 0, FALSE));
-            sv = *av_fetch(comppad, o->op_targ, FALSE);
-        } else
-            sv = NULL;
-        if (sv)
-           PerlIO_printf(Perl_debug_log, "(%s)", SvPV_nolen_const(sv));
-        else
-           PerlIO_printf(Perl_debug_log, "[%"UVuf"]", (UV)o->op_targ);
-       }
+        {
+            CV * const cv = deb_curcv(cxstack_ix);
+            SV *sv;
+            PAD * comppad = NULL;
+            int i;
+
+            if (cv) {
+                PADLIST * const padlist = CvPADLIST(cv);
+                comppad = *PadlistARRAY(padlist);
+            }
+            PerlIO_printf(Perl_debug_log, "(");
+            for (i = 0; i < count; i++) {
+                if (comppad &&
+                        (sv = *av_fetch(comppad, o->op_targ + i, FALSE)))
+                    PerlIO_printf(Perl_debug_log, "%s", SvPV_nolen_const(sv));
+                else
+                    PerlIO_printf(Perl_debug_log, "[%"UVuf"]",
+                            (UV)o->op_targ+i);
+                if (i < count-1)
+                    PerlIO_printf(Perl_debug_log, ",");
+            }
+            PerlIO_printf(Perl_debug_log, ")");
+        }
         break;
         break;
+    }
+
     default:
        break;
     }
     default:
        break;
     }
@@ -1985,7 +2253,7 @@ S_deb_curcv(pTHX_ const I32 ix)
     if (CxTYPE(cx) == CXt_SUB || CxTYPE(cx) == CXt_FORMAT)
         return cx->blk_sub.cv;
     else if (CxTYPE(cx) == CXt_EVAL && !CxTRYBLOCK(cx))
     if (CxTYPE(cx) == CXt_SUB || CxTYPE(cx) == CXt_FORMAT)
         return cx->blk_sub.cv;
     else if (CxTYPE(cx) == CXt_EVAL && !CxTRYBLOCK(cx))
-        return PL_compcv;
+        return cx->blk_eval.cv;
     else if (ix == 0 && PL_curstackinfo->si_type == PERLSI_MAIN)
         return PL_main_cv;
     else if (ix <= 0)
     else if (ix == 0 && PL_curstackinfo->si_type == PERLSI_MAIN)
         return PL_main_cv;
     else if (ix <= 0)
@@ -1998,6 +2266,9 @@ void
 Perl_watch(pTHX_ char **addr)
 {
     dVAR;
 Perl_watch(pTHX_ char **addr)
 {
     dVAR;
+
+    PERL_ARGS_ASSERT_WATCH;
+
     PL_watchaddr = addr;
     PL_watchok = *addr;
     PerlIO_printf(Perl_debug_log, "WATCHING, %"UVxf" is currently %"UVxf"\n",
     PL_watchaddr = addr;
     PL_watchok = *addr;
     PerlIO_printf(Perl_debug_log, "WATCHING, %"UVxf" is currently %"UVxf"\n",
@@ -2008,6 +2279,9 @@ STATIC void
 S_debprof(pTHX_ const OP *o)
 {
     dVAR;
 S_debprof(pTHX_ const OP *o)
 {
     dVAR;
+
+    PERL_ARGS_ASSERT_DEBPROF;
+
     if (!DEBUG_J_TEST_ && CopSTASH_eq(PL_curcop, PL_debstash))
        return;
     if (!PL_profiledata)
     if (!DEBUG_J_TEST_ && CopSTASH_eq(PL_curcop, PL_debstash))
        return;
     if (!PL_profiledata)
@@ -2039,6 +2313,9 @@ STATIC void
 S_xmldump_attr(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
 {
     va_list args;
 S_xmldump_attr(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
 {
     va_list args;
+
+    PERL_ARGS_ASSERT_XMLDUMP_ATTR;
+
     PerlIO_printf(file, "\n    ");
     va_start(args, pat);
     xmldump_vindent(level, file, pat, &args);
     PerlIO_printf(file, "\n    ");
     va_start(args, pat);
     xmldump_vindent(level, file, pat, &args);
@@ -2050,6 +2327,7 @@ void
 Perl_xmldump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
 {
     va_list args;
 Perl_xmldump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
 {
     va_list args;
+    PERL_ARGS_ASSERT_XMLDUMP_INDENT;
     va_start(args, pat);
     xmldump_vindent(level, file, pat, &args);
     va_end(args);
     va_start(args, pat);
     xmldump_vindent(level, file, pat, &args);
     va_end(args);
@@ -2058,6 +2336,8 @@ Perl_xmldump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
 void
 Perl_xmldump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args)
 {
 void
 Perl_xmldump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args)
 {
+    PERL_ARGS_ASSERT_XMLDUMP_VINDENT;
+
     PerlIO_printf(file, "%*s", (int)(level*PL_dumpindent), "");
     PerlIO_vprintf(file, pat, *args);
 }
     PerlIO_printf(file, "%*s", (int)(level*PL_dumpindent), "");
     PerlIO_vprintf(file, pat, *args);
 }
@@ -2065,9 +2345,17 @@ Perl_xmldump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *ar
 void
 Perl_xmldump_all(pTHX)
 {
 void
 Perl_xmldump_all(pTHX)
 {
+    xmldump_all_perl(FALSE);
+}
+
+void
+Perl_xmldump_all_perl(pTHX_ bool justperl PERL_UNUSED_DECL)
+{
     PerlIO_setlinebuf(PL_xmlfp);
     if (PL_main_root)
        op_xmldump(PL_main_root);
     PerlIO_setlinebuf(PL_xmlfp);
     if (PL_main_root)
        op_xmldump(PL_main_root);
+    /* someday we might call this, when it outputs XML: */
+    /* xmldump_packsubs_perl(PL_defstash, justperl); */
     if (PL_xmlfp != (PerlIO*)PerlIO_stdout())
        PerlIO_close(PL_xmlfp);
     PL_xmlfp = 0;
     if (PL_xmlfp != (PerlIO*)PerlIO_stdout())
        PerlIO_close(PL_xmlfp);
     PL_xmlfp = 0;
@@ -2076,24 +2364,33 @@ Perl_xmldump_all(pTHX)
 void
 Perl_xmldump_packsubs(pTHX_ const HV *stash)
 {
 void
 Perl_xmldump_packsubs(pTHX_ const HV *stash)
 {
+    PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS;
+    xmldump_packsubs_perl(stash, FALSE);
+}
+
+void
+Perl_xmldump_packsubs_perl(pTHX_ const HV *stash, bool justperl)
+{
     I32        i;
     HE *entry;
 
     I32        i;
     HE *entry;
 
+    PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS_PERL;
+
     if (!HvARRAY(stash))
        return;
     for (i = 0; i <= (I32) HvMAX(stash); i++) {
        for (entry = HvARRAY(stash)[i]; entry; entry = HeNEXT(entry)) {
     if (!HvARRAY(stash))
        return;
     for (i = 0; i <= (I32) HvMAX(stash); i++) {
        for (entry = HvARRAY(stash)[i]; entry; entry = HeNEXT(entry)) {
-           GV *gv = (GV*)HeVAL(entry);
+           GV *gv = MUTABLE_GV(HeVAL(entry));
            HV *hv;
            if (SvTYPE(gv) != SVt_PVGV || !GvGP(gv))
                continue;
            if (GvCVu(gv))
            HV *hv;
            if (SvTYPE(gv) != SVt_PVGV || !GvGP(gv))
                continue;
            if (GvCVu(gv))
-               xmldump_sub(gv);
+               xmldump_sub_perl(gv, justperl);
            if (GvFORM(gv))
                xmldump_form(gv);
            if (HeKEY(entry)[HeKLEN(entry)-1] == ':'
                && (hv = GvHV(gv)) && hv != PL_defstash)
            if (GvFORM(gv))
                xmldump_form(gv);
            if (HeKEY(entry)[HeKLEN(entry)-1] == ':'
                && (hv = GvHV(gv)) && hv != PL_defstash)
-               xmldump_packsubs(hv);           /* nested package */
+               xmldump_packsubs_perl(hv, justperl);    /* nested package */
        }
     }
 }
        }
     }
 }
@@ -2101,9 +2398,22 @@ Perl_xmldump_packsubs(pTHX_ const HV *stash)
 void
 Perl_xmldump_sub(pTHX_ const GV *gv)
 {
 void
 Perl_xmldump_sub(pTHX_ const GV *gv)
 {
-    SV * const sv = sv_newmortal();
+    PERL_ARGS_ASSERT_XMLDUMP_SUB;
+    xmldump_sub_perl(gv, FALSE);
+}
+
+void
+Perl_xmldump_sub_perl(pTHX_ const GV *gv, bool justperl)
+{
+    SV * sv;
+
+    PERL_ARGS_ASSERT_XMLDUMP_SUB_PERL;
 
 
-    gv_fullname3(sv, gv, Nullch);
+    if (justperl && (CvISXSUB(GvCV(gv)) || !CvROOT(GvCV(gv))))
+       return;
+
+    sv = sv_newmortal();
+    gv_fullname3(sv, gv, NULL);
     Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "\nSUB %s = ", SvPVX(sv));
     if (CvXSUB(GvCV(gv)))
        Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "(xsub 0x%"UVxf" %d)\n",
     Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "\nSUB %s = ", SvPVX(sv));
     if (CvXSUB(GvCV(gv)))
        Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "(xsub 0x%"UVxf" %d)\n",
@@ -2120,7 +2430,9 @@ Perl_xmldump_form(pTHX_ const GV *gv)
 {
     SV * const sv = sv_newmortal();
 
 {
     SV * const sv = sv_newmortal();
 
-    gv_fullname3(sv, gv, Nullch);
+    PERL_ARGS_ASSERT_XMLDUMP_FORM;
+
+    gv_fullname3(sv, gv, NULL);
     Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "\nFORMAT %s = ", SvPVX(sv));
     if (CvROOT(GvFORM(gv)))
        op_xmldump(CvROOT(GvFORM(gv)));
     Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "\nFORMAT %s = ", SvPVX(sv));
     if (CvROOT(GvFORM(gv)))
        op_xmldump(CvROOT(GvFORM(gv)));
@@ -2137,10 +2449,18 @@ Perl_xmldump_eval(pTHX)
 char *
 Perl_sv_catxmlsv(pTHX_ SV *dsv, SV *ssv)
 {
 char *
 Perl_sv_catxmlsv(pTHX_ SV *dsv, SV *ssv)
 {
+    PERL_ARGS_ASSERT_SV_CATXMLSV;
     return sv_catxmlpvn(dsv, SvPVX(ssv), SvCUR(ssv), SvUTF8(ssv));
 }
 
 char *
     return sv_catxmlpvn(dsv, SvPVX(ssv), SvCUR(ssv), SvUTF8(ssv));
 }
 
 char *
+Perl_sv_catxmlpv(pTHX_ SV *dsv, const char *pv, int utf8)
+{
+    PERL_ARGS_ASSERT_SV_CATXMLPV;
+    return sv_catxmlpvn(dsv, pv, strlen(pv), utf8);
+}
+
+char *
 Perl_sv_catxmlpvn(pTHX_ SV *dsv, const char *pv, STRLEN len, int utf8)
 {
     unsigned int c;
 Perl_sv_catxmlpvn(pTHX_ SV *dsv, const char *pv, STRLEN len, int utf8)
 {
     unsigned int c;
@@ -2149,13 +2469,15 @@ Perl_sv_catxmlpvn(pTHX_ SV *dsv, const char *pv, STRLEN len, int utf8)
     STRLEN dsvcur;
     STRLEN cl;
 
     STRLEN dsvcur;
     STRLEN cl;
 
-    sv_catpvn(dsv,"",0);
+    PERL_ARGS_ASSERT_SV_CATXMLPVN;
+
+    sv_catpvs(dsv,"");
     dsvcur = SvCUR(dsv);       /* in case we have to restart */
 
   retry:
     while (pv < e) {
        if (utf8) {
     dsvcur = SvCUR(dsv);       /* in case we have to restart */
 
   retry:
     while (pv < e) {
        if (utf8) {
-           c = utf8_to_uvchr((U8*)pv, &cl);
+           c = utf8_to_uvchr_buf((U8*)pv, (U8*)e, &cl);
            if (cl == 0) {
                SvCUR(dsv) = dsvcur;
                pv = start;
            if (cl == 0) {
                SvCUR(dsv) = dsvcur;
                pv = start;
@@ -2225,16 +2547,16 @@ Perl_sv_catxmlpvn(pTHX_ SV *dsv, const char *pv, STRLEN len, int utf8)
            Perl_sv_catpvf(aTHX_ dsv, "STUPIDXML(#x%X)", c);
            break;
        case '<':
            Perl_sv_catpvf(aTHX_ dsv, "STUPIDXML(#x%X)", c);
            break;
        case '<':
-           Perl_sv_catpvf(aTHX_ dsv, "&lt;");
+           sv_catpvs(dsv, "&lt;");
            break;
        case '>':
            break;
        case '>':
-           Perl_sv_catpvf(aTHX_ dsv, "&gt;");
+           sv_catpvs(dsv, "&gt;");
            break;
        case '&':
            break;
        case '&':
-           Perl_sv_catpvf(aTHX_ dsv, "&amp;");
+           sv_catpvs(dsv, "&amp;");
            break;
        case '"':
            break;
        case '"':
-           Perl_sv_catpvf(aTHX_ dsv, "&#34;");
+           sv_catpvs(dsv, "&#34;");
            break;
        default:
            if (c < 0xD800) {
            break;
        default:
            if (c < 0xD800) {
@@ -2242,7 +2564,8 @@ Perl_sv_catxmlpvn(pTHX_ SV *dsv, const char *pv, STRLEN len, int utf8)
                    Perl_sv_catpvf(aTHX_ dsv, "&#x%X;", c);
                }
                else {
                    Perl_sv_catpvf(aTHX_ dsv, "&#x%X;", c);
                }
                else {
-                   Perl_sv_catpvf(aTHX_ dsv, "%c", c);
+                   const char string = (char) c;
+                   sv_catpvn(dsv, &string, 1);
                }
                break;
            }
                }
                break;
            }
@@ -2271,14 +2594,16 @@ Perl_sv_xmlpeek(pTHX_ SV *sv)
     STRLEN n_a;
     int unref = 0;
 
     STRLEN n_a;
     int unref = 0;
 
+    PERL_ARGS_ASSERT_SV_XMLPEEK;
+
     sv_utf8_upgrade(t);
     sv_utf8_upgrade(t);
-    sv_setpvn(t, "", 0);
+    sv_setpvs(t, "");
     /* retry: */
     if (!sv) {
        sv_catpv(t, "VOID=\"\"");
        goto finish;
     }
     /* retry: */
     if (!sv) {
        sv_catpv(t, "VOID=\"\"");
        goto finish;
     }
-    else if (sv == (SV*)0x55555555 || SvTYPE(sv) == 'U') {
+    else if (sv == (const SV *)0x55555555 || SvTYPE(sv) == 'U') {
        sv_catpv(t, "WILD=\"\"");
        goto finish;
     }
        sv_catpv(t, "WILD=\"\"");
        goto finish;
     }
@@ -2358,9 +2683,6 @@ Perl_sv_xmlpeek(pTHX_ SV *sv)
     case SVt_NV:
        sv_catpv(t, " NV=\"");
        break;
     case SVt_NV:
        sv_catpv(t, " NV=\"");
        break;
-    case SVt_RV:
-       sv_catpv(t, " RV=\"");
-       break;
     case SVt_PV:
        sv_catpv(t, " PV=\"");
        break;
     case SVt_PV:
        sv_catpv(t, " PV=\"");
        break;
@@ -2394,6 +2716,9 @@ Perl_sv_xmlpeek(pTHX_ SV *sv)
     case SVt_BIND:
        sv_catpv(t, " BIND=\"");
        break;
     case SVt_BIND:
        sv_catpv(t, " BIND=\"");
        break;
+    case SVt_REGEXP:
+       sv_catpv(t, " REGEXP=\"");
+       break;
     case SVt_PVFM:
        sv_catpv(t, " FM=\"");
        break;
     case SVt_PVFM:
        sv_catpv(t, " FM=\"");
        break;
@@ -2431,6 +2756,8 @@ Perl_sv_xmlpeek(pTHX_ SV *sv)
 void
 Perl_do_pmop_xmldump(pTHX_ I32 level, PerlIO *file, const PMOP *pm)
 {
 void
 Perl_do_pmop_xmldump(pTHX_ I32 level, PerlIO *file, const PMOP *pm)
 {
+    PERL_ARGS_ASSERT_DO_PMOP_XMLDUMP;
+
     if (!pm) {
        Perl_xmldump_indent(aTHX_ level, file, "<pmop/>\n");
        return;
     if (!pm) {
        Perl_xmldump_indent(aTHX_ level, file, "<pmop/>\n");
        return;
@@ -2438,10 +2765,9 @@ Perl_do_pmop_xmldump(pTHX_ I32 level, PerlIO *file, const PMOP *pm)
     Perl_xmldump_indent(aTHX_ level, file, "<pmop \n");
     level++;
     if (PM_GETRE(pm)) {
     Perl_xmldump_indent(aTHX_ level, file, "<pmop \n");
     level++;
     if (PM_GETRE(pm)) {
-       const char * const s = PM_GETRE(pm)->precomp;
-       SV * const tmpsv = newSVpvn("",0);
-       SvUTF8_on(tmpsv);
-       sv_catxmlpvn(tmpsv, s, strlen(s), 1);
+       REGEXP *const r = PM_GETRE(pm);
+       SV * const tmpsv = newSVpvn_utf8("", 0, TRUE);
+       sv_catxmlsv(tmpsv, MUTABLE_SV(r));
        Perl_xmldump_indent(aTHX_ level, file, "pre=\"%s\"\n",
             SvPVX(tmpsv));
        SvREFCNT_dec(tmpsv);
        Perl_xmldump_indent(aTHX_ level, file, "pre=\"%s\"\n",
             SvPVX(tmpsv));
        SvREFCNT_dec(tmpsv);
@@ -2450,7 +2776,7 @@ Perl_do_pmop_xmldump(pTHX_ I32 level, PerlIO *file, const PMOP *pm)
     }
     else
        Perl_xmldump_indent(aTHX_ level, file, "pre=\"\" when=\"RUN\"\n");
     }
     else
        Perl_xmldump_indent(aTHX_ level, file, "pre=\"\" when=\"RUN\"\n");
-    if (pm->op_pmflags || (PM_GETRE(pm) && PM_GETRE(pm)->check_substr)) {
+    if (pm->op_pmflags || (PM_GETRE(pm) && RX_CHECK_SUBSTR(PM_GETRE(pm)))) {
        SV * const tmpsv = pm_description(pm);
        Perl_xmldump_indent(aTHX_ level, file, "pmflags=\"%s\"\n", SvCUR(tmpsv) ? SvPVX(tmpsv) + 1 : "");
        SvREFCNT_dec(tmpsv);
        SV * const tmpsv = pm_description(pm);
        Perl_xmldump_indent(aTHX_ level, file, "pmflags=\"%s\"\n", SvCUR(tmpsv) ? SvPVX(tmpsv) + 1 : "");
        SvREFCNT_dec(tmpsv);
@@ -2479,9 +2805,11 @@ Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
 {
     UV      seq;
     int     contents = 0;
 {
     UV      seq;
     int     contents = 0;
+
+    PERL_ARGS_ASSERT_DO_OP_XMLDUMP;
+
     if (!o)
        return;
     if (!o)
        return;
-    sequence(o);
     seq = sequence_num(o);
     Perl_xmldump_indent(aTHX_ level, file,
        "<op_%s seq=\"%"UVuf" -> ",
     seq = sequence_num(o);
     Perl_xmldump_indent(aTHX_ level, file,
        "<op_%s seq=\"%"UVuf" -> ",
@@ -2506,9 +2834,9 @@ Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
                if (CopSTASHPV(cCOPo))
                    PerlIO_printf(file, " package=\"%s\"",
                                     CopSTASHPV(cCOPo));
                if (CopSTASHPV(cCOPo))
                    PerlIO_printf(file, " package=\"%s\"",
                                     CopSTASHPV(cCOPo));
-               if (cCOPo->cop_label)
+               if (CopLABEL(cCOPo))
                    PerlIO_printf(file, " label=\"%s\"",
                    PerlIO_printf(file, " label=\"%s\"",
-                                    cCOPo->cop_label);
+                                    CopLABEL(cCOPo));
            }
        }
        else
            }
        }
        else
@@ -2518,7 +2846,7 @@ Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
     PerlIO_printf(file, " addr=\"0x%"UVxf" => 0x%"UVxf"\"", (UV)o, (UV)o->op_next);
 #endif
     if (o->op_flags) {
     PerlIO_printf(file, " addr=\"0x%"UVxf" => 0x%"UVxf"\"", (UV)o, (UV)o->op_next);
 #endif
     if (o->op_flags) {
-       SV * const tmpsv = newSVpvn("", 0);
+       SV * const tmpsv = newSVpvs("");
        switch (o->op_flags & OPf_WANT) {
        case OPf_WANT_VOID:
            sv_catpv(tmpsv, ",VOID");
        switch (o->op_flags & OPf_WANT) {
        case OPf_WANT_VOID:
            sv_catpv(tmpsv, ",VOID");
@@ -2549,7 +2877,7 @@ Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
        SvREFCNT_dec(tmpsv);
     }
     if (o->op_private) {
        SvREFCNT_dec(tmpsv);
     }
     if (o->op_private) {
-       SV * const tmpsv = newSVpvn("", 0);
+       SV * const tmpsv = newSVpvs("");
        if (PL_opargs[o->op_type] & OA_TARGLEX) {
            if (o->op_private & OPpTARGET_MY)
                sv_catpv(tmpsv, ",TARGET_MY");
        if (PL_opargs[o->op_type] & OA_TARGLEX) {
            if (o->op_private & OPpTARGET_MY)
                sv_catpv(tmpsv, ",TARGET_MY");
@@ -2605,8 +2933,6 @@ Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
                    sv_catpv(tmpsv, ",NOPAREN");
                if (o->op_private & OPpENTERSUB_INARGS)
                    sv_catpv(tmpsv, ",INARGS");
                    sv_catpv(tmpsv, ",NOPAREN");
                if (o->op_private & OPpENTERSUB_INARGS)
                    sv_catpv(tmpsv, ",INARGS");
-               if (o->op_private & OPpENTERSUB_NOMOD)
-                   sv_catpv(tmpsv, ",NOMOD");
            }
            else {
                switch (o->op_private & OPpDEREF) {
            }
            else {
                switch (o->op_private & OPpDEREF) {
@@ -2639,12 +2965,10 @@ Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
                sv_catpv(tmpsv, ",BARE");
            if (o->op_private & OPpCONST_STRICT)
                sv_catpv(tmpsv, ",STRICT");
                sv_catpv(tmpsv, ",BARE");
            if (o->op_private & OPpCONST_STRICT)
                sv_catpv(tmpsv, ",STRICT");
-           if (o->op_private & OPpCONST_ARYBASE)
-               sv_catpv(tmpsv, ",ARYBASE");
-           if (o->op_private & OPpCONST_WARNING)
-               sv_catpv(tmpsv, ",WARNING");
            if (o->op_private & OPpCONST_ENTERED)
                sv_catpv(tmpsv, ",ENTERED");
            if (o->op_private & OPpCONST_ENTERED)
                sv_catpv(tmpsv, ",ENTERED");
+           if (o->op_private & OPpCONST_FOLDED)
+               sv_catpv(tmpsv, ",FOLDED");
        }
        else if (o->op_type == OP_FLIP) {
            if (o->op_private & OPpFLIP_LINENUM)
        }
        else if (o->op_type == OP_FLIP) {
            if (o->op_private & OPpFLIP_LINENUM)
@@ -2702,8 +3026,8 @@ Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
            if (o->op_private & OPpHUSH_VMSISH)
                sv_catpv(tmpsv, ",HUSH_VMSISH");
        }
            if (o->op_private & OPpHUSH_VMSISH)
                sv_catpv(tmpsv, ",HUSH_VMSISH");
        }
-       else if (PL_check[o->op_type] != MEMBER_TO_FPTR(Perl_ck_ftst)) {
-           if (OP_IS_FILETEST_ACCESS(o) && o->op_private & OPpFT_ACCESS)
+       else if (PL_check[o->op_type] != Perl_ck_ftst) {
+           if (OP_IS_FILETEST_ACCESS(o->op_type) && o->op_private & OPpFT_ACCESS)
                sv_catpv(tmpsv, ",FT_ACCESS");
            if (o->op_private & OPpFT_STACKED)
                sv_catpv(tmpsv, ",FT_STACKED");
                sv_catpv(tmpsv, ",FT_ACCESS");
            if (o->op_private & OPpFT_STACKED)
                sv_catpv(tmpsv, ",FT_STACKED");
@@ -2726,16 +3050,14 @@ Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
        S_xmldump_attr(aTHX_ level, file, "padix=\"%" IVdf "\"", (IV)cPADOPo->op_padix);
 #else
        if (cSVOPo->op_sv) {
        S_xmldump_attr(aTHX_ level, file, "padix=\"%" IVdf "\"", (IV)cPADOPo->op_padix);
 #else
        if (cSVOPo->op_sv) {
-           SV * const tmpsv1 = newSV(0);
-           SV * const tmpsv2 = newSVpvn("",0);
+           SV * const tmpsv1 = newSVpvn_utf8(NULL, 0, TRUE);
+           SV * const tmpsv2 = newSVpvn_utf8("", 0, TRUE);
            char *s;
            STRLEN len;
            char *s;
            STRLEN len;
-           SvUTF8_on(tmpsv1);
-           SvUTF8_on(tmpsv2);
            ENTER;
            SAVEFREESV(tmpsv1);
            SAVEFREESV(tmpsv2);
            ENTER;
            SAVEFREESV(tmpsv1);
            SAVEFREESV(tmpsv2);
-           gv_fullname3(tmpsv1, (GV*)cSVOPo->op_sv, Nullch);
+           gv_fullname3(tmpsv1, MUTABLE_GV(cSVOPo->op_sv), NULL);
            s = SvPV(tmpsv1,len);
            sv_catxmlpvn(tmpsv2, s, len, 1);
            S_xmldump_attr(aTHX_ level, file, "gv=\"%s\"", SvPV(tmpsv2, len));
            s = SvPV(tmpsv1,len);
            sv_catxmlpvn(tmpsv2, s, len, 1);
            S_xmldump_attr(aTHX_ level, file, "gv=\"%s\"", SvPV(tmpsv2, len));
@@ -2746,6 +3068,7 @@ Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
 #endif
        break;
     case OP_CONST:
 #endif
        break;
     case OP_CONST:
+    case OP_HINTSEVAL:
     case OP_METHOD_NAMED:
 #ifndef USE_ITHREADS
        /* with ITHREADS, consts are stored in the pad, and the right pad
     case OP_METHOD_NAMED:
 #ifndef USE_ITHREADS
        /* with ITHREADS, consts are stored in the pad, and the right pad
@@ -2760,7 +3083,6 @@ Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
        }
        do_op_xmldump(level+1, file, CvROOT(cSVOPo_sv));
        break;
        }
        do_op_xmldump(level+1, file, CvROOT(cSVOPo_sv));
        break;
-    case OP_SETSTATE:
     case OP_NEXTSTATE:
     case OP_DBSTATE:
        if (CopLINE(cCOPo))
     case OP_NEXTSTATE:
     case OP_DBSTATE:
        if (CopLINE(cCOPo))
@@ -2769,9 +3091,9 @@ Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
        if (CopSTASHPV(cCOPo))
            S_xmldump_attr(aTHX_ level, file, "package=\"%s\"",
                             CopSTASHPV(cCOPo));
        if (CopSTASHPV(cCOPo))
            S_xmldump_attr(aTHX_ level, file, "package=\"%s\"",
                             CopSTASHPV(cCOPo));
-       if (cCOPo->cop_label)
+       if (CopLABEL(cCOPo))
            S_xmldump_attr(aTHX_ level, file, "label=\"%s\"",
            S_xmldump_attr(aTHX_ level, file, "label=\"%s\"",
-                            cCOPo->cop_label);
+                            CopLABEL(cCOPo));
        break;
     case OP_ENTERLOOP:
        S_xmldump_attr(aTHX_ level, file, "redo=\"");
        break;
     case OP_ENTERLOOP:
        S_xmldump_attr(aTHX_ level, file, "redo=\"");
@@ -2817,10 +3139,9 @@ Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
 
     if (PL_madskills && o->op_madprop) {
        char prevkey = '\0';
 
     if (PL_madskills && o->op_madprop) {
        char prevkey = '\0';
-       SV * const tmpsv = newSVpvn("", 0);
+       SV * const tmpsv = newSVpvn_utf8("", 0, TRUE);
        const MADPROP* mp = o->op_madprop;
 
        const MADPROP* mp = o->op_madprop;
 
-       sv_utf8_upgrade(tmpsv);
        if (!contents) {
            contents = 1;
            PerlIO_printf(file, ">\n");
        if (!contents) {
            contents = 1;
            PerlIO_printf(file, ">\n");
@@ -2829,7 +3150,7 @@ Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
        level++;
        while (mp) {
            char tmp = mp->mad_key;
        level++;
        while (mp) {
            char tmp = mp->mad_key;
-           sv_setpvn(tmpsv,"\"",1);
+           sv_setpvs(tmpsv,"\"");
            if (tmp)
                sv_catxmlpvn(tmpsv, &tmp, 1, 0);
            if ((tmp == '_') || (tmp == '#')) /* '_' '#' whitespace belong to the previous token. */
            if (tmp)
                sv_catxmlpvn(tmpsv, &tmp, 1, 0);
            if ((tmp == '_') || (tmp == '#')) /* '_' '#' whitespace belong to the previous token. */
@@ -2850,7 +3171,7 @@ Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
                break;
            case MAD_SV:
                sv_catpv(tmpsv, " val=\"");
                break;
            case MAD_SV:
                sv_catpv(tmpsv, " val=\"");
-               sv_catxmlsv(tmpsv, (SV*)mp->mad_val);
+               sv_catxmlsv(tmpsv, MUTABLE_SV(mp->mad_val));
                sv_catpv(tmpsv, "\"");
                Perl_xmldump_indent(aTHX_ level, file, "<mad_sv key=%s/>\n", SvPVX(tmpsv));
                break;
                sv_catpv(tmpsv, "\"");
                Perl_xmldump_indent(aTHX_ level, file, "<mad_sv key=%s/>\n", SvPVX(tmpsv));
                break;
@@ -2907,6 +3228,8 @@ Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
 void
 Perl_op_xmldump(pTHX_ const OP *o)
 {
 void
 Perl_op_xmldump(pTHX_ const OP *o)
 {
+    PERL_ARGS_ASSERT_OP_XMLDUMP;
+
     do_op_xmldump(0, PL_xmlfp, o);
 }
 #endif
     do_op_xmldump(0, PL_xmlfp, o);
 }
 #endif
@@ -2915,8 +3238,8 @@ Perl_op_xmldump(pTHX_ const OP *o)
  * Local variables:
  * c-indentation-style: bsd
  * c-basic-offset: 4
  * Local variables:
  * c-indentation-style: bsd
  * c-basic-offset: 4
- * indent-tabs-mode: t
+ * indent-tabs-mode: nil
  * End:
  *
  * End:
  *
- * ex: set ts=8 sts=4 sw=4 noet:
+ * ex: set ts=8 sts=4 sw=4 et:
  */
  */
Unnamed repository; edit this file 'description' to name the repository.