This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Merge branch 'embed.fnc' into blead
authorKarl Williamson <khw@cpan.org>
Sun, 15 Sep 2019 16:40:29 +0000 (10:40 -0600)
committerKarl Williamson <khw@cpan.org>
Sun, 15 Sep 2019 16:44:16 +0000 (10:44 -0600)
This series of commits slightly improves XS code name space pollution
from the core, and better documents what is happening.

It adds a new C flag to embed.fnc which doesn't change the pollution
problem, but makes it easier for downstream tools, like Devel::PPPort.

Some of the inline.h functions didn't even have prefixes, contrary to
our policy of having functions visible outside the core have a 'Perl_'
prefix.

The branch also documents a couple of API functions and macros.

And better error checking of embed.fnc entries is now done.

18 files changed:
autodoc.pl
cv.h
embed.fnc
embed.h
inline.h
mathoms.c
op.c
perl.h
pp.h
proto.h
regen/embed.pl
regen/embed_lib.pl
regexec.c
regexp.h
sv.h
t/porting/args_assert.t
utf8.c
utf8.h

index 6c54b2f..b8d46b3 100644 (file)
@@ -251,7 +251,7 @@ removed without notice.\n\n$docs" if $flags =~ /x/;
                 }
             }
             my $args = '';
-            if ($p && $flags !~ /T/) {
+            if ($flags !~ /T/ && ($p || ($flags =~ /m/ && $name =~ /^Perl_/))) {
                 $args = @args ? "pTHX_ " : "pTHX";
                 if ($long_args) { print $fh $args; $args = '' }
             }
@@ -397,8 +397,8 @@ foreach (sort keys %missing) {
 # walk table providing an array of components in each line to
 # subroutine, printing the result
 
-# List of funcs in the public API that aren't also marked as experimental nor
-# deprecated.
+# List of funcs in the public API that aren't also marked as core-only,
+# experimental nor deprecated.
 my @missing_api = grep $funcflags{$_}{flags} =~ /A/
                     && $funcflags{$_}{flags} !~ /[xD]/
                     && !$docs{api}{$_}, keys %funcflags;
diff --git a/cv.h b/cv.h
index 35751eb..9a169e8 100644 (file)
--- a/cv.h
+++ b/cv.h
@@ -49,7 +49,7 @@ See L<perlguts/Autoloading with XSUBs>.
 #define CvROOT(sv)     ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_root_u.xcv_root
 #define CvXSUB(sv)     ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_root_u.xcv_xsub
 #define CvXSUBANY(sv)  ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_start_u.xcv_xsubany
-#define CvGV(sv)       S_CvGV(aTHX_ (CV *)(sv))
+#define CvGV(sv)       Perl_CvGV(aTHX_ (CV *)(sv))
 #define CvGV_set(cv,gv)        Perl_cvgv_set(aTHX_ cv, gv)
 #define CvHASGV(cv)    cBOOL(SvANY(cv)->xcv_gv_u.xcv_gv)
 #define CvFILE(sv)     ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_file
@@ -61,9 +61,9 @@ See L<perlguts/Autoloading with XSUBs>.
     (CvFILE(sv) = CopFILE(cop), CvDYNFILE_off(sv))
 #endif
 #define CvFILEGV(sv)   (gv_fetchfile(CvFILE(sv)))
-#define CvDEPTH(sv)    (*S_CvDEPTHp((const CV *)sv))
+#define CvDEPTH(sv)    (*Perl_CvDEPTH((const CV *)sv))
 /* For use when you only have a XPVCV*, not a real CV*.
-   Must be assert protected as in S_CvDEPTHp before use. */
+   Must be assert protected as in Perl_CvDEPTH before use. */
 #define CvDEPTHunsafe(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_depth
 
 /* these CvPADLIST/CvRESERVED asserts can be reverted one day, once stabilized */
index 2bf9ed4..a3e5fb2 100644 (file)
--- a/embed.fnc
+++ b/embed.fnc
 : This file is known to be processed by regen/embed.pl, autodoc.pl,
 : makedef.pl, Devel::PPPort, and porting/diag.t.
 :
+: This file contains entries for various functions and macros defined by perl.
+: Each entry includes the name, parameters, and various attributes about it.
+: In most functions listed here, the name is a short name, and the function's
+: real name is the short one, prefixed by either 'Perl_' (for publicly visible
+: functions) or 'S_' (for internal-to-a-file static ones).  In many instances a
+: macro is defined that is the name in this file, and which expands to call the
+: real (full) name, with any appropriate thread context paramaters, thus hiding
+: that detail from the typical code.
+:
+: Most macros listed here are the complete full name.
+:
 : All non-static functions defined by perl need to be listed in this file.
-: embed.pl uses the entries here to construct proto.h to declare to the
-: compiler the function interfaces, and embed.h to create macros that present a
-: uniform interface to C code for the functions, regardless of, say, whether
-: the perl is threaded or not.
+: embed.pl uses the entries here to construct:
+:   1) proto.h to declare to the compiler the function interfaces; and
+:   2) embed.h to create short name macros
 :
-: Static functions need not appear here, but there is benefit to declaring them
-: here, as it generally handles the thread context parameter invisibly, as well
-: as making sure a PERL_ARGS_ASSERT_foo macro is defined, which can save you
-: debugging time.
+: Static functions internal to a file need not appear here, but there is
+: benefit to declaring them here, as it generally handles the thread context
+: parameter invisibly, as well as making sure a PERL_ARGS_ASSERT_foo macro is
+: defined, which can save you debugging time.
 :
 : Lines in this file are of the form:
-:    flags|return_type|function_name|arg1|arg2|...|argN
+:    flags|return_type|name|arg1|arg2|...|argN
 :
 : 'flags' is a string of single letters.  Most of the flags are meaningful only
 : to embed.pl; some only to autodoc.pl, and others only to makedef.pl.  The
-: comments here don't include how Devel::PPPort or diag.t use them:
+: comments here mostly don't include how Devel::PPPort or diag.t use them:
 :
 : A function taking no parameters will have no 'arg' elements.
 : A line may be continued onto the next by ending it with a backslash.
 : Leading and trailing whitespace will be ignored in each component.
 :
+: Most entries here have a macro created with the entry name.  This presents
+: name space collision potentials which haven't been well thought out, but are
+: now documented here.  In practice this has rarely been an issue.  At least,
+: with a macro, the XS author can #undef it, unlike a function.
+:
 : The default without flags is to declare a function for internal perl-core use
-: only.  On some platforms, such as Linux and Darwin, all non-static functions
+: only.  The short name is visible only when the PERL_CORE symbol is defined.
+: On some platforms, such as Linux and Darwin, all non-static functions
 : are currently externally visible.  Because of this, and also for programs
 : that embed perl, most non-static functions should have the 'p' flag to avoid
 : namespace clashes.
 :
-: Most entries here have a macro created to wrap them, and whose name doesn't
-: include the 'Perl_', or other prefix.
+: There are several advantages to using a macro instead of the full Perl_foo or
+: S_foo form: it hides the need to know if the called function requires a
+: thread context parameter or not, and the code using it is more readable
+: because of fewer parameters being visible.  And if there is some bug in it
+: that gets fixed in a later release, ppport.h can be changed to automatically
+: backport the fixed version to modules.  The only disadvantage khw can think
+: of is the namespace pollution one.
+:
+: Since we don't require a C compiler to support variadic macros (C99), the
+: macros can't be generated in such situations.
+:
+: WARNING: Any macro created in a header file is visible to XS code, unless
+: care is taken to wrap it within something like #ifdef PERL_CORE..#endif.
+: This has had to be done with things like MAX and MIN, but nearly everything
+: else has been created without regard to the namespace pollution problem.
+:
+: Here's what else you need to know about using this file with regards to name
+: space pollution:
+:
+: The A flag is used to make a function and its short name visible everywhere
+:           on all platforms.  This should be used to make it part of Perl's
+:           API contract with XS developers.  The documentation for these is
+:           usually placed in perlapi.  If no documentation exists, that fact
+:           is also noted in perlapi.
+:
+: The C flag is used instead for functions and their short names that need to
+:            be accessible everywhere, typically because they are called from a
+:            publicly available macro or inline function, but they are not for
+:            public use by themselves.  The documentation for these is placed
+:            in perlintern.  If no documentation exists, that fact is also
+:            noted in perlintern.
+:
+:            These really need the 'p' flag to avoid name space collisions.
+:
+:           Some of these have been constructed so that the wrapper macro
+:           names begin with an underscore to lessen the chances of a name
+:           collision.  However, this is contrary to the C standard, and those
+:           should be changed.
+:
+: The E flag is used instead for a function and its short name that is supposed
+:            to be used only in the core, and in extensions compiled with the
+:            PERL_EXT symbol defined.  Again, on some platforms, the function
+:            will be visible everywhere, so the 'p' flag is gnerally needed.
+:            Also note that an XS writer can always cheat and pretend to be an
+:            extension by #defining PERL_EXT.
+:
+: The X flag is similar to the C flag in that the function (whose entry better
+:           have the 'p' flag) is accessible everywhere on all platforms.
+:           However the short name macro that normally gets generated is
+:           suppressed outside the core.  (Except it is also visible in
+:           PERL_EXT extensions if the E flag is also specified.)  This flag
+:           is used for functions that are called from a public macro, the
+:           name of which isn't derived from the function name.  You'll have
+:           to write the macro yourself, and from within it, refer to the
+:           function in its full 'Perl_' form with any necessary thread
+:           context parameter.
 :
 : Scattered around the perl source are lines of the form:
 :
 : autodoc.pl where the documentation is for a function listed in this file.  It
 : uses the prototype from here and the pod from there in generating the
 : documentation in perlapi or perlintern.  The entries in this file that have
-: corresponding '=for apidoc' entries should have the flag 'd' set in this
+: corresponding '=for apidoc' entries should have the 'd' flag set in this
 : file.
 :
 : There are also lines of this form scattered around:
 :
 :   =for apidoc flags|return_type|name|arg1|arg2|...|argN
 :
-: and with the same meanings as the lines in this file.  The 'name' in any such
-: line must not be the same as any in this file (i.e., no redundant
-: definitions), and one of the flags must be 'm', indicating this is a macro.
-: The lines following these are pod for the respective macro.  Since these are
-: macros, the arguments need not be legal C parameters.  To indicate this to
-: downstream software that inspects these lines, there are a few conventions:
+: and with the same meanings as the lines in this file.  These are for
+: documenting macros.  The 'name' in any such line must not be the same as any
+: in this file (i.e., no redundant definitions), and one of the flags must be
+: 'm', indicating it is a macro.  The lines following these are pod for the
+: respective macro.  Since these are macros, the arguments need not be legal C
+: parameters.  To indicate this to downstream software that inspects these
+: lines, there are a few conventions:
 :  type    should be the entire argument name if it names a type
 :  cast    should be the entire argument name if it is a cast
 :  SP      should be the entire argument name if it is the stack pointer SP
 : indicate that it has to be a string, instead of a const char * const, like this
 :   =for apidoc Ama|SV*|newSVpvs|"string"
 :
+: If any argument or return value is not one of the above, and isn't a legal C
+: language one, the 'u' flag should be specified.
+:
 : Again, autodoc uses these lines to construct perlapi. 'return_type' in these
 : lines can be empty, unlike in this file.
 :
 : Devel::PPPort also looks at both this file and the '=for apidoc' lines.  In
 : part it is to construct lists of functions that are or are not backported.
 :
-: makedef.pl uses this file for constructing the export list
+: makedef.pl uses this file for constructing the export list which lists the
+: symbols that should be available on all platforms.
 :
 : porting/diag.t checks some things for consistency based on this file.
 :
-:   A  Accessible fully everywhere (usually part of the public API):
+: The remainder of these introductory comments detail all the possible flags:
 :
-:         add entry to the list of exported symbols (unless e or m);
-:         any doc entry goes in perlapi.pod rather than perlintern.pod.  If
-:            no documentation is furnished, x controls what happens: If x
-:            isn't specified, autodoc.pl lists this in perlapi as existing and
-:           being undocumented; otherwise it simply isn't listed.
-:         makes '#define foo Perl_foo' scope not just for PERL_CORE/PERL_EXT
+:   A  Both long and short names are accessible fully everywhere (usually part
+:      of the public API).  If the function is not part of the public API,
+:      instead use C, E, or X.
 :
-:      If the function is only exported for use in a public macro, see X.
+:         add entry to the list of symbols available on all platforms
+:          unless e or m are also specified;
+:         any doc entry goes in perlapi.pod rather than perlintern.pod.  If
+:          there isn't a doc entry, autodoc.pl lists this in perlapi as
+:          existing and being undocumented; unless x is also specified, in
+:          which case it simply isn't listed.
+:         makes the short name defined for everywhere, not just for
+:          PERL_CORE/PERL_EXT
 :
-:   a  Allocates memory a la malloc/calloc.  Also implies "R".
-:      This flag should only be on a function which returns 'empty' memory
-:      which has no other pointers to it, and which does not contain
-:      any pointers to other things. So for example realloc() can't be
-:      'a'.
+:   a  Allocates memory a la malloc/calloc.  Also implies "R".  This flag
+:      should only be on a function which returns 'empty' memory which has no
+:      other pointers to it, and which does not contain any pointers to other
+:      things. So for example realloc() can't be 'a'.
 :
 :         proto.h: add __attribute__malloc__
 :
 :      -Accflags='-DNO_MATHOMS' parameter to not even compile them.
 :
 :      Sometimes the function has been subsumed by a more general one (say, by
-:      adding a flags parameter), and a macro exists with the original API, and
-:      it calls the new function, bypassing this one, and the original 'Perl_'
-:      form is being deprecated.  In this case also specify the 'M' flag.  The
-:      'b' functions are normally moved to mathoms.c, but if circumstances
+:      adding a flags parameter), and a macro exists with the original short
+:      name API, and it calls the new function, bypassing this one, and the
+:      original 'Perl_' form is being deprecated.  In this case also specify
+:      the 'M' flag.
+:
+:      Without the M flag, these functions should be deprecated, and it is an
+:      error to not also specify the 'D' flag.
+:
+:      The 'b' functions are normally moved to mathoms.c, but if circumstances
 :      dictate otherwise, they can be anywhere, provided the whole function is
 :      wrapped with
 :          #ifndef NO_MATHOMS
 :      Note that this flag no longer automatically adds a 'Perl_' prefix to the
 :      name.  Additionally specify 'p' to do that.
 :
-:      For functions, like wrappers, whose macro shortcut doesn't call the
-:      function, but which, for whatever reason, aren't considered legacy-only,
-:      use the 'o' flag, and maybe the 'M'
-:
 :      This flag effectively causes nothing to happen if the perl interpreter
-:      is compiled with -DNO_MATHOMS; otherwise these happen:
-:         add entry to the list of exported symbols;
+:      is compiled with -DNO_MATHOMS (which causes any functions with this flag
+:      to not be compiled); otherwise these happen:
+:         add entry to the list of symbols available on all platforms;
 :         create PERL_ARGS_ASSERT_foo;
-:        add embed.h entry (unless overridden by the 'o' flag)
+:        add embed.h entry (unless overridden by the 'M' or 'o' flags)
+:
+:   C  Intended for core use only.  This indicates to XS writers that they
+:      shouldn't be using this function.  Devel::PPPort informs them of this,
+:      for example.  Some functions have to be accessible everywhere even if
+:      they are not intended for public use.  An example is helper functions
+:      that are called from inline ones that are publicly available.
+:
+:         add entry to the list of symbols available on all platforms
+:          unless e or m are also specified;
+:         any doc entry goes in perlintern.pod rather than perlapi.pod.  If
+:          there isn't a doc entry, autodoc.pl lists this in perlintern as
+:          existing and being undocumented
+:         makes the short name defined for everywhere, not just for
+:          PERL_CORE/PERL_EXT
 :
 :   D  Function is deprecated:
 :
 :
 :   e  Not exported
 :
-:         suppress entry in the list of exported symbols
+:         suppress entry in the list of symbols available on all platforms
 :
 :   f  Function takes a format string. If the function name =~ qr/strftime/
-:      then its assumed to take a strftime-style format string as 1st arg;
-:      otherwise it's assumed to be a printf style format string, varargs
+:      then it is assumed to take a strftime-style format string as the 1st
+:      arg; otherwise it's assumed to be a printf style format string, varargs
 :      (hence any entry that would otherwise go in embed.h is suppressed):
 :
 :         proto.h: add __attribute__format__ (or ...null_ok__)
 :
-:   h  Hide any documentation.  This is used typically when the documentation
-:      is atypical of the rest of perlapi and perlintern.  In other words the
-:      item is documented, but just not the standard way.  One reason would be
-:      if there are a bunch of macros which follow a common paradigm in their
-:      naming, so rather than having an entry for each slight variation, there
-:      is an overarchinge one.  It is also used when the documentation is in
-:      another pod, such as perlguts or warnings.h.  This flag is useful for
-:      downstream programs, such as Devel::PPPort.
-:
-:   i  Static inline: function in source code has a S_ prefix:
-:
-:         proto.h: function is declared as S_foo rather than foo unless the 'p'
-:                 flag is also given in which case 'Perl_foo' is used,
-:                PERL_STATIC_INLINE is added to the declaration
-:         embed.h: "#define foo S_foo" or Perl_foo entries added
-:
-:   M  There is an extra macro that bypasses this function
-:
-:      (requires 'p', and implies 'o')  The function exists so that callers who
-:      used the 'Perl_' form can continue to do so, but there is a macro
-:      available without the 'Perl_' prefix that bypasses the function call,
-:      such as when the function has been reduced to a wrapper around another
-:      one.
-:
-:   m  Implemented as a macro:
-:
-:         suppress proto.h entry unless 'b' also specified (actually, not
-:              suppressed, but commented out)
-:         suppress entry in the list of exported symbols
-:         suppress embed.h entry
+:   G  Suppress empty PERL_ARGS_ASSERT_foo macro.  Normally such a macro is
+:      generated for all entries for functions 'foo' in this file.  If there is
+:      a pointer argument to 'foo', it needs to be declared in this file as
+:      either NN or NULLOK, and the function definition must call its
+:      corresponding PERL_ARGS_ASSERT_foo macro (a porting test ensures this)
+:      which asserts at runtime (under DEBUGGING builds) that NN arguments are
+:      not NULL.  If there aren't NN arguments, use of this macro is optional.
+:      Rarely, a function will define its own PERL_ARGS_ASSERT_foo macro, and
+:      in those cases, adding this flag to its entry in this file will suppress
+:      the normal one.  It is not possible to suppress the generated macro if
+:      it isn't optional, that is, if there is at least one NN argument.
+:
+:         proto.h: PERL_ARGS_ASSERT macro is not defined unless the function
+:                 has NN arguments
+:
+:   h  Hide any documentation.  This is used when the documentation is atypical
+:      of the rest of perlapi and perlintern.  In other words the item is
+:      documented, but just not the standard way.  One reason would be if there
+:      are a bunch of macros which follow a common paradigm in their naming, so
+:      rather than having an entry for each slight variation, there is an
+:      overarchinge one.  It is also used when the documentation is in another
+:      pod, such as perlguts or warnings.h.  This flag is useful for downstream
+:      programs, such as Devel::PPPort.
+:
+:   i  inline static.  This is used for functions that the compiler is being
+:      requested to inline.  If the function is in a header file its
+:      definition will be visible (unless guarded by #if..#endif) to all
+:      XS code.  (A typical guard will be that it is being included in a
+:      particular C file(s) or in the perl core.)  Therefore, all
+:      non-guarded function should also have the 'p' flag specified to avoid
+:      polluting the XS code name space.  Otherwise an error is generated if
+:      the 'S' flag is not also specified.
+:
+:         proto.h: function is declared as PERL_STATIC_INLINE
+:
+:   m  Implemented as a macro; there is no function associated with this name,
+:      and hence no long Perl_ or S_ name.  However, if the macro name itself
+:      begins with 'Perl_', autodoc.pl will show a thread context parameter
+:      unless the 'T' flag is specified.
+:
+:         suppress proto.h entry (actually, not suppressed, but commented out)
+:         suppress entry in the list of exported symbols available on all platforms
+:         suppress embed.h entry, as the implementation should furnish the macro
+:
+:   M  The implementation is furnishing its own macro instead of relying on the
+:      default short name macro that simply expands to call the real name
+:      function.  This is used if the parameters need to be cast from what the
+:      caller has, or if there is a macro that bypasses this function (whose
+:      long name is being retained for backward compatibility for those who
+:      call it with that name).  An example is when a new function is created
+:      with an extra parameter and a wrapper macro is added that has the old
+:      API, but calls the new one with the exta parameter set to a default.
+:
+:      This flag requires the 'p' flag to be specified, as there would be no
+:      need to do this if the function weren't publicly accessible before.
+:
+:      The entry is processed based on the other flags, but the:
+:         embed.h entry is suppressed
 :
 :   N  The name in the entry isn't strictly a name
 :
 :      autodoc.pl adds a note that the perl_ form of this function is
 :      deprecated.
 :
-:
 :   o  Has no Perl_foo or S_foo compatibility macro:
 :
-:      This can be used when you define a macro with this entry's name that
-:      doesn't call the function specified by this entry.  This is typically
-:      done for a function that effectively just wraps another one, and where
-:      the macro form calls the underlying function directly.  For these, also
-:      specify the 'M' flag.  Legacy-only functions should instead use 'b'.
+:      This is used for whatever reason to force the function to be called
+:      with the long name.  Perhaps there is a varargs issue.  Use the 'M'
+:      flag instead for wrapper macros, and legacy-only functions should
+:      also use 'b'.
 :
 :         embed.h: suppress "#define foo Perl_foo"
 :
 :      autodoc.pl adds a note that this function must be explicitly called as
-:      Perl_$name with an aTHX_ parameter, unless the 'M' flag is specified.
+:      Perl_$name with an aTHX_ parameter.
 :
 :   P  Pure function:
 :
 :
 :   X  Explicitly exported:
 :
-:         add entry to the list of exported symbols, unless e or m
+:         add entry to the list of symbols available on all platforms, unless e
+:          or m
 :
 :      This is often used for private functions that are used by public
 :      macros.  In those cases the macros must use the long form of the
 :   x  Experimental, may change:
 :
 :         any doc entry is marked that it may change.  Also used to suppress
-:        making a doc entry if it would just be a placeholder.
+:        making a perlapi doc entry if it would just be a placeholder.
 :
 : In this file, pointer parameters that must not be passed NULLs should be
 : prefixed with NN.
@@ -403,7 +524,7 @@ Apd |void   |av_push        |NN AV *av|NN SV *val
 EXp    |void   |av_reify       |NN AV *av
 ApdR   |SV*    |av_shift       |NN AV *av
 Apd    |SV**   |av_store       |NN AV *av|SSize_t key|NULLOK SV *val
-AidR   |SSize_t|av_top_index   |NN AV *av
+AidRp  |SSize_t|av_top_index   |NN AV *av
 AmdR   |SSize_t|av_tindex      |NN AV *av
 Apd    |void   |av_undef       |NN AV *av
 Apdoex |SV**   |av_create_and_unshift_one|NN AV **const avp|NN SV *const val
@@ -493,6 +614,8 @@ Apd |void   |cv_undef       |NN CV* cv
 p      |void   |cv_undef_flags |NN CV* cv|U32 flags
 pd     |void   |cv_forget_slab |NULLOK CV *cv
 Ap     |void   |cx_dump        |NN PERL_CONTEXT* cx
+AiMp   |GV *   |CvGV           |NN CV *sv
+AiMTp  |I32 *  |CvDEPTH        |NN const CV * const sv
 Aphd   |SV*    |filter_add     |NULLOK filter_t funcp|NULLOK SV* datasv
 Ap     |void   |filter_del     |NN filter_t funcp
 ApRhd  |I32    |filter_read    |int idx|NN SV *buf_sv|int maxlen
@@ -538,7 +661,7 @@ Ap  |bool   |do_close       |NULLOK GV* gv|bool not_implicit
 p      |bool   |do_eof         |NN GV* gv
 
 #ifdef PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION
-pm     |bool|do_exec   |NN const char* cmd
+pM     |bool|do_exec   |NN const char* cmd
 #else
 p      |bool|do_exec   |NN const char* cmd
 #endif
@@ -759,7 +882,7 @@ Apd |HV*    |gv_stashpv     |NN const char* name|I32 flags
 Apd    |HV*    |gv_stashpvn    |NN const char* name|U32 namelen|I32 flags
 #if defined(PERL_IN_GV_C)
 i      |HV*    |gv_stashpvn_internal   |NN const char* name|U32 namelen|I32 flags
-i      |HV*    |gv_stashsvpvn_cached   |NULLOK SV *namesv|NULLOK const char* name|U32 namelen|I32 flags
+iG     |HV*    |gv_stashsvpvn_cached   |NULLOK SV *namesv|NULLOK const char* name|U32 namelen|I32 flags
 i      |GV*    |gv_fetchmeth_internal  |NULLOK HV* stash|NULLOK SV* meth|NULLOK const char* name \
                                        |STRLEN len|I32 level|U32 flags
 #endif
@@ -835,7 +958,7 @@ Am  |I32    |ibcmp_utf8     |NN const char *s1|NULLOK char **pe1|UV l1 \
 Amd    |I32    |foldEQ_utf8    |NN const char *s1|NULLOK char **pe1|UV l1 \
                                |bool u1|NN const char *s2|NULLOK char **pe2 \
                                |UV l2|bool u2
-Axp    |I32    |foldEQ_utf8_flags |NN const char *s1|NULLOK char **pe1|UV l1 \
+Cp     |I32    |foldEQ_utf8_flags |NN const char *s1|NULLOK char **pe1|UV l1 \
                                |bool u1|NN const char *s2|NULLOK char **pe2 \
                                |UV l2|bool u2|U32 flags
 AiTp   |I32    |foldEQ_latin1  |NN const char* a|NN const char* b|I32 len
@@ -860,29 +983,29 @@ pR        |OP*    |invert         |NULLOK OP* cmd
 ApR    |I32    |is_lvalue_sub
 : Used in cop.h
 XopR   |I32    |was_lvalue_sub
-ApxRTP |STRLEN |_is_utf8_char_helper|NN const U8 * const s|NN const U8 * e|const U32 flags
-AbDxpR |U32    |to_uni_upper_lc|U32 c
-AbDxpR |U32    |to_uni_title_lc|U32 c
-AbDxpR |U32    |to_uni_lower_lc|U32 c
-AbDxpR |bool   |is_uni_alnum   |UV c
-AbDxpR |bool   |is_uni_alnumc  |UV c
-AbDxpR |bool   |is_uni_idfirst |UV c
-AbDxpR |bool   |is_uni_alpha   |UV c
-AbDxpPR        |bool   |is_uni_ascii   |UV c
-AbDxpPR        |bool   |is_uni_blank   |UV c
-AbDxpPR        |bool   |is_uni_space   |UV c
-AbDxpPR        |bool   |is_uni_cntrl   |UV c
-AbDxpR |bool   |is_uni_graph   |UV c
-AbDxpR |bool   |is_uni_digit   |UV c
-AbDxpR |bool   |is_uni_upper   |UV c
-AbDxpR |bool   |is_uni_lower   |UV c
-AbDxpR |bool   |is_uni_print   |UV c
-AbDxpR |bool   |is_uni_punct   |UV c
-AbDxpPR        |bool   |is_uni_xdigit  |UV c
-Axp    |UV     |to_uni_upper   |UV c|NN U8 *p|NN STRLEN *lenp
-Axp    |UV     |to_uni_title   |UV c|NN U8 *p|NN STRLEN *lenp
-AbDxpR |bool   |isIDFIRST_lazy |NN const char* p
-AbDxpR |bool   |isALNUM_lazy   |NN const char* p
+CpRTP  |STRLEN |is_utf8_char_helper|NN const U8 * const s|NN const U8 * e|const U32 flags
+CbDpR  |U32    |to_uni_upper_lc|U32 c
+CbDpR  |U32    |to_uni_title_lc|U32 c
+CbDpR  |U32    |to_uni_lower_lc|U32 c
+CbDpR  |bool   |is_uni_alnum   |UV c
+CbDpR  |bool   |is_uni_alnumc  |UV c
+CbDpR  |bool   |is_uni_idfirst |UV c
+CbDpR  |bool   |is_uni_alpha   |UV c
+CbDpPR |bool   |is_uni_ascii   |UV c
+CbDpPR |bool   |is_uni_blank   |UV c
+CbDpPR |bool   |is_uni_space   |UV c
+CbDpPR |bool   |is_uni_cntrl   |UV c
+CbDpR  |bool   |is_uni_graph   |UV c
+CbDpR  |bool   |is_uni_digit   |UV c
+CbDpR  |bool   |is_uni_upper   |UV c
+CbDpR  |bool   |is_uni_lower   |UV c
+CbDpR  |bool   |is_uni_print   |UV c
+CbDpR  |bool   |is_uni_punct   |UV c
+CbDpPR |bool   |is_uni_xdigit  |UV c
+Cp     |UV     |to_uni_upper   |UV c|NN U8 *p|NN STRLEN *lenp
+Cp     |UV     |to_uni_title   |UV c|NN U8 *p|NN STRLEN *lenp
+CbDpR  |bool   |isIDFIRST_lazy |NN const char* p
+CbDpR  |bool   |isALNUM_lazy   |NN const char* p
 p      |void   |init_uniprops
 #ifdef PERL_IN_UTF8_C
 STR    |U8     |to_lower_latin1|const U8 c|NULLOK U8 *p|NULLOK STRLEN *lenp  \
@@ -899,33 +1022,33 @@ EXTp     |UV        |_to_fold_latin1|const U8 c|NN U8 *p|NN STRLEN *lenp|const unsig
 #if defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C)
 p      |UV     |_to_upper_title_latin1|const U8 c|NN U8 *p|NN STRLEN *lenp|const char S_or_s
 #endif
-Axp    |UV     |to_uni_lower   |UV c|NN U8 *p|NN STRLEN *lenp
-Axmp   |UV     |to_uni_fold    |UV c|NN U8 *p|NN STRLEN *lenp
-Axp    |UV     |_to_uni_fold_flags|UV c|NN U8 *p|NN STRLEN *lenp|U8 flags
-AbDxpR |bool   |is_uni_alnum_lc|UV c
-AbDxpR |bool   |is_uni_alnumc_lc|UV c
-AbDxpR |bool   |is_uni_idfirst_lc|UV c
-AxpR   |bool   |_is_uni_perl_idcont|UV c
-AxpR   |bool   |_is_uni_perl_idstart|UV c
-AbDxpR |bool   |is_uni_alpha_lc|UV c
-AbDxpPR        |bool   |is_uni_ascii_lc|UV c
-AbDxpPR        |bool   |is_uni_space_lc|UV c
-AbDxpPR        |bool   |is_uni_blank_lc|UV c
-AbDxpPR        |bool   |is_uni_cntrl_lc|UV c
-AbDxpR |bool   |is_uni_graph_lc|UV c
-AbDxpR |bool   |is_uni_digit_lc|UV c
-AbDxpR |bool   |is_uni_upper_lc|UV c
-AbDxpR |bool   |is_uni_lower_lc|UV c
-AbDxpR |bool   |is_uni_print_lc|UV c
-AbDxpR |bool   |is_uni_punct_lc|UV c
-AbDxpPR        |bool   |is_uni_xdigit_lc|UV c
+Cp     |UV     |to_uni_lower   |UV c|NN U8 *p|NN STRLEN *lenp
+Cm     |UV     |to_uni_fold    |UV c|NN U8 *p|NN STRLEN *lenp
+Cp     |UV     |_to_uni_fold_flags|UV c|NN U8 *p|NN STRLEN *lenp|U8 flags
+CbDpR  |bool   |is_uni_alnum_lc|UV c
+CbDpR  |bool   |is_uni_alnumc_lc|UV c
+CbDpR  |bool   |is_uni_idfirst_lc|UV c
+CpR    |bool   |_is_uni_perl_idcont|UV c
+CpR    |bool   |_is_uni_perl_idstart|UV c
+CbDpR  |bool   |is_uni_alpha_lc|UV c
+CbDpPR |bool   |is_uni_ascii_lc|UV c
+CbDpPR |bool   |is_uni_space_lc|UV c
+CbDpPR |bool   |is_uni_blank_lc|UV c
+CbDpPR |bool   |is_uni_cntrl_lc|UV c
+CbDpR  |bool   |is_uni_graph_lc|UV c
+CbDpR  |bool   |is_uni_digit_lc|UV c
+CbDpR  |bool   |is_uni_upper_lc|UV c
+CbDpR  |bool   |is_uni_lower_lc|UV c
+CbDpR  |bool   |is_uni_print_lc|UV c
+CbDpR  |bool   |is_uni_punct_lc|UV c
+CbDpPR |bool   |is_uni_xdigit_lc|UV c
 ATdmoR |bool   |is_utf8_invariant_string|NN const U8* const s              \
                |STRLEN len
-ATidR  |bool   |is_utf8_invariant_string_loc|NN const U8* const s          \
+ATidRp |bool   |is_utf8_invariant_string_loc|NN const U8* const s          \
                |STRLEN len                                                 \
                |NULLOK const U8 ** ep
 #ifndef EBCDIC
-ATiR   |unsigned int|_variant_byte_number|PERL_UINTMAX_T word
+CTiRp  |unsigned int|variant_byte_number|PERL_UINTMAX_T word
 #endif
 #if defined(PERL_CORE) || defined(PERL_EXT)
 EiTRd  |Size_t |variant_under_utf8_count|NN const U8* const s              \
@@ -934,19 +1057,19 @@ EiTRd    |Size_t |variant_under_utf8_count|NN const U8* const s              \
 AmTdRP |bool   |is_ascii_string|NN const U8* const s|STRLEN len
 AmTdRP |bool   |is_invariant_string|NN const U8* const s|STRLEN len
 #if defined(PERL_CORE) || defined (PERL_EXT)
-EXTidR |bool   |is_utf8_non_invariant_string|NN const U8* const s          \
+EXTidRp        |bool   |is_utf8_non_invariant_string|NN const U8* const s          \
                |STRLEN len
 #endif
 AbTpdD |STRLEN |is_utf8_char   |NN const U8 *s
 AbMTpd |STRLEN |is_utf8_char_buf|NN const U8 *buf|NN const U8 *buf_end
-ATidR  |Size_t |isUTF8_CHAR|NN const U8 * const s0                         \
+ATidRp |Size_t |isUTF8_CHAR|NN const U8 * const s0                         \
                            |NN const U8 * const e
-ATidR  |Size_t |isSTRICT_UTF8_CHAR |NN const U8 * const s0                 \
+ATidRp |Size_t |isSTRICT_UTF8_CHAR |NN const U8 * const s0                 \
                                    |NN const U8 * const e
-ATidR  |Size_t |isC9_STRICT_UTF8_CHAR |NN const U8 * const s0              \
+ATidRp |Size_t |isC9_STRICT_UTF8_CHAR |NN const U8 * const s0              \
                                       |NN const U8 * const e
 ATmdR  |bool   |is_utf8_string |NN const U8 *s|STRLEN len
-ATidR  |bool   |is_utf8_string_flags                                       \
+ATidRp |bool   |is_utf8_string_flags                                       \
                |NN const U8 *s|STRLEN len|const U32 flags
 ATmdR  |bool   |is_strict_utf8_string|NN const U8 *s|STRLEN len
 ATmdR  |bool   |is_c9strict_utf8_string|NN const U8 *s|STRLEN len
@@ -962,13 +1085,13 @@ ATdm     |bool   |is_c9strict_utf8_string_loc                                \
 ATipd  |bool   |is_utf8_string_loclen                                      \
                |NN const U8 *s|STRLEN len|NULLOK const U8 **ep             \
                |NULLOK STRLEN *el
-ATid   |bool   |is_utf8_string_loclen_flags                                \
+ATidp  |bool   |is_utf8_string_loclen_flags                                \
                |NN const U8 *s|STRLEN len|NULLOK const U8 **ep             \
                |NULLOK STRLEN *el|const U32 flags
-ATid   |bool   |is_strict_utf8_string_loclen                               \
+ATidp  |bool   |is_strict_utf8_string_loclen                               \
                |NN const U8 *s|STRLEN len|NULLOK const U8 **ep     \
                |NULLOK STRLEN *el
-ATid   |bool   |is_c9strict_utf8_string_loclen                             \
+ATidp  |bool   |is_c9strict_utf8_string_loclen                             \
                |NN const U8 *s|STRLEN len|NULLOK const U8 **ep     \
                |NULLOK STRLEN *el
 AmTd   |bool   |is_utf8_fixed_width_buf_flags                              \
@@ -976,51 +1099,51 @@ AmTd     |bool   |is_utf8_fixed_width_buf_flags                              \
 AmTd   |bool   |is_utf8_fixed_width_buf_loc_flags                          \
                |NN const U8 * const s|STRLEN len                           \
                |NULLOK const U8 **ep|const U32 flags
-ATid   |bool   |is_utf8_fixed_width_buf_loclen_flags                       \
+ATidp  |bool   |is_utf8_fixed_width_buf_loclen_flags                       \
                |NN const U8 * const s|STRLEN len                           \
                |NULLOK const U8 **ep|NULLOK STRLEN *el|const U32 flags
 AmTdP  |bool   |is_utf8_valid_partial_char                                 \
                |NN const U8 * const s|NN const U8 * const e
-ATidR  |bool   |is_utf8_valid_partial_char_flags                           \
+ATidRp |bool   |is_utf8_valid_partial_char_flags                           \
                |NN const U8 * const s|NN const U8 * const e|const U32 flags
-AxpR   |bool   |_is_uni_FOO|const U8 classnum|const UV c
-AxpR   |bool   |_is_utf8_FOO|U8 classnum|NN const U8 * const p             \
+CpR    |bool   |_is_uni_FOO|const U8 classnum|const UV c
+CpR    |bool   |_is_utf8_FOO|U8 classnum|NN const U8 * const p             \
                |NN const char * const name                                 \
                |NN const char * const alternative                          \
                |const bool use_utf8|const bool use_locale                  \
                |NN const char * const file|const unsigned line
-AxpR   |bool   |_is_utf8_FOO_with_len|const U8 classnum|NN const U8 *p     \
+CpR    |bool   |_is_utf8_FOO_with_len|const U8 classnum|NN const U8 *p     \
                |NN const U8 * const e
-AbDxpR |bool   |is_utf8_alnum  |NN const U8 *p
-AbDxpR |bool   |is_utf8_alnumc |NN const U8 *p
-AbDxpR |bool   |is_utf8_idfirst|NN const U8 *p
-AbDxpR |bool   |is_utf8_xidfirst|NN const U8 *p
-AxpR   |bool   |_is_utf8_idcont|NN const U8 *p
-AxpR   |bool   |_is_utf8_idstart|NN const U8 *p
-AxpR   |bool   |_is_utf8_xidcont|NN const U8 *p
-AxpR   |bool   |_is_utf8_xidstart|NN const U8 *p
-AxpR   |bool   |_is_utf8_perl_idcont_with_len|NN const U8 *p               \
+CbDpR  |bool   |is_utf8_alnum  |NN const U8 *p
+CbDpR  |bool   |is_utf8_alnumc |NN const U8 *p
+CbDpR  |bool   |is_utf8_idfirst|NN const U8 *p
+CbDpR  |bool   |is_utf8_xidfirst|NN const U8 *p
+CpR    |bool   |_is_utf8_idcont|NN const U8 *p
+CpR    |bool   |_is_utf8_idstart|NN const U8 *p
+CpR    |bool   |_is_utf8_xidcont|NN const U8 *p
+CpR    |bool   |_is_utf8_xidstart|NN const U8 *p
+CpR    |bool   |_is_utf8_perl_idcont_with_len|NN const U8 *p               \
                |NN const U8 * const e
-AxpR   |bool   |_is_utf8_perl_idstart_with_len|NN const U8 *p              \
+CpR    |bool   |_is_utf8_perl_idstart_with_len|NN const U8 *p              \
                |NN const U8 * const e
-AbDxpR |bool   |is_utf8_idcont |NN const U8 *p
-AbDxpR |bool   |is_utf8_xidcont        |NN const U8 *p
-AbDxpR |bool   |is_utf8_alpha  |NN const U8 *p
-AbDxpR |bool   |is_utf8_ascii  |NN const U8 *p
-AbDxpR |bool   |is_utf8_blank  |NN const U8 *p
-AbDxpR |bool   |is_utf8_space  |NN const U8 *p
-AbDxpR |bool   |is_utf8_perl_space     |NN const U8 *p
-AbDxpR |bool   |is_utf8_perl_word      |NN const U8 *p
-AbDxpR |bool   |is_utf8_cntrl  |NN const U8 *p
-AbDxpR |bool   |is_utf8_digit  |NN const U8 *p
-AbDxpR |bool   |is_utf8_posix_digit    |NN const U8 *p
-AbDxpR |bool   |is_utf8_graph  |NN const U8 *p
-AbDxpR |bool   |is_utf8_upper  |NN const U8 *p
-AbDxpR |bool   |is_utf8_lower  |NN const U8 *p
-AbDxpR |bool   |is_utf8_print  |NN const U8 *p
-AbDxpR |bool   |is_utf8_punct  |NN const U8 *p
-AbDxpR |bool   |is_utf8_xdigit |NN const U8 *p
-AxpR   |bool   |_is_utf8_mark  |NN const U8 *p
+CbDpR  |bool   |is_utf8_idcont |NN const U8 *p
+CbDpR  |bool   |is_utf8_xidcont        |NN const U8 *p
+CbDpR  |bool   |is_utf8_alpha  |NN const U8 *p
+CbDpR  |bool   |is_utf8_ascii  |NN const U8 *p
+CbDpR  |bool   |is_utf8_blank  |NN const U8 *p
+CbDpR  |bool   |is_utf8_space  |NN const U8 *p
+CbDpR  |bool   |is_utf8_perl_space     |NN const U8 *p
+CbDpR  |bool   |is_utf8_perl_word      |NN const U8 *p
+CbDpR  |bool   |is_utf8_cntrl  |NN const U8 *p
+CbDpR  |bool   |is_utf8_digit  |NN const U8 *p
+CbDpR  |bool   |is_utf8_posix_digit    |NN const U8 *p
+CbDpR  |bool   |is_utf8_graph  |NN const U8 *p
+CbDpR  |bool   |is_utf8_upper  |NN const U8 *p
+CbDpR  |bool   |is_utf8_lower  |NN const U8 *p
+CbDpR  |bool   |is_utf8_print  |NN const U8 *p
+CbDpR  |bool   |is_utf8_punct  |NN const U8 *p
+CbDpR  |bool   |is_utf8_xdigit |NN const U8 *p
+CpR    |bool   |_is_utf8_mark  |NN const U8 *p
 AbDxpR |bool   |is_utf8_mark   |NN const U8 *p
 #if defined(PERL_CORE) || defined(PERL_EXT)
 EXdpR  |bool   |isSCRIPT_RUN   |NN const U8 *s|NN const U8 *send   \
@@ -1178,7 +1301,7 @@ p |int    |magic_setcollxfrm|NN SV* sv|NN MAGIC* mg
 pbD    |char*  |mem_collxfrm   |NN const char* input_string|STRLEN len|NN STRLEN* xlen
 : Defined in locale.c, used only in sv.c
 #   if defined(PERL_IN_LOCALE_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_MATHOMS_C)
-px     |char*  |_mem_collxfrm  |NN const char* input_string    \
+p      |char*  |_mem_collxfrm  |NN const char* input_string    \
                                |STRLEN len                     \
                                |NN STRLEN* xlen                \
                                |bool utf8
@@ -1248,8 +1371,8 @@ pX        |I32    |my_stat_flags  |NULLOK const U32 flags
 Afp    |char * |my_strftime    |NN const char *fmt|int sec|int min|int hour|int mday|int mon|int year|int wday|int yday|int isdst
 : Used in pp_ctl.c
 p      |void   |my_unexec
-AbDxTPR        |UV     |NATIVE_TO_NEED |const UV enc|const UV ch
-AbDxTPR        |UV     |ASCII_TO_NEED  |const UV enc|const UV ch
+CbDTPR |UV     |NATIVE_TO_NEED |const UV enc|const UV ch
+CbDTPR |UV     |ASCII_TO_NEED  |const UV enc|const UV ch
 ApR    |OP*    |newANONLIST    |NULLOK OP* o
 ApR    |OP*    |newANONHASH    |NULLOK OP* o
 Ap     |OP*    |newANONSUB     |I32 floor|NULLOK OP* proto|NULLOK OP* block
@@ -1425,8 +1548,8 @@ ATdo      |const char*|Perl_langinfo|const nl_item item
 #else
 ATdo   |const char*|Perl_langinfo|const int item
 #endif
-ApOx   |int    |init_i18nl10n  |int printwarn
-AbpOxD |int    |init_i18nl14n  |int printwarn
+CpO    |int    |init_i18nl10n  |int printwarn
+CbpOD  |int    |init_i18nl14n  |int printwarn
 p      |char*  |my_strerror    |const int errnum
 XpT    |void   |_warn_problematic_locale
 Xp     |void   |set_numeric_underlying
@@ -1458,6 +1581,7 @@ ApMb      |OP*    |ref            |NULLOK OP* o|I32 type
 S      |OP*    |refkids        |NULLOK OP* o|I32 type
 #endif
 Ap     |void   |regdump        |NN const regexp* r
+CiTop  |struct regexp *|ReANY  |NN const REGEXP * const re
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_PERL_C) || defined(PERL_IN_UTF8_C)
 EXpR   |SV*    |_new_invlist_C_array|NN const UV* const list
 EXp    |bool   |_invlistEQ     |NN SV* const a|NN SV* const b|const bool complement_b
@@ -1482,14 +1606,14 @@ p       |REGEXP*|re_op_compile  |NULLOK SV ** const patternp \
                                |NULLOK bool *is_bare_re \
                                |const U32 rx_flags|const U32 pm_flags
 Ap     |REGEXP*|re_compile     |NN SV * const pattern|U32 orig_rx_flags
-Ap     |char*  |re_intuit_start|NN REGEXP * const rx \
+Cp     |char*  |re_intuit_start|NN REGEXP * const rx \
                                |NULLOK SV* sv \
                                |NN const char* const strbeg \
                                |NN char* strpos \
                                |NN char* strend \
                                |const U32 flags \
                                |NULLOK re_scream_pos_data *data
-Ap     |SV*    |re_intuit_string|NN REGEXP  *const r
+Cp     |SV*    |re_intuit_string|NN REGEXP  *const r
 Ap     |I32    |regexec_flags  |NN REGEXP *const rx|NN char *stringarg \
                                |NN char *strend|NN char *strbeg \
                                |SSize_t minend|NN SV *sv \
@@ -1546,7 +1670,7 @@ Apda      |char*  |savesharedsvpv |NN SV *sv
 Apda   |char*  |savesvpv       |NN SV* sv
 Ap     |void   |savestack_grow
 Ap     |void   |savestack_grow_cnt     |I32 need
-Amp    |void   |save_aelem     |NN AV* av|SSize_t idx|NN SV **sptr
+Am     |void   |save_aelem     |NN AV* av|SSize_t idx|NN SV **sptr
 Ap     |void   |save_aelem_flags|NN AV* av|SSize_t idx|NN SV **sptr \
                                 |const U32 flags
 Ap     |I32    |save_alloc     |I32 size|I32 pad
@@ -1569,7 +1693,7 @@ Ap        |void   |save_shared_pvref|NN char** str
 Adp    |void   |save_gp        |NN GV* gv|I32 empty
 Apdh   |HV*    |save_hash      |NN GV* gv
 Ap     |void   |save_hints
-Amp    |void   |save_helem     |NN HV *hv|NN SV *key|NN SV **sptr
+Am     |void   |save_helem     |NN HV *hv|NN SV *key|NN SV **sptr
 Ap     |void   |save_helem_flags|NN HV *hv|NN SV *key|NN SV **sptr|const U32 flags
 Apdh   |void   |save_hptr      |NN HV** hptr
 Ap     |void   |save_I16       |NN I16* intp
@@ -1602,6 +1726,8 @@ Ap        |void   |save_pushptrptr|NULLOK void *const ptr1 \
 S      |void   |save_pushptri32ptr|NULLOK void *const ptr1|const I32 i \
                                |NULLOK void *const ptr2|const int type
 #endif
+Xiop   |I32    |TOPMARK
+Xiop   |I32    |POPMARK
 : Used in perly.y
 p      |OP*    |sawparens      |NULLOK OP* o
 Apd    |OP*    |op_contextualize|NN OP* o|I32 context
@@ -1692,10 +1818,10 @@ Apd     |void   |sv_clear       |NN SV *const orig_sv
 #if defined(PERL_IN_SV_C)
 S      |bool   |curse          |NN SV * const sv|const bool check_refcnt
 #endif
-AMopd  |I32    |sv_cmp         |NULLOK SV *const sv1|NULLOK SV *const sv2
+AMpd   |I32    |sv_cmp         |NULLOK SV *const sv1|NULLOK SV *const sv2
 Apd    |I32    |sv_cmp_flags   |NULLOK SV *const sv1|NULLOK SV *const sv2 \
                                |const U32 flags
-AMopd  |I32    |sv_cmp_locale  |NULLOK SV *const sv1|NULLOK SV *const sv2
+AMpd   |I32    |sv_cmp_locale  |NULLOK SV *const sv1|NULLOK SV *const sv2
 Apd    |I32    |sv_cmp_locale_flags    |NULLOK SV *const sv1 \
                                |NULLOK SV *const sv2|const U32 flags
 #if defined(USE_LOCALE_COLLATE)
@@ -1741,7 +1867,7 @@ Apd       |void   |sv_magic       |NN SV *const sv|NULLOK SV *const obj|const int how \
 Apd    |MAGIC *|sv_magicext    |NN SV *const sv|NULLOK SV *const obj|const int how \
                                |NULLOK const MGVTBL *const vtbl|NULLOK const char *const name \
                                |const I32 namlen
-EiT    |bool   |sv_only_taint_gmagic|NN SV *sv
+EiTp   |bool   |sv_only_taint_gmagic|NN SV *sv
 : exported for re.pm
 EXp    |MAGIC *|sv_magicext_mglob|NN SV *sv
 ApdbMR |SV*    |sv_mortalcopy  |NULLOK SV *const oldsv
@@ -1838,15 +1964,15 @@ ESR     |SV*    |invlist_contents|NN SV* const invlist              \
 ESRT   |bool   |new_regcurly   |NN const char *s|NN const char *e
 #endif
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C)
-EXm    |void   |_invlist_intersection  |NN SV* const a|NN SV* const b|NN SV** i
+m      |void   |_invlist_intersection  |NN SV* const a|NN SV* const b|NN SV** i
 EXp    |void   |_invlist_intersection_maybe_complement_2nd \
                |NULLOK SV* const a|NN SV* const b          \
                |const bool complement_b|NN SV** i
-EXm    |void   |_invlist_union |NULLOK SV* const a|NN SV* const b|NN SV** output
+Cm     |void   |_invlist_union |NULLOK SV* const a|NN SV* const b|NN SV** output
 EXp    |void   |_invlist_union_maybe_complement_2nd        \
                |NULLOK SV* const a|NN SV* const b          \
                |const bool complement_b|NN SV** output
-EXm    |void   |_invlist_subtract|NN SV* const a|NN SV* const b|NN SV** result
+m      |void   |_invlist_subtract|NN SV* const a|NN SV* const b|NN SV** result
 EXp    |void   |_invlist_invert|NN SV* const invlist
 EXpR   |SV*    |_new_invlist   |IV initial_size
 EXpR   |SV*    |_add_range_to_invlist  |NULLOK SV* invlist|UV start|UV end
@@ -1863,6 +1989,9 @@ EiRT      |UV     |_invlist_len   |NN SV* const invlist
 EiRT   |bool   |_invlist_contains_cp|NN SV* const invlist|const UV cp
 EXpRT  |SSize_t|_invlist_search        |NN SV* const invlist|const UV cp
 #endif
+#if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C)
+EiT    |const char *|get_regex_charset_name|const U32 flags|NN STRLEN* const lenp
+#endif
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C)
 EXp    |SV*    |_get_regclass_nonbitmap_data                              \
                                |NULLOK const regexp *prog                 \
@@ -1879,7 +2008,7 @@ EXp       |void   |_invlist_dump  |NN PerlIO *file|I32 level   \
 #endif
 Ap     |void   |taint_env
 Ap     |void   |taint_proper   |NULLOK const char* f|NN const char *const s
-Epx    |char * |_byte_dump_string                                      \
+Ep     |char * |_byte_dump_string                                      \
                                |NN const U8 * const start              \
                                |const STRLEN len                       \
                                |const bool format
@@ -1890,7 +2019,7 @@ iTR       |int    |does_utf8_overflow|NN const U8 * const s               \
 iTR    |int    |is_utf8_overlong_given_start_byte_ok|NN const U8 * const s \
                                                     |const STRLEN len
 iTR    |int    |isFF_OVERLONG  |NN const U8 * const s|const STRLEN len
-SxR    |char * |unexpected_non_continuation_text                       \
+S    |char * |unexpected_non_continuation_text                       \
                |NN const U8 * const s                                  \
                |STRLEN print_len                                       \
                |const STRLEN non_cont_byte_pos                         \
@@ -1922,19 +2051,19 @@ S       |UV     |turkic_lc      |NN const U8 * const p0|NN const U8 * const e|NN U8* ustrp|NN S
 S      |UV     |turkic_uc      |NN const U8 * const p |NN const U8 * const e|NN U8* ustrp|NN STRLEN *lenp
 #endif
 ApbMdD |UV     |to_utf8_lower  |NN const U8 *p|NN U8* ustrp|NULLOK STRLEN *lenp
-Axp    |UV     |_to_utf8_lower_flags|NN const U8 *p|NULLOK const U8* e         \
+Cp     |UV     |_to_utf8_lower_flags|NN const U8 *p|NULLOK const U8* e         \
                                |NN U8* ustrp|NULLOK STRLEN *lenp|bool flags    \
                                |NN const char * const file|const int line
 ApbMdD |UV     |to_utf8_upper  |NN const U8 *p|NN U8* ustrp|NULLOK STRLEN *lenp
-Axp    |UV     |_to_utf8_upper_flags   |NN const U8 *p|NULLOK const U8 *e      \
+Cp     |UV     |_to_utf8_upper_flags   |NN const U8 *p|NULLOK const U8 *e      \
                                |NN U8* ustrp|NULLOK STRLEN *lenp|bool flags    \
                                |NN const char * const file|const int line
 ApbMdD |UV     |to_utf8_title  |NN const U8 *p|NN U8* ustrp|NULLOK STRLEN *lenp
-Axp    |UV     |_to_utf8_title_flags   |NN const U8 *p|NULLOK const U8* e      \
+Cp     |UV     |_to_utf8_title_flags   |NN const U8 *p|NULLOK const U8* e      \
                                |NN U8* ustrp|NULLOK STRLEN *lenp|bool flags    \
                                |NN const char * const file|const int line
 ApbMdD |UV     |to_utf8_fold   |NN const U8 *p|NN U8* ustrp|NULLOK STRLEN *lenp
-Axp    |UV     |_to_utf8_fold_flags|NN const U8 *p|NULLOK const U8 *e          \
+Cp     |UV     |_to_utf8_fold_flags|NN const U8 *p|NULLOK const U8 *e          \
                                |NN U8* ustrp|NULLOK STRLEN *lenp|U8 flags  \
                                |NN const char * const file|const int line
 #if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C)
@@ -1956,7 +2085,7 @@ Ap        |void   |unsharepvn     |NULLOK const char* sv|I32 len|U32 hash
 p      |void   |unshare_hek    |NULLOK HEK* hek
 : Used in perly.y
 p      |void   |utilize        |int aver|I32 floor|NULLOK OP* version|NN OP* idop|NULLOK OP* arg
-Apx    |void   |_force_out_malformed_utf8_message                          \
+Cp     |void   |_force_out_malformed_utf8_message                          \
                |NN const U8 *const p|NN const U8 * const e|const U32 flags \
                |const bool die_here
 EXp    |U8*    |utf16_to_utf8  |NN U8* p|NN U8 *d|I32 bytelen|NN I32 *newlen
@@ -1977,11 +2106,11 @@ AxTp    |U8*    |bytes_from_utf8_loc|NN const U8 *s                         \
                                    |NULLOK const U8 ** first_unconverted
 Apxd   |U8*    |bytes_to_utf8  |NN const U8 *s|NN STRLEN *lenp
 ApdD   |UV     |utf8_to_uvchr  |NN const U8 *s|NULLOK STRLEN *retlen
-AbpdD  |UV     |utf8_to_uvuni  |NN const U8 *s|NULLOK STRLEN *retlen
-AbpxD  |UV     |valid_utf8_to_uvuni    |NN const U8 *s|NULLOK STRLEN *retlen
+CbpdD  |UV     |utf8_to_uvuni  |NN const U8 *s|NULLOK STRLEN *retlen
+CbpD   |UV     |valid_utf8_to_uvuni    |NN const U8 *s|NULLOK STRLEN *retlen
 AMpd   |UV     |utf8_to_uvchr_buf      |NN const U8 *s|NN const U8 *send|NULLOK STRLEN *retlen
-Ai     |UV     |_utf8_to_uvchr_buf     |NN const U8 *s|NN const U8 *send|NULLOK STRLEN *retlen
-ApdD   |UV     |utf8_to_uvuni_buf      |NN const U8 *s|NN const U8 *send|NULLOK STRLEN *retlen
+Cip    |UV     |utf8_to_uvchr_buf_helper|NN const U8 *s|NN const U8 *send|NULLOK STRLEN *retlen
+CpdD   |UV     |utf8_to_uvuni_buf      |NN const U8 *s|NN const U8 *send|NULLOK STRLEN *retlen
 p      |bool   |check_utf8_print       |NN const U8 *s|const STRLEN len
 
 AdMTp  |UV     |utf8n_to_uvchr |NN const U8 *s                             \
@@ -1993,29 +2122,29 @@ AdMTp   |UV     |utf8n_to_uvchr_error|NN const U8 *s                        \
                                |NULLOK STRLEN *retlen                      \
                                |const U32 flags                            \
                                |NULLOK U32 * errors
-AxTdi  |UV     |utf8n_to_uvchr_msgs|NN const U8 *s                         \
+AxTdip |UV     |utf8n_to_uvchr_msgs|NN const U8 *s                         \
                                |STRLEN curlen                              \
                                |NULLOK STRLEN *retlen                      \
                                |const U32 flags                            \
                                |NULLOK U32 * errors                        \
                                |NULLOK AV ** msgs
-AxTp   |UV     |_utf8n_to_uvchr_msgs_helper                                \
+CTp    |UV     |_utf8n_to_uvchr_msgs_helper                                \
                                |NN const U8 *s                             \
                                |STRLEN curlen                              \
                                |NULLOK STRLEN *retlen                      \
                                |const U32 flags                            \
                                |NULLOK U32 * errors                        \
                                |NULLOK AV ** msgs
-AipTRd |UV     |valid_utf8_to_uvchr    |NN const U8 *s|NULLOK STRLEN *retlen
-Adp    |UV     |utf8n_to_uvuni|NN const U8 *s|STRLEN curlen|NULLOK STRLEN *retlen|U32 flags
+CipTRd |UV     |valid_utf8_to_uvchr    |NN const U8 *s|NULLOK STRLEN *retlen
+Cdp    |UV     |utf8n_to_uvuni|NN const U8 *s|STRLEN curlen|NULLOK STRLEN *retlen|U32 flags
 
 Adm    |U8*    |uvchr_to_utf8  |NN U8 *d|UV uv
-Ap     |U8*    |uvuni_to_utf8  |NN U8 *d|UV uv
+Cp     |U8*    |uvuni_to_utf8  |NN U8 *d|UV uv
 Adm    |U8*    |uvchr_to_utf8_flags    |NN U8 *d|UV uv|UV flags
 Admx   |U8*    |uvchr_to_utf8_flags_msgs|NN U8 *d|UV uv|UV flags|NULLOK HV ** msgs
-AMpod  |U8*    |uvoffuni_to_utf8_flags |NN U8 *d|UV uv|const UV flags
-Apx    |U8*    |uvoffuni_to_utf8_flags_msgs|NN U8 *d|UV uv|const UV flags|NULLOK HV** msgs
-Adp    |U8*    |uvuni_to_utf8_flags    |NN U8 *d|UV uv|UV flags
+CMpd   |U8*    |uvoffuni_to_utf8_flags |NN U8 *d|UV uv|const UV flags
+Cp     |U8*    |uvoffuni_to_utf8_flags_msgs|NN U8 *d|UV uv|const UV flags|NULLOK HV** msgs
+Cdp    |U8*    |uvuni_to_utf8_flags    |NN U8 *d|UV uv|UV flags
 Apd    |char*  |pv_uni_display |NN SV *dsv|NN const U8 *spv|STRLEN len|STRLEN pvlim|UV flags
 ApdR   |char*  |sv_uni_display |NN SV *dsv|NN SV *ssv|STRLEN pvlim|UV flags
 EXpR   |Size_t |_inverse_folds |const UV cp                                \
@@ -2065,7 +2194,7 @@ Ap        |I32    |whichsig_sv    |NN SV* sigsv
 Ap     |I32    |whichsig_pv    |NN const char* sig
 Ap     |I32    |whichsig_pvn   |NN const char* sig|STRLEN len
 : used to check for NULs in pathnames and other names
-AiRd   |bool   |is_safe_syscall|NN const char *pv|STRLEN len|NN const char *what|NN const char *op_name
+AiRdp  |bool   |is_safe_syscall|NN const char *pv|STRLEN len|NN const char *what|NN const char *op_name
 #ifdef PERL_CORE
 iTR    |bool   |should_warn_nl|NN const char *pv
 #endif
@@ -2099,7 +2228,7 @@ ATpa      |Malloc_t|safesysmalloc |MEM_SIZE nbytes
 ATpa   |Malloc_t|safesyscalloc |MEM_SIZE elements|MEM_SIZE size
 ATpR   |Malloc_t|safesysrealloc|Malloc_t where|MEM_SIZE nbytes
 ATp    |Free_t |safesysfree    |Malloc_t where
-AirTe  |void   |croak_memory_wrap
+AirTep |void   |croak_memory_wrap
 #if defined(PERL_GLOBAL_STRUCT)
 Ap     |struct perl_vars *|GetVars
 Ap     |struct perl_vars*|init_global_struct
@@ -2172,6 +2301,13 @@ pX       |SSize_t|tmps_grow_p    |SSize_t ix
 Apd    |SV*    |sv_rvweaken    |NN SV *const sv
 Apd    |SV*    |sv_rvunweaken  |NN SV *const sv
 ATpxd  |SV*    |sv_get_backrefs|NN SV *const sv
+AiTMdp |SV *   |SvREFCNT_inc   |NULLOK SV *sv
+AiTMdp |SV *   |SvREFCNT_inc_NN|NN SV *sv
+AiTMdp |void   |SvREFCNT_inc_void|NULLOK SV *sv
+AiMdp  |void   |SvREFCNT_dec   |NULLOK SV *sv
+AiMdp  |void   |SvREFCNT_dec_NN|NN SV *sv
+AiTp   |void   |SvAMAGIC_on    |NN SV *sv
+AiTp   |void   |SvAMAGIC_off   |NN SV *sv
 : This is indirectly referenced by globals.c. This is somewhat annoying.
 p      |int    |magic_killbackrefs|NN SV *sv|NN MAGIC *mg
 Ap     |OP*    |newANONATTRSUB |I32 floor|NULLOK OP *proto|NULLOK OP *attrs|NULLOK OP *block
@@ -2224,7 +2360,9 @@ Ap        |void   |sys_intern_dup |NN struct interp_intern* src|NN struct interp_intern*
 #  endif
 #endif
 
-Admop  |const XOP *    |custom_op_xop  |NN const OP *o
+: The reason for the 'u' flag is that this passes "aTHX_ x" to its callee: not
+: a legal C parameter
+Admu   |const XOP *    |Perl_custom_op_xop     |NN const OP *o
 AbpRdD |const char *   |custom_op_name |NN const OP *o
 AbpRdD |const char *   |custom_op_desc |NN const OP *o
 pRX    |XOPRETANY      |custom_op_get_field    |NN const OP *o|const xop_flags_enum field
@@ -2683,7 +2821,7 @@ ESR       |bool   |regtail_study  |NN RExC_state_t *pRExC_state \
 #endif
 
 #if defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C)
-EXRpx  |bool   |isFOO_lc       |const U8 classnum|const U8 character
+EXRp   |bool   |isFOO_lc       |const U8 classnum|const U8 character
 #endif
 
 #if defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C)
@@ -2991,7 +3129,7 @@ STR       |char * |setlocale_debug_string |const int category                 \
         || defined(PERL_IN_MG_C)       \
        || defined (PERL_EXT_POSIX)     \
        || defined (PERL_EXT_LANGINFO))
-Apx    |bool   |_is_cur_LC_category_utf8|int category
+Cp     |bool   |_is_cur_LC_category_utf8|int category
 #endif
 
 
@@ -3034,7 +3172,7 @@ SR        |U8*    |swash_scan_list_line|NN U8* l|NN U8* const lend|NN UV* min \
                |NN const U8* const typestr
 #endif
 
-EXiT   |void   |append_utf8_from_native_byte|const U8 byte|NN U8** dest
+EXiTp  |void   |append_utf8_from_native_byte|const U8 byte|NN U8** dest
 
 Apd    |void   |sv_set_undef   |NN SV *sv
 Apd    |void   |sv_setsv_flags |NN SV *dstr|NULLOK SV *sstr|const I32 flags
@@ -3047,10 +3185,10 @@ Amd     |STRLEN |sv_utf8_upgrade_flags|NN SV *const sv|const I32 flags
 Adp    |STRLEN |sv_utf8_upgrade_flags_grow|NN SV *const sv|const I32 flags|STRLEN extra
 Apd    |char*  |sv_pvn_force_flags|NN SV *const sv|NULLOK STRLEN *const lp|const I32 flags
 AdpMb  |void   |sv_copypv      |NN SV *const dsv|NN SV *const ssv
-Apmd   |void   |sv_copypv_nomg |NN SV *const dsv|NN SV *const ssv
+Amd    |void   |sv_copypv_nomg |NN SV *const dsv|NN SV *const ssv
 Apd    |void   |sv_copypv_flags        |NN SV *const dsv|NN SV *const ssv|const I32 flags
-Apo    |char*  |my_atof2       |NN const char *orig|NN NV* value
-Ap     |char*  |my_atof3       |NN const char *orig|NN NV* value|const STRLEN len
+Cpo    |char*  |my_atof2       |NN const char *orig|NN NV* value
+Cp     |char*  |my_atof3       |NN const char *orig|NN NV* value|const STRLEN len
 ApT    |int    |my_socketpair  |int family|int type|int protocol|int fd[2]
 ApT    |int    |my_dirfd       |NULLOK DIR* dir
 #ifdef PERL_ANY_COW
@@ -3155,6 +3293,9 @@ pd        |void   |do_dump_pad    |I32 level|NN PerlIO *file|NULLOK PADLIST *padlist|int ful
 Sd     |void   |cv_dump        |NN const CV *cv|NN const char *title
 #  endif
 #endif
+#if defined(PERL_IN_PAD_C) || defined(PERL_IN_OP_C)
+iT     |bool   |PadnameIN_SCOPE|NN const PADNAME * const pn|const U32 seq
+#endif
 Apd    |CV*    |cv_clone       |NN CV* proto
 p      |CV*    |cv_clone_into  |NN CV* proto|NN CV *target
 pd     |void   |pad_fixup_inner_anons|NN PADLIST *padlist|NN CV *old_cv|NN CV *new_cv
@@ -3245,8 +3386,8 @@ ApoP      |bool   |ckwarn_d       |U32 w
 XEopxR |STRLEN *|new_warnings_bitfield|NULLOK STRLEN *buffer \
                                |NN const char *const bits|STRLEN size
 
-AMpTodf        |int    |my_snprintf    |NN char *buffer|const Size_t len|NN const char *format|...
-AMpTod |int    |my_vsnprintf   |NN char *buffer|const Size_t len|NN const char *format|va_list ap
+AMpTdf |int    |my_snprintf    |NN char *buffer|const Size_t len|NN const char *format|...
+AMpT |int    |my_vsnprintf   |NN char *buffer|const Size_t len|NN const char *format|va_list ap
 #ifdef USE_QUADMATH
 ApTd   |const char*    |quadmath_format_single|NN const char* format
 ApTd   |bool|quadmath_format_needed|NN const char* format
@@ -3376,28 +3517,28 @@ Apx     |void   |leave_adjust_stacks|NN SV **from_sp|NN SV **to_sp \
                 |U8 gimme|int filter
 
 #ifndef PERL_NO_INLINE_FUNCTIONS
-Aix    |PERL_CONTEXT * |cx_pushblock|U8 type|U8 gimme|NN SV** sp|I32 saveix
-Aix    |void   |cx_popblock|NN PERL_CONTEXT *cx
-Aix    |void   |cx_topblock|NN PERL_CONTEXT *cx
-Aix    |void   |cx_pushsub      |NN PERL_CONTEXT *cx|NN CV *cv \
+Aixp   |PERL_CONTEXT * |cx_pushblock|U8 type|U8 gimme|NN SV** sp|I32 saveix
+Aixp   |void   |cx_popblock|NN PERL_CONTEXT *cx
+Aixp   |void   |cx_topblock|NN PERL_CONTEXT *cx
+Aixp   |void   |cx_pushsub      |NN PERL_CONTEXT *cx|NN CV *cv \
                                 |NULLOK OP *retop|bool hasargs
-Aix    |void   |cx_popsub_common|NN PERL_CONTEXT *cx
-Aix    |void   |cx_popsub_args  |NN PERL_CONTEXT *cx
-Aix    |void   |cx_popsub       |NN PERL_CONTEXT *cx
-Aix    |void   |cx_pushformat   |NN PERL_CONTEXT *cx|NN CV *cv \
+Aixp   |void   |cx_popsub_common|NN PERL_CONTEXT *cx
+Aixp   |void   |cx_popsub_args  |NN PERL_CONTEXT *cx
+Aixp   |void   |cx_popsub       |NN PERL_CONTEXT *cx
+Aixp   |void   |cx_pushformat   |NN PERL_CONTEXT *cx|NN CV *cv \
                                 |NULLOK OP *retop|NULLOK GV *gv
-Aix    |void   |cx_popformat    |NN PERL_CONTEXT *cx
-Aix    |void   |cx_pusheval     |NN PERL_CONTEXT *cx \
+Aixp   |void   |cx_popformat    |NN PERL_CONTEXT *cx
+Aixp   |void   |cx_pusheval     |NN PERL_CONTEXT *cx \
                                 |NULLOK OP *retop|NULLOK SV *namesv
-Aix    |void   |cx_popeval      |NN PERL_CONTEXT *cx
-Aix    |void   |cx_pushloop_plain|NN PERL_CONTEXT *cx
-Aix    |void   |cx_pushloop_for |NN PERL_CONTEXT *cx \
+Aixp   |void   |cx_popeval      |NN PERL_CONTEXT *cx
+Aixp   |void   |cx_pushloop_plain|NN PERL_CONTEXT *cx
+Aixp   |void   |cx_pushloop_for |NN PERL_CONTEXT *cx \
                                 |NN void *itervarp|NULLOK SV *itersave
-Aix    |void   |cx_poploop      |NN PERL_CONTEXT *cx
-Aix    |void   |cx_pushwhen     |NN PERL_CONTEXT *cx
-Aix    |void   |cx_popwhen      |NN PERL_CONTEXT *cx
-Aix    |void   |cx_pushgiven    |NN PERL_CONTEXT *cx|NULLOK SV *orig_defsv
-Aix    |void   |cx_popgiven     |NN PERL_CONTEXT *cx
+Aixp   |void   |cx_poploop      |NN PERL_CONTEXT *cx
+Aixp   |void   |cx_pushwhen     |NN PERL_CONTEXT *cx
+Aixp   |void   |cx_popwhen      |NN PERL_CONTEXT *cx
+Aixp   |void   |cx_pushgiven    |NN PERL_CONTEXT *cx|NULLOK SV *orig_defsv
+Aixp   |void   |cx_popgiven     |NN PERL_CONTEXT *cx
 #endif
 
 #ifdef USE_DTRACE
diff --git a/embed.h b/embed.h
index 1c154c2..f1c3f57 100644 (file)
--- a/embed.h
+++ b/embed.h
 /* Hide global symbols */
 
 #define Gv_AMupdate(a,b)       Perl_Gv_AMupdate(aTHX_ a,b)
+#define SvAMAGIC_off           Perl_SvAMAGIC_off
+#define SvAMAGIC_on            Perl_SvAMAGIC_on
 #define _force_out_malformed_utf8_message(a,b,c,d)     Perl__force_out_malformed_utf8_message(aTHX_ a,b,c,d)
 #define _is_uni_FOO(a,b)       Perl__is_uni_FOO(aTHX_ a,b)
 #define _is_uni_perl_idcont(a) Perl__is_uni_perl_idcont(aTHX_ a)
 #define _is_uni_perl_idstart(a)        Perl__is_uni_perl_idstart(aTHX_ a)
 #define _is_utf8_FOO(a,b,c,d,e,f,g,h)  Perl__is_utf8_FOO(aTHX_ a,b,c,d,e,f,g,h)
 #define _is_utf8_FOO_with_len(a,b,c)   Perl__is_utf8_FOO_with_len(aTHX_ a,b,c)
-#define _is_utf8_char_helper   Perl__is_utf8_char_helper
 #define _is_utf8_idcont(a)     Perl__is_utf8_idcont(aTHX_ a)
 #define _is_utf8_idstart(a)    Perl__is_utf8_idstart(aTHX_ a)
 #define _is_utf8_mark(a)       Perl__is_utf8_mark(aTHX_ a)
@@ -46,7 +47,6 @@
 #define _to_utf8_lower_flags(a,b,c,d,e,f,g)    Perl__to_utf8_lower_flags(aTHX_ a,b,c,d,e,f,g)
 #define _to_utf8_title_flags(a,b,c,d,e,f,g)    Perl__to_utf8_title_flags(aTHX_ a,b,c,d,e,f,g)
 #define _to_utf8_upper_flags(a,b,c,d,e,f,g)    Perl__to_utf8_upper_flags(aTHX_ a,b,c,d,e,f,g)
-#define _utf8_to_uvchr_buf(a,b,c)      S__utf8_to_uvchr_buf(aTHX_ a,b,c)
 #define _utf8n_to_uvchr_msgs_helper    Perl__utf8n_to_uvchr_msgs_helper
 #define amagic_call(a,b,c,d)   Perl_amagic_call(aTHX_ a,b,c,d)
 #define amagic_deref_call(a,b) Perl_amagic_deref_call(aTHX_ a,b)
@@ -65,7 +65,7 @@
 #define av_push(a,b)           Perl_av_push(aTHX_ a,b)
 #define av_shift(a)            Perl_av_shift(aTHX_ a)
 #define av_store(a,b,c)                Perl_av_store(aTHX_ a,b,c)
-#define av_top_index(a)                S_av_top_index(aTHX_ a)
+#define av_top_index(a)                Perl_av_top_index(aTHX_ a)
 #define av_undef(a)            Perl_av_undef(aTHX_ a)
 #define av_unshift(a,b)                Perl_av_unshift(aTHX_ a,b)
 #define block_end(a,b)         Perl_block_end(aTHX_ a,b)
@@ -98,7 +98,7 @@
 #ifndef PERL_IMPLICIT_CONTEXT
 #define croak                  Perl_croak
 #endif
-#define croak_memory_wrap      S_croak_memory_wrap
+#define croak_memory_wrap      Perl_croak_memory_wrap
 #define croak_no_modify                Perl_croak_no_modify
 #define croak_sv(a)            Perl_croak_sv(aTHX_ a)
 #define croak_xs_usage         Perl_croak_xs_usage
 #ifndef NO_MATHOMS
 #define isALNUM_lazy(a)                Perl_isALNUM_lazy(aTHX_ a)
 #endif
-#define isC9_STRICT_UTF8_CHAR  S_isC9_STRICT_UTF8_CHAR
+#define isC9_STRICT_UTF8_CHAR  Perl_isC9_STRICT_UTF8_CHAR
 #ifndef NO_MATHOMS
 #define isIDFIRST_lazy(a)      Perl_isIDFIRST_lazy(aTHX_ a)
 #endif
-#define isSTRICT_UTF8_CHAR     S_isSTRICT_UTF8_CHAR
-#define isUTF8_CHAR            S_isUTF8_CHAR
-#define is_c9strict_utf8_string_loclen S_is_c9strict_utf8_string_loclen
+#define isSTRICT_UTF8_CHAR     Perl_isSTRICT_UTF8_CHAR
+#define isUTF8_CHAR            Perl_isUTF8_CHAR
+#define is_c9strict_utf8_string_loclen Perl_is_c9strict_utf8_string_loclen
 #define is_lvalue_sub()                Perl_is_lvalue_sub(aTHX)
-#define is_safe_syscall(a,b,c,d)       S_is_safe_syscall(aTHX_ a,b,c,d)
-#define is_strict_utf8_string_loclen   S_is_strict_utf8_string_loclen
+#define is_safe_syscall(a,b,c,d)       Perl_is_safe_syscall(aTHX_ a,b,c,d)
+#define is_strict_utf8_string_loclen   Perl_is_strict_utf8_string_loclen
 #ifndef NO_MATHOMS
 #define is_uni_alnum(a)                Perl_is_uni_alnum(aTHX_ a)
 #endif
 #ifndef NO_MATHOMS
 #define is_utf8_char           Perl_is_utf8_char
 #endif
+#define is_utf8_char_helper    Perl_is_utf8_char_helper
 #ifndef NO_MATHOMS
 #define is_utf8_cntrl(a)       Perl_is_utf8_cntrl(aTHX_ a)
 #endif
 #ifndef NO_MATHOMS
 #define is_utf8_digit(a)       Perl_is_utf8_digit(aTHX_ a)
 #endif
-#define is_utf8_fixed_width_buf_loclen_flags   S_is_utf8_fixed_width_buf_loclen_flags
+#define is_utf8_fixed_width_buf_loclen_flags   Perl_is_utf8_fixed_width_buf_loclen_flags
 #ifndef NO_MATHOMS
 #define is_utf8_graph(a)       Perl_is_utf8_graph(aTHX_ a)
 #endif
 #ifndef NO_MATHOMS
 #define is_utf8_idfirst(a)     Perl_is_utf8_idfirst(aTHX_ a)
 #endif
-#define is_utf8_invariant_string_loc   S_is_utf8_invariant_string_loc
+#define is_utf8_invariant_string_loc   Perl_is_utf8_invariant_string_loc
 #ifndef NO_MATHOMS
 #define is_utf8_lower(a)       Perl_is_utf8_lower(aTHX_ a)
 #endif
 #ifndef NO_MATHOMS
 #define is_utf8_space(a)       Perl_is_utf8_space(aTHX_ a)
 #endif
-#define is_utf8_string_flags   S_is_utf8_string_flags
+#define is_utf8_string_flags   Perl_is_utf8_string_flags
 #define is_utf8_string_loclen  Perl_is_utf8_string_loclen
-#define is_utf8_string_loclen_flags    S_is_utf8_string_loclen_flags
+#define is_utf8_string_loclen_flags    Perl_is_utf8_string_loclen_flags
 #ifndef NO_MATHOMS
 #define is_utf8_upper(a)       Perl_is_utf8_upper(aTHX_ a)
 #endif
-#define is_utf8_valid_partial_char_flags       S_is_utf8_valid_partial_char_flags
+#define is_utf8_valid_partial_char_flags       Perl_is_utf8_valid_partial_char_flags
 #ifndef NO_MATHOMS
 #define is_utf8_xdigit(a)      Perl_is_utf8_xdigit(aTHX_ a)
 #endif
 #define utf8_length(a,b)       Perl_utf8_length(aTHX_ a,b)
 #define utf8_to_bytes(a,b)     Perl_utf8_to_bytes(aTHX_ a,b)
 #define utf8_to_uvchr(a,b)     Perl_utf8_to_uvchr(aTHX_ a,b)
+#define utf8_to_uvchr_buf_helper(a,b,c)        Perl_utf8_to_uvchr_buf_helper(aTHX_ a,b,c)
 #ifndef NO_MATHOMS
 #define utf8_to_uvuni(a,b)     Perl_utf8_to_uvuni(aTHX_ a,b)
 #endif
 #define utf8_to_uvuni_buf(a,b,c)       Perl_utf8_to_uvuni_buf(aTHX_ a,b,c)
-#define utf8n_to_uvchr_msgs    S_utf8n_to_uvchr_msgs
+#define utf8n_to_uvchr_msgs    Perl_utf8n_to_uvchr_msgs
 #define utf8n_to_uvuni(a,b,c,d)        Perl_utf8n_to_uvuni(aTHX_ a,b,c,d)
 #define uvoffuni_to_utf8_flags_msgs(a,b,c,d)   Perl_uvoffuni_to_utf8_flags_msgs(aTHX_ a,b,c,d)
 #define uvuni_to_utf8(a,b)     Perl_uvuni_to_utf8(aTHX_ a,b)
 #define csighandler            Perl_csighandler
 #endif
 #if !defined(EBCDIC)
-#define _variant_byte_number   S__variant_byte_number
+#define variant_byte_number    Perl_variant_byte_number
 #endif
 #if !defined(HAS_STRLCAT)
 #define my_strlcat             Perl_my_strlcat
 #define my_popen(a,b)          Perl_my_popen(aTHX_ a,b)
 #endif
 #if !defined(PERL_NO_INLINE_FUNCTIONS)
-#define cx_popblock(a)         S_cx_popblock(aTHX_ a)
-#define cx_popeval(a)          S_cx_popeval(aTHX_ a)
-#define cx_popformat(a)                S_cx_popformat(aTHX_ a)
-#define cx_popgiven(a)         S_cx_popgiven(aTHX_ a)
-#define cx_poploop(a)          S_cx_poploop(aTHX_ a)
-#define cx_popsub(a)           S_cx_popsub(aTHX_ a)
-#define cx_popsub_args(a)      S_cx_popsub_args(aTHX_ a)
-#define cx_popsub_common(a)    S_cx_popsub_common(aTHX_ a)
-#define cx_popwhen(a)          S_cx_popwhen(aTHX_ a)
-#define cx_pushblock(a,b,c,d)  S_cx_pushblock(aTHX_ a,b,c,d)
-#define cx_pusheval(a,b,c)     S_cx_pusheval(aTHX_ a,b,c)
-#define cx_pushformat(a,b,c,d) S_cx_pushformat(aTHX_ a,b,c,d)
-#define cx_pushgiven(a,b)      S_cx_pushgiven(aTHX_ a,b)
-#define cx_pushloop_for(a,b,c) S_cx_pushloop_for(aTHX_ a,b,c)
-#define cx_pushloop_plain(a)   S_cx_pushloop_plain(aTHX_ a)
-#define cx_pushsub(a,b,c,d)    S_cx_pushsub(aTHX_ a,b,c,d)
-#define cx_pushwhen(a)         S_cx_pushwhen(aTHX_ a)
-#define cx_topblock(a)         S_cx_topblock(aTHX_ a)
+#define cx_popblock(a)         Perl_cx_popblock(aTHX_ a)
+#define cx_popeval(a)          Perl_cx_popeval(aTHX_ a)
+#define cx_popformat(a)                Perl_cx_popformat(aTHX_ a)
+#define cx_popgiven(a)         Perl_cx_popgiven(aTHX_ a)
+#define cx_poploop(a)          Perl_cx_poploop(aTHX_ a)
+#define cx_popsub(a)           Perl_cx_popsub(aTHX_ a)
+#define cx_popsub_args(a)      Perl_cx_popsub_args(aTHX_ a)
+#define cx_popsub_common(a)    Perl_cx_popsub_common(aTHX_ a)
+#define cx_popwhen(a)          Perl_cx_popwhen(aTHX_ a)
+#define cx_pushblock(a,b,c,d)  Perl_cx_pushblock(aTHX_ a,b,c,d)
+#define cx_pusheval(a,b,c)     Perl_cx_pusheval(aTHX_ a,b,c)
+#define cx_pushformat(a,b,c,d) Perl_cx_pushformat(aTHX_ a,b,c,d)
+#define cx_pushgiven(a,b)      Perl_cx_pushgiven(aTHX_ a,b)
+#define cx_pushloop_for(a,b,c) Perl_cx_pushloop_for(aTHX_ a,b,c)
+#define cx_pushloop_plain(a)   Perl_cx_pushloop_plain(aTHX_ a)
+#define cx_pushsub(a,b,c,d)    Perl_cx_pushsub(aTHX_ a,b,c,d)
+#define cx_pushwhen(a)         Perl_cx_pushwhen(aTHX_ a)
+#define cx_topblock(a)         Perl_cx_topblock(aTHX_ a)
 #endif
 #if defined(DEBUGGING)
 #define pad_setsv(a,b)         Perl_pad_setsv(aTHX_ a,b)
 #if defined(PERL_CORE) || defined(PERL_EXT)
 #define _byte_dump_string(a,b,c)       Perl__byte_dump_string(aTHX_ a,b,c)
 #define _inverse_folds(a,b,c)  Perl__inverse_folds(aTHX_ a,b,c)
-#define append_utf8_from_native_byte   S_append_utf8_from_native_byte
+#define append_utf8_from_native_byte   Perl_append_utf8_from_native_byte
 #define av_reify(a)            Perl_av_reify(aTHX_ a)
 #define current_re_engine()    Perl_current_re_engine(aTHX)
 #define cv_ckproto_len_flags(a,b,c,d,e)        Perl_cv_ckproto_len_flags(aTHX_ a,b,c,d,e)
 #define scan_word(a,b,c,d,e)   Perl_scan_word(aTHX_ a,b,c,d,e)
 #define skipspace_flags(a,b)   Perl_skipspace_flags(aTHX_ a,b)
 #define sv_magicext_mglob(a)   Perl_sv_magicext_mglob(aTHX_ a)
-#define sv_only_taint_gmagic   S_sv_only_taint_gmagic
+#define sv_only_taint_gmagic   Perl_sv_only_taint_gmagic
 #define swash_fetch(a,b,c)     Perl_swash_fetch(aTHX_ a,b,c)
 #define swash_init(a,b,c,d,e)  Perl_swash_init(aTHX_ a,b,c,d,e)
 #define utf16_to_utf8(a,b,c,d) Perl_utf16_to_utf8(aTHX_ a,b,c,d)
 #define sv_setsv_cow(a,b)      Perl_sv_setsv_cow(aTHX_ a,b)
 #  endif
 #  if defined(PERL_CORE) || defined (PERL_EXT)
-#define is_utf8_non_invariant_string   S_is_utf8_non_invariant_string
+#define is_utf8_non_invariant_string   Perl_is_utf8_non_invariant_string
 #define sv_or_pv_pos_u2b(a,b,c,d)      S_sv_or_pv_pos_u2b(aTHX_ a,b,c,d)
 #  endif
 #  if defined(PERL_CORE) || defined(PERL_EXT)
 #define isSCRIPT_RUN(a,b,c)    Perl_isSCRIPT_RUN(aTHX_ a,b,c)
 #define variant_under_utf8_count       S_variant_under_utf8_count
 #  endif
+#  if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C)
+#define get_regex_charset_name S_get_regex_charset_name
+#  endif
 #  if defined(PERL_IN_REGCOMP_C)
 #define _make_exactf_invlist(a,b)      S__make_exactf_invlist(aTHX_ a,b)
 #define add_above_Latin1_folds(a,b,c)  S_add_above_Latin1_folds(aTHX_ a,b,c)
 #define pad_findlex(a,b,c,d,e,f,g,h,i) S_pad_findlex(aTHX_ a,b,c,d,e,f,g,h,i)
 #define pad_reset()            S_pad_reset(aTHX)
 #  endif
+#  if defined(PERL_IN_PAD_C) || defined(PERL_IN_OP_C)
+#define PadnameIN_SCOPE                S_PadnameIN_SCOPE
+#  endif
 #  if defined(PERL_IN_PERL_C)
 #define find_beginning(a,b)    S_find_beginning(aTHX_ a,b)
 #define forbid_setid(a,b)      S_forbid_setid(aTHX_ a,b)
index cf813ab..aa4e7b8 100644 (file)
--- a/inline.h
+++ b/inline.h
@@ -40,7 +40,7 @@ SOFTWARE.
 /* ------------------------------- av.h ------------------------------- */
 
 PERL_STATIC_INLINE SSize_t
-S_av_top_index(pTHX_ AV *av)
+Perl_av_top_index(pTHX_ AV *av)
 {
     PERL_ARGS_ASSERT_AV_TOP_INDEX;
     assert(SvTYPE(av) == SVt_PVAV);
@@ -51,17 +51,21 @@ S_av_top_index(pTHX_ AV *av)
 /* ------------------------------- cv.h ------------------------------- */
 
 PERL_STATIC_INLINE GV *
-S_CvGV(pTHX_ CV *sv)
+Perl_CvGV(pTHX_ CV *sv)
 {
+    PERL_ARGS_ASSERT_CVGV;
+
     return CvNAMED(sv)
        ? Perl_cvgv_from_hek(aTHX_ sv)
        : ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_gv_u.xcv_gv;
 }
 
 PERL_STATIC_INLINE I32 *
-S_CvDEPTHp(const CV * const sv)
+Perl_CvDEPTH(const CV * const sv)
 {
+    PERL_ARGS_ASSERT_CVDEPTH;
     assert(SvTYPE(sv) == SVt_PVCV || SvTYPE(sv) == SVt_PVFM);
+
     return &((XPVCV*)SvANY(sv))->xcv_depth;
 }
 
@@ -119,8 +123,10 @@ S_MgBYTEPOS(pTHX_ MAGIC *mg, SV *sv, const char *s, STRLEN len)
 
 #if defined(PERL_IN_PAD_C) || defined(PERL_IN_OP_C)
 PERL_STATIC_INLINE bool
-PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq)
+S_PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq)
 {
+    PERL_ARGS_ASSERT_PADNAMEIN_SCOPE;
+
     /* is seq within the range _LOW to _HIGH ?
      * This is complicated by the fact that PL_cop_seqmax
      * may have wrapped around at some point */
@@ -153,7 +159,7 @@ PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq)
 /* ------------------------------- pp.h ------------------------------- */
 
 PERL_STATIC_INLINE I32
-S_TOPMARK(pTHX)
+Perl_TOPMARK(pTHX)
 {
     DEBUG_s(DEBUG_v(PerlIO_printf(Perl_debug_log,
                                 "MARK top  %p %" IVdf "\n",
@@ -163,7 +169,7 @@ S_TOPMARK(pTHX)
 }
 
 PERL_STATIC_INLINE I32
-S_POPMARK(pTHX)
+Perl_POPMARK(pTHX)
 {
     DEBUG_s(DEBUG_v(PerlIO_printf(Perl_debug_log,
                                 "MARK pop  %p %" IVdf "\n",
@@ -176,10 +182,13 @@ S_POPMARK(pTHX)
 /* ----------------------------- regexp.h ----------------------------- */
 
 PERL_STATIC_INLINE struct regexp *
-S_ReANY(const REGEXP * const re)
+Perl_ReANY(const REGEXP * const re)
 {
     XPV* const p = (XPV*)SvANY(re);
+
+    PERL_ARGS_ASSERT_REANY;
     assert(isREGEXP(re));
+
     return SvTYPE(re) == SVt_PVLV ? p->xpv_len_u.xpvlenu_rx
                                    : (struct regexp *)p;
 }
@@ -187,26 +196,28 @@ S_ReANY(const REGEXP * const re)
 /* ------------------------------- sv.h ------------------------------- */
 
 PERL_STATIC_INLINE SV *
-S_SvREFCNT_inc(SV *sv)
+Perl_SvREFCNT_inc(SV *sv)
 {
     if (LIKELY(sv != NULL))
        SvREFCNT(sv)++;
     return sv;
 }
 PERL_STATIC_INLINE SV *
-S_SvREFCNT_inc_NN(SV *sv)
+Perl_SvREFCNT_inc_NN(SV *sv)
 {
+    PERL_ARGS_ASSERT_SVREFCNT_INC_NN;
+
     SvREFCNT(sv)++;
     return sv;
 }
 PERL_STATIC_INLINE void
-S_SvREFCNT_inc_void(SV *sv)
+Perl_SvREFCNT_inc_void(SV *sv)
 {
     if (LIKELY(sv != NULL))
        SvREFCNT(sv)++;
 }
 PERL_STATIC_INLINE void
-S_SvREFCNT_dec(pTHX_ SV *sv)
+Perl_SvREFCNT_dec(pTHX_ SV *sv)
 {
     if (LIKELY(sv != NULL)) {
        U32 rc = SvREFCNT(sv);
@@ -218,9 +229,12 @@ S_SvREFCNT_dec(pTHX_ SV *sv)
 }
 
 PERL_STATIC_INLINE void
-S_SvREFCNT_dec_NN(pTHX_ SV *sv)
+Perl_SvREFCNT_dec_NN(pTHX_ SV *sv)
 {
     U32 rc = SvREFCNT(sv);
+
+    PERL_ARGS_ASSERT_SVREFCNT_DEC_NN;
+
     if (LIKELY(rc > 1))
        SvREFCNT(sv) = rc - 1;
     else
@@ -228,26 +242,30 @@ S_SvREFCNT_dec_NN(pTHX_ SV *sv)
 }
 
 PERL_STATIC_INLINE void
-SvAMAGIC_on(SV *sv)
+Perl_SvAMAGIC_on(SV *sv)
 {
+    PERL_ARGS_ASSERT_SVAMAGIC_ON;
     assert(SvROK(sv));
+
     if (SvOBJECT(SvRV(sv))) HvAMAGIC_on(SvSTASH(SvRV(sv)));
 }
 PERL_STATIC_INLINE void
-SvAMAGIC_off(SV *sv)
+Perl_SvAMAGIC_off(SV *sv)
 {
+    PERL_ARGS_ASSERT_SVAMAGIC_OFF;
+
     if (SvROK(sv) && SvOBJECT(SvRV(sv)))
        HvAMAGIC_off(SvSTASH(SvRV(sv)));
 }
 
 PERL_STATIC_INLINE U32
-S_SvPADSTALE_on(SV *sv)
+Perl_SvPADSTALE_on(SV *sv)
 {
     assert(!(SvFLAGS(sv) & SVs_PADTMP));
     return SvFLAGS(sv) |= SVs_PADSTALE;
 }
 PERL_STATIC_INLINE U32
-S_SvPADSTALE_off(SV *sv)
+Perl_SvPADSTALE_off(SV *sv)
 {
     assert(!(SvFLAGS(sv) & SVs_PADTMP));
     return SvFLAGS(sv) &= ~SVs_PADSTALE;
@@ -271,7 +289,7 @@ S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp)
 /* saves machine code for a common noreturn idiom typically used in Newx*() */
 GCC_DIAG_IGNORE_DECL(-Wunused-function);
 static void
-S_croak_memory_wrap(void)
+Perl_croak_memory_wrap(void)
 {
     Perl_croak_nocontext("%s",PL_memory_wrap);
 }
@@ -284,7 +302,7 @@ GCC_DIAG_RESTORE_DECL;
 */
 
 PERL_STATIC_INLINE void
-S_append_utf8_from_native_byte(const U8 byte, U8** dest)
+Perl_append_utf8_from_native_byte(const U8 byte, U8** dest)
 {
     /* Takes an input 'byte' (Latin1 or EBCDIC) and appends it to the UTF-8
      * encoded string at '*dest', updating '*dest' to include it */
@@ -301,10 +319,10 @@ S_append_utf8_from_native_byte(const U8 byte, U8** dest)
 
 /*
 =for apidoc valid_utf8_to_uvchr
-Like C<L</utf8_to_uvchr_buf>>, but should only be called when it is known that
-the next character in the input UTF-8 string C<s> is well-formed (I<e.g.>,
-it passes C<L</isUTF8_CHAR>>.  Surrogates, non-character code points, and
-non-Unicode code points are allowed.
+Like C<L<perlapi/utf8_to_uvchr_buf>>, but should only be called when it is
+known that the next character in the input UTF-8 string C<s> is well-formed
+(I<e.g.>, it passes C<L<perlapi/isUTF8_CHAR>>.  Surrogates, non-character code
+points, and non-Unicode code points are allowed.
 
 =cut
 
@@ -394,7 +412,7 @@ UTF-8 invariant, this function does not change the contents of C<*ep>.
 */
 
 PERL_STATIC_INLINE bool
-S_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep)
+Perl_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep)
 {
     const U8* send;
     const U8* x = s;
@@ -466,7 +484,7 @@ S_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep)
 #  if   BYTEORDER == 0x1234 || BYTEORDER == 0x12345678    \
      || BYTEORDER == 0x4321 || BYTEORDER == 0x87654321
 
-                *ep = x + _variant_byte_number(* (PERL_UINTMAX_T *) x);
+                *ep = x + variant_byte_number(* (PERL_UINTMAX_T *) x);
                 assert(*ep >= s && *ep < send);
 
                 return FALSE;
@@ -504,7 +522,7 @@ S_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep)
 #ifndef EBCDIC
 
 PERL_STATIC_INLINE unsigned int
-S__variant_byte_number(PERL_UINTMAX_T word)
+Perl_variant_byte_number(PERL_UINTMAX_T word)
 {
 
     /* This returns the position in a word (0..7) of the first variant byte in
@@ -757,7 +775,7 @@ at this low a level.  A valid use case could change that.
 */
 
 PERL_STATIC_INLINE bool
-S_is_utf8_non_invariant_string(const U8* const s, STRLEN len)
+Perl_is_utf8_non_invariant_string(const U8* const s, STRLEN len)
 {
     const U8 * first_variant;
 
@@ -891,7 +909,7 @@ C<L</is_c9strict_utf8_string_loclen>>.
 */
 
 PERL_STATIC_INLINE bool
-S_is_utf8_string_flags(const U8 *s, STRLEN len, const U32 flags)
+Perl_is_utf8_string_flags(const U8 *s, STRLEN len, const U32 flags)
 {
     const U8 * first_variant;
 
@@ -1050,7 +1068,7 @@ documented at the definition of PL_extended_utf8_dfa_tab[].
 */
 
 PERL_STATIC_INLINE Size_t
-S_isUTF8_CHAR(const U8 * const s0, const U8 * const e)
+Perl_isUTF8_CHAR(const U8 * const s0, const U8 * const e)
 {
     const U8 * s = s0;
     UV state = 0;
@@ -1078,7 +1096,7 @@ S_isUTF8_CHAR(const U8 * const s0, const U8 * const e)
 #if defined(UV_IS_QUAD) || defined(EBCDIC)
 
     if (NATIVE_UTF8_TO_I8(*s0) == 0xFF && e - s0 >= UTF8_MAXBYTES) {
-       return _is_utf8_char_helper(s0, e, 0);
+       return is_utf8_char_helper(s0, e, 0);
     }
 
 #endif
@@ -1124,7 +1142,7 @@ documented at the definition of strict_extended_utf8_dfa_tab[].
 */
 
 PERL_STATIC_INLINE Size_t
-S_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e)
+Perl_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e)
 {
     const U8 * s = s0;
     UV state = 0;
@@ -1190,7 +1208,7 @@ documented at the definition of PL_c9_utf8_dfa_tab[].
 */
 
 PERL_STATIC_INLINE Size_t
-S_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e)
+Perl_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e)
 {
     const U8 * s = s0;
     UV state = 0;
@@ -1242,7 +1260,7 @@ See also C<L</is_strict_utf8_string_loc>>.
 */
 
 PERL_STATIC_INLINE bool
-S_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el)
+Perl_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el)
 {
     const U8 * first_variant;
 
@@ -1319,7 +1337,7 @@ See also C<L</is_c9strict_utf8_string_loc>>.
 */
 
 PERL_STATIC_INLINE bool
-S_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el)
+Perl_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el)
 {
     const U8 * first_variant;
 
@@ -1401,7 +1419,7 @@ See also C<L</is_utf8_string_loc_flags>>.
 */
 
 PERL_STATIC_INLINE bool
-S_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags)
+Perl_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags)
 {
     const U8 * first_variant;
 
@@ -1691,7 +1709,7 @@ determined from just the first one or two bytes.
  */
 
 PERL_STATIC_INLINE bool
-S_is_utf8_valid_partial_char_flags(const U8 * const s, const U8 * const e, const U32 flags)
+Perl_is_utf8_valid_partial_char_flags(const U8 * const s, const U8 * const e, const U32 flags)
 {
     PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR_FLAGS;
 
@@ -1702,7 +1720,7 @@ S_is_utf8_valid_partial_char_flags(const U8 * const s, const U8 * const e, const
         return FALSE;
     }
 
-    return cBOOL(_is_utf8_char_helper(s, e, flags));
+    return cBOOL(is_utf8_char_helper(s, e, flags));
 }
 
 /*
@@ -1759,7 +1777,7 @@ complete, valid characters found in the C<el> pointer.
 */
 
 PERL_STATIC_INLINE bool
-S_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s,
+Perl_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s,
                                        STRLEN len,
                                        const U8 **ep,
                                        STRLEN *el,
@@ -1780,7 +1798,7 @@ S_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s,
 }
 
 PERL_STATIC_INLINE UV
-S_utf8n_to_uvchr_msgs(const U8 *s,
+Perl_utf8n_to_uvchr_msgs(const U8 *s,
                       STRLEN curlen,
                       STRLEN *retlen,
                       const U32 flags,
@@ -1843,9 +1861,9 @@ S_utf8n_to_uvchr_msgs(const U8 *s,
 }
 
 PERL_STATIC_INLINE UV
-S__utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen)
+Perl_utf8_to_uvchr_buf_helper(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen)
 {
-    PERL_ARGS_ASSERT__UTF8_TO_UVCHR_BUF;
+    PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF_HELPER;
 
     assert(s < send);
 
@@ -1874,18 +1892,23 @@ S__utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen)
 
 =for apidoc is_safe_syscall
 
-Test that the given C<pv> doesn't contain any internal C<NUL> characters.
-If it does, set C<errno> to C<ENOENT>, optionally warn, and return FALSE.
+Test that the given C<pv> (with length C<len>) doesn't contain any internal
+C<NUL> characters.
+If it does, set C<errno> to C<ENOENT>, optionally warn using the C<syscalls>
+category, and return FALSE.
 
 Return TRUE if the name is safe.
 
+C<what> and C<op_name> are used in any warning.
+
 Used by the C<IS_SAFE_SYSCALL()> macro.
 
 =cut
 */
 
 PERL_STATIC_INLINE bool
-S_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) {
+Perl_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name)
+{
     /* While the Windows CE API provides only UCS-16 (or UTF-16) APIs
      * perl itself uses xce*() functions which accept 8-bit strings.
      */
@@ -1926,7 +1949,8 @@ then calling:
 #ifdef PERL_CORE
 
 PERL_STATIC_INLINE bool
-S_should_warn_nl(const char *pv) {
+S_should_warn_nl(const char *pv)
+{
     STRLEN len;
 
     PERL_ARGS_ASSERT_SHOULD_WARN_NL;
@@ -1974,11 +1998,15 @@ S_lossless_NV_to_IV(const NV nv, IV *ivp)
 
 /* ------------------ pp.c, regcomp.c, toke.c, universal.c ------------ */
 
+#if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C)
+
 #define MAX_CHARSET_NAME_LENGTH 2
 
 PERL_STATIC_INLINE const char *
-get_regex_charset_name(const U32 flags, STRLEN* const lenp)
+S_get_regex_charset_name(const U32 flags, STRLEN* const lenp)
 {
+    PERL_ARGS_ASSERT_GET_REGEX_CHARSET_NAME;
+
     /* Returns a string that corresponds to the name of the regex character set
      * given by 'flags', and *lenp is set the length of that string, which
      * cannot exceed MAX_CHARSET_NAME_LENGTH characters */
@@ -1999,6 +2027,8 @@ get_regex_charset_name(const U32 flags, STRLEN* const lenp)
     return "?";            /* Unknown */
 }
 
+#endif
+
 /*
 
 Return false if any get magic is on the SV other than taint magic.
@@ -2006,7 +2036,8 @@ Return false if any get magic is on the SV other than taint magic.
 */
 
 PERL_STATIC_INLINE bool
-S_sv_only_taint_gmagic(SV *sv) {
+Perl_sv_only_taint_gmagic(SV *sv)
+{
     MAGIC *mg = SvMAGIC(sv);
 
     PERL_ARGS_ASSERT_SV_ONLY_TAINT_GMAGIC;
@@ -2029,7 +2060,7 @@ S_sv_only_taint_gmagic(SV *sv) {
 /* Enter a block. Push a new base context and return its address. */
 
 PERL_STATIC_INLINE PERL_CONTEXT *
-S_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix)
+Perl_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix)
 {
     PERL_CONTEXT * cx;
 
@@ -2056,7 +2087,7 @@ S_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix)
 /* Exit a block (RETURN and LAST). */
 
 PERL_STATIC_INLINE void
-S_cx_popblock(pTHX_ PERL_CONTEXT *cx)
+Perl_cx_popblock(pTHX_ PERL_CONTEXT *cx)
 {
     PERL_ARGS_ASSERT_CX_POPBLOCK;
 
@@ -2081,7 +2112,7 @@ S_cx_popblock(pTHX_ PERL_CONTEXT *cx)
  * *after* cx_pushblock() was called. */
 
 PERL_STATIC_INLINE void
-S_cx_topblock(pTHX_ PERL_CONTEXT *cx)
+Perl_cx_topblock(pTHX_ PERL_CONTEXT *cx)
 {
     PERL_ARGS_ASSERT_CX_TOPBLOCK;
 
@@ -2096,7 +2127,7 @@ S_cx_topblock(pTHX_ PERL_CONTEXT *cx)
 
 
 PERL_STATIC_INLINE void
-S_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs)
+Perl_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs)
 {
     U8 phlags = CX_PUSHSUB_GET_LVALUE_MASK(Perl_was_lvalue_sub);
 
@@ -2116,7 +2147,7 @@ S_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs)
 /* subsets of cx_popsub() */
 
 PERL_STATIC_INLINE void
-S_cx_popsub_common(pTHX_ PERL_CONTEXT *cx)
+Perl_cx_popsub_common(pTHX_ PERL_CONTEXT *cx)
 {
     CV *cv;
 
@@ -2135,7 +2166,7 @@ S_cx_popsub_common(pTHX_ PERL_CONTEXT *cx)
 /* handle the @_ part of leaving a sub */
 
 PERL_STATIC_INLINE void
-S_cx_popsub_args(pTHX_ PERL_CONTEXT *cx)
+Perl_cx_popsub_args(pTHX_ PERL_CONTEXT *cx)
 {
     AV *av;
 
@@ -2157,7 +2188,7 @@ S_cx_popsub_args(pTHX_ PERL_CONTEXT *cx)
 
 
 PERL_STATIC_INLINE void
-S_cx_popsub(pTHX_ PERL_CONTEXT *cx)
+Perl_cx_popsub(pTHX_ PERL_CONTEXT *cx)
 {
     PERL_ARGS_ASSERT_CX_POPSUB;
     assert(CxTYPE(cx) == CXt_SUB);
@@ -2171,7 +2202,7 @@ S_cx_popsub(pTHX_ PERL_CONTEXT *cx)
 
 
 PERL_STATIC_INLINE void
-S_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv)
+Perl_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv)
 {
     PERL_ARGS_ASSERT_CX_PUSHFORMAT;
 
@@ -2189,7 +2220,7 @@ S_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv)
 
 
 PERL_STATIC_INLINE void
-S_cx_popformat(pTHX_ PERL_CONTEXT *cx)
+Perl_cx_popformat(pTHX_ PERL_CONTEXT *cx)
 {
     CV *cv;
     GV *dfout;
@@ -2212,7 +2243,7 @@ S_cx_popformat(pTHX_ PERL_CONTEXT *cx)
 
 
 PERL_STATIC_INLINE void
-S_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv)
+Perl_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv)
 {
     PERL_ARGS_ASSERT_CX_PUSHEVAL;
 
@@ -2230,7 +2261,7 @@ S_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv)
 
 
 PERL_STATIC_INLINE void
-S_cx_popeval(pTHX_ PERL_CONTEXT *cx)
+Perl_cx_popeval(pTHX_ PERL_CONTEXT *cx)
 {
     SV *sv;
 
@@ -2262,7 +2293,7 @@ S_cx_popeval(pTHX_ PERL_CONTEXT *cx)
  */
 
 PERL_STATIC_INLINE void
-S_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx)
+Perl_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx)
 {
     PERL_ARGS_ASSERT_CX_PUSHLOOP_PLAIN;
     cx->blk_loop.my_op = cLOOP;
@@ -2274,7 +2305,7 @@ S_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx)
  */
 
 PERL_STATIC_INLINE void
-S_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV* itersave)
+Perl_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV* itersave)
 {
     PERL_ARGS_ASSERT_CX_PUSHLOOP_FOR;
 
@@ -2292,7 +2323,7 @@ S_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV* itersave)
 /* pop all loop types, including plain */
 
 PERL_STATIC_INLINE void
-S_cx_poploop(pTHX_ PERL_CONTEXT *cx)
+Perl_cx_poploop(pTHX_ PERL_CONTEXT *cx)
 {
     PERL_ARGS_ASSERT_CX_POPLOOP;
 
@@ -2325,7 +2356,7 @@ S_cx_poploop(pTHX_ PERL_CONTEXT *cx)
 
 
 PERL_STATIC_INLINE void
-S_cx_pushwhen(pTHX_ PERL_CONTEXT *cx)
+Perl_cx_pushwhen(pTHX_ PERL_CONTEXT *cx)
 {
     PERL_ARGS_ASSERT_CX_PUSHWHEN;
 
@@ -2334,7 +2365,7 @@ S_cx_pushwhen(pTHX_ PERL_CONTEXT *cx)
 
 
 PERL_STATIC_INLINE void
-S_cx_popwhen(pTHX_ PERL_CONTEXT *cx)
+Perl_cx_popwhen(pTHX_ PERL_CONTEXT *cx)
 {
     PERL_ARGS_ASSERT_CX_POPWHEN;
     assert(CxTYPE(cx) == CXt_WHEN);
@@ -2346,7 +2377,7 @@ S_cx_popwhen(pTHX_ PERL_CONTEXT *cx)
 
 
 PERL_STATIC_INLINE void
-S_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv)
+Perl_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv)
 {
     PERL_ARGS_ASSERT_CX_PUSHGIVEN;
 
@@ -2356,7 +2387,7 @@ S_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv)
 
 
 PERL_STATIC_INLINE void
-S_cx_popgiven(pTHX_ PERL_CONTEXT *cx)
+Perl_cx_popgiven(pTHX_ PERL_CONTEXT *cx)
 {
     SV *sv;
 
index 752edd8..7e93a0a 100644 (file)
--- a/mathoms.c
+++ b/mathoms.c
@@ -1676,7 +1676,7 @@ Perl_is_utf8_char(const U8 *s)
 /*
 =for apidoc is_utf8_char_buf
 
-This is identical to the macro L</isUTF8_CHAR>.
+This is identical to the macro L<perlapi/isUTF8_CHAR>.
 
 =cut */
 
@@ -1722,7 +1722,7 @@ NULL) to -1.  If those warnings are off, the computed value if well-defined (or
 the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen>
 is set (if C<retlen> isn't NULL) so that (S<C<s> + C<*retlen>>) is the
 next possible position in C<s> that could begin a non-malformed character.
-See L</utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is returned.
+See L<perlapi/utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is returned.
 
 =cut
 */
diff --git a/op.c b/op.c
index 8625104..944c57a 100644 (file)
--- a/op.c
+++ b/op.c
@@ -17036,7 +17036,7 @@ Perl_peep(pTHX_ OP *o)
 /*
 =head1 Custom Operators
 
-=for apidoc custom_op_xop
+=for apidoc Perl_custom_op_xop
 Return the XOP structure for a given custom op.  This macro should be
 considered internal to C<OP_NAME> and the other access macros: use them instead.
 This macro does call a function.  Prior
diff --git a/perl.h b/perl.h
index fb4eb77..b1ab81d 100644 (file)
--- a/perl.h
+++ b/perl.h
@@ -7205,9 +7205,19 @@ so no C<x++>.
 #  define do_aexec(really, mark,sp)    do_aexec5(really, mark, sp, 0, 0)
 #endif
 
-/* check embedded \0 characters in pathnames passed to syscalls,
-   but allow one ending \0 */
-#define IS_SAFE_SYSCALL(p, len, what, op_name) (S_is_safe_syscall(aTHX_ (p), (len), (what), (op_name)))
+
+/*
+=head1 Miscellaneous Functions
+
+=for apidoc Am|bool|IS_SAFE_SYSCALL|NN const char *pv|STRLEN len|NN const char *what|NN const char *op_name
+
+Same as L</is_safe_syscall>.
+
+=cut
+
+Allows one ending \0
+*/
+#define IS_SAFE_SYSCALL(p, len, what, op_name) (Perl_is_safe_syscall(aTHX_ (p), (len), (what), (op_name)))
 
 #define IS_SAFE_PATHNAME(p, len, op_name) IS_SAFE_SYSCALL((p), (len), "pathname", (op_name))
 
diff --git a/pp.h b/pp.h
index d4176db..17129d0 100644 (file)
--- a/pp.h
+++ b/pp.h
@@ -67,8 +67,8 @@ Refetch the stack pointer.  Used after a callback.  See L<perlcall>.
                 PL_markstack_ptr, (IV)*mark_stack_entry)));           \
     } STMT_END
 
-#define TOPMARK S_TOPMARK(aTHX)
-#define POPMARK S_POPMARK(aTHX)
+#define TOPMARK Perl_TOPMARK(aTHX)
+#define POPMARK Perl_POPMARK(aTHX)
 
 #define INCMARK \
     STMT_START {                                                      \
diff --git a/proto.h b/proto.h
index 9bd6046..fe9b9a0 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -22,8 +22,19 @@ PERL_CALLCONV UV     ASCII_TO_NEED(const UV enc, const UV ch)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_ASCII_TO_NEED
 #endif
 
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE I32 *       Perl_CvDEPTH(const CV * const sv);
+#define PERL_ARGS_ASSERT_CVDEPTH       \
+       assert(sv)
+#endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE GV *        Perl_CvGV(pTHX_ CV *sv);
+#define PERL_ARGS_ASSERT_CVGV  \
+       assert(sv)
+#endif
 PERL_CALLCONV int      Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing);
 #define PERL_ARGS_ASSERT_GV_AMUPDATE   \
        assert(stash)
@@ -32,12 +43,20 @@ PERL_CALLCONV UV    NATIVE_TO_NEED(const UV enc, const UV ch)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_NATIVE_TO_NEED
 #endif
 
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE I32 Perl_POPMARK(pTHX);
+#define PERL_ARGS_ASSERT_POPMARK
+#endif
 PERL_CALLCONV const char *     Perl_PerlIO_context_layers(pTHX_ const char *mode);
+#define PERL_ARGS_ASSERT_PERLIO_CONTEXT_LAYERS
 PERL_CALLCONV int      Perl_PerlLIO_dup2_cloexec(pTHX_ int oldfd, int newfd);
+#define PERL_ARGS_ASSERT_PERLLIO_DUP2_CLOEXEC
 PERL_CALLCONV int      Perl_PerlLIO_dup_cloexec(pTHX_ int oldfd)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_PERLLIO_DUP_CLOEXEC
 
 PERL_CALLCONV int      Perl_PerlLIO_open3_cloexec(pTHX_ const char *file, int flag, int perm)
                        __attribute__warn_unused_result__;
@@ -49,13 +68,58 @@ PERL_CALLCONV int   Perl_PerlLIO_open_cloexec(pTHX_ const char *file, int flag)
 #define PERL_ARGS_ASSERT_PERLLIO_OPEN_CLOEXEC  \
        assert(file)
 
+/* PERL_CALLCONV const XOP *   Perl_custom_op_xop(pTHX_ const OP *o); */
+#define PERL_ARGS_ASSERT_PERL_CUSTOM_OP_XOP
 PERL_CALLCONV const char*      Perl_setlocale(const int category, const char* locale);
+#define PERL_ARGS_ASSERT_PERL_SETLOCALE
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE struct regexp *     Perl_ReANY(const REGEXP * const re);
+#define PERL_ARGS_ASSERT_REANY \
+       assert(re)
+#endif
 PERL_CALLCONV void*    Perl_Slab_Alloc(pTHX_ size_t sz)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SLAB_ALLOC
 
 PERL_CALLCONV void     Perl_Slab_Free(pTHX_ void *op);
 #define PERL_ARGS_ASSERT_SLAB_FREE     \
        assert(op)
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE void        Perl_SvAMAGIC_off(SV *sv);
+#define PERL_ARGS_ASSERT_SVAMAGIC_OFF  \
+       assert(sv)
+#endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE void        Perl_SvAMAGIC_on(SV *sv);
+#define PERL_ARGS_ASSERT_SVAMAGIC_ON   \
+       assert(sv)
+#endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE void        Perl_SvREFCNT_dec(pTHX_ SV *sv);
+#define PERL_ARGS_ASSERT_SVREFCNT_DEC
+#endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE void        Perl_SvREFCNT_dec_NN(pTHX_ SV *sv);
+#define PERL_ARGS_ASSERT_SVREFCNT_DEC_NN       \
+       assert(sv)
+#endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE SV *        Perl_SvREFCNT_inc(SV *sv);
+#define PERL_ARGS_ASSERT_SVREFCNT_INC
+#endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE SV *        Perl_SvREFCNT_inc_NN(SV *sv);
+#define PERL_ARGS_ASSERT_SVREFCNT_INC_NN       \
+       assert(sv)
+#endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE void        Perl_SvREFCNT_inc_void(SV *sv);
+#define PERL_ARGS_ASSERT_SVREFCNT_INC_VOID
+#endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE I32 Perl_TOPMARK(pTHX);
+#define PERL_ARGS_ASSERT_TOPMARK
+#endif
 PERL_CALLCONV char *   Perl__byte_dump_string(pTHX_ const U8 * const start, const STRLEN len, const bool format);
 #define PERL_ARGS_ASSERT__BYTE_DUMP_STRING     \
        assert(start)
@@ -68,14 +132,18 @@ PERL_CALLCONV Size_t       Perl__inverse_folds(pTHX_ const UV cp, unsigned int * first
        assert(first_folds_to); assert(remaining_folds_to)
 
 PERL_CALLCONV bool     Perl__is_in_locale_category(pTHX_ const bool compiling, const int category);
+#define PERL_ARGS_ASSERT__IS_IN_LOCALE_CATEGORY
 PERL_CALLCONV bool     Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT__IS_UNI_FOO
 
 PERL_CALLCONV bool     Perl__is_uni_perl_idcont(pTHX_ UV c)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT__IS_UNI_PERL_IDCONT
 
 PERL_CALLCONV bool     Perl__is_uni_perl_idstart(pTHX_ UV c)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT__IS_UNI_PERL_IDSTART
 
 PERL_CALLCONV bool     Perl__is_utf8_FOO(pTHX_ U8 classnum, const U8 * const p, const char * const name, const char * const alternative, const bool use_utf8, const bool use_locale, const char * const file, const unsigned line)
                        __attribute__warn_unused_result__;
@@ -87,12 +155,6 @@ PERL_CALLCONV bool  Perl__is_utf8_FOO_with_len(pTHX_ const U8 classnum, const U8
 #define PERL_ARGS_ASSERT__IS_UTF8_FOO_WITH_LEN \
        assert(p); assert(e)
 
-PERL_CALLCONV STRLEN   Perl__is_utf8_char_helper(const U8 * const s, const U8 * e, const U32 flags)
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
-#define PERL_ARGS_ASSERT__IS_UTF8_CHAR_HELPER  \
-       assert(s); assert(e)
-
 PERL_CALLCONV bool     Perl__is_utf8_idcont(pTHX_ const U8 *p)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT__IS_UTF8_IDCONT       \
@@ -143,21 +205,18 @@ PERL_CALLCONV UV  Perl__to_utf8_title_flags(pTHX_ const U8 *p, const U8* e, U8* u
 PERL_CALLCONV UV       Perl__to_utf8_upper_flags(pTHX_ const U8 *p, const U8 *e, U8* ustrp, STRLEN *lenp, bool flags, const char * const file, const int line);
 #define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS  \
        assert(p); assert(ustrp); assert(file)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE UV  S__utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen);
-#define PERL_ARGS_ASSERT__UTF8_TO_UVCHR_BUF    \
-       assert(s); assert(send)
-#endif
 PERL_CALLCONV UV       Perl__utf8n_to_uvchr_msgs_helper(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 * errors, AV ** msgs);
 #define PERL_ARGS_ASSERT__UTF8N_TO_UVCHR_MSGS_HELPER   \
        assert(s)
 PERL_CALLCONV void     Perl__warn_problematic_locale(void);
+#define PERL_ARGS_ASSERT__WARN_PROBLEMATIC_LOCALE
 PERL_CALLCONV_NO_RET void      Perl_abort_execution(pTHX_ const char * const msg, const char * const name)
                        __attribute__noreturn__;
 #define PERL_ARGS_ASSERT_ABORT_EXECUTION       \
        assert(msg); assert(name)
 
 PERL_CALLCONV LOGOP*   Perl_alloc_LOGOP(pTHX_ I32 type, OP *first, OP *other);
+#define PERL_ARGS_ASSERT_ALLOC_LOGOP
 PERL_CALLCONV PADOFFSET        Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags);
 #define PERL_ARGS_ASSERT_ALLOCMY       \
        assert(name)
@@ -168,8 +227,9 @@ PERL_CALLCONV SV *  Perl_amagic_deref_call(pTHX_ SV *ref, int method);
 #define PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL     \
        assert(ref)
 PERL_CALLCONV bool     Perl_amagic_is_enabled(pTHX_ int method);
+#define PERL_ARGS_ASSERT_AMAGIC_IS_ENABLED
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_append_utf8_from_native_byte(const U8 byte, U8** dest);
+PERL_STATIC_INLINE void        Perl_append_utf8_from_native_byte(const U8 byte, U8** dest);
 #define PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE  \
        assert(dest)
 #endif
@@ -180,7 +240,9 @@ PERL_CALLCONV void  Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv, co
 #define PERL_ARGS_ASSERT_APPLY_ATTRS_STRING    \
        assert(stashpv); assert(cv); assert(attrstr)
 PERL_CALLCONV void     Perl_atfork_lock(void);
+#define PERL_ARGS_ASSERT_ATFORK_LOCK
 PERL_CALLCONV void     Perl_atfork_unlock(void);
+#define PERL_ARGS_ASSERT_ATFORK_UNLOCK
 PERL_CALLCONV SV**     Perl_av_arylen_p(pTHX_ AV *av);
 #define PERL_ARGS_ASSERT_AV_ARYLEN_P   \
        assert(av)
@@ -250,9 +312,10 @@ PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val);
        assert(av)
 /* PERL_CALLCONV SSize_t       av_tindex(pTHX_ AV *av)
                        __attribute__warn_unused_result__; */
+#define PERL_ARGS_ASSERT_AV_TINDEX
 
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE SSize_t     S_av_top_index(pTHX_ AV *av)
+PERL_STATIC_INLINE SSize_t     Perl_av_top_index(pTHX_ AV *av)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_AV_TOP_INDEX  \
        assert(av)
@@ -271,19 +334,25 @@ PERL_CALLCONV OP* Perl_bind_match(pTHX_ I32 type, OP *left, OP *right)
 
 PERL_CALLCONV OP*      Perl_block_end(pTHX_ I32 floor, OP* seq)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_BLOCK_END
 
 PERL_CALLCONV U8       Perl_block_gimme(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_BLOCK_GIMME
 
 PERL_CALLCONV int      Perl_block_start(pTHX_ int full)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_BLOCK_START
 
 PERL_CALLCONV void     Perl_blockhook_register(pTHX_ BHK *hk);
 #define PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER    \
        assert(hk)
 PERL_CALLCONV void     Perl_boot_core_PerlIO(pTHX);
+#define PERL_ARGS_ASSERT_BOOT_CORE_PERLIO
 PERL_CALLCONV void     Perl_boot_core_UNIVERSAL(pTHX);
+#define PERL_ARGS_ASSERT_BOOT_CORE_UNIVERSAL
 PERL_CALLCONV void     Perl_boot_core_mro(pTHX);
+#define PERL_ARGS_ASSERT_BOOT_CORE_MRO
 PERL_CALLCONV int      Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen);
 #define PERL_ARGS_ASSERT_BYTES_CMP_UTF8        \
        assert(b); assert(u)
@@ -300,6 +369,7 @@ PERL_CALLCONV I32   Perl_call_argv(pTHX_ const char* sub_name, I32 flags, char** a
 #define PERL_ARGS_ASSERT_CALL_ARGV     \
        assert(sub_name); assert(argv)
 PERL_CALLCONV void     Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr);
+#define PERL_ARGS_ASSERT_CALL_ATEXIT
 PERL_CALLCONV void     Perl_call_list(pTHX_ I32 oldscope, AV *paramList);
 #define PERL_ARGS_ASSERT_CALL_LIST     \
        assert(paramList)
@@ -313,9 +383,11 @@ PERL_CALLCONV I32  Perl_call_sv(pTHX_ SV* sv, volatile I32 flags);
 #define PERL_ARGS_ASSERT_CALL_SV       \
        assert(sv)
 PERL_CALLCONV const PERL_CONTEXT *     Perl_caller_cx(pTHX_ I32 level, const PERL_CONTEXT **dbcxp);
+#define PERL_ARGS_ASSERT_CALLER_CX
 PERL_CALLCONV Malloc_t Perl_calloc(MEM_SIZE elements, MEM_SIZE size)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CALLOC
 
 PERL_CALLCONV bool     Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t* statbufp)
                        __attribute__warn_unused_result__;
@@ -324,15 +396,19 @@ PERL_CALLCONV bool        Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t* s
 
 PERL_CALLCONV I32      Perl_cast_i32(NV f)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CAST_I32
 
 PERL_CALLCONV IV       Perl_cast_iv(NV f)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CAST_IV
 
 PERL_CALLCONV U32      Perl_cast_ulong(NV f)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CAST_ULONG
 
 PERL_CALLCONV UV       Perl_cast_uv(NV f)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CAST_UV
 
 PERL_CALLCONV bool     Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len);
 #define PERL_ARGS_ASSERT_CHECK_UTF8_PRINT      \
@@ -592,10 +668,12 @@ PERL_CALLCONV void        Perl_ck_warner_d(pTHX_ U32 err, const char* pat, ...)
 PERL_CALLCONV bool     Perl_ckwarn(pTHX_ U32 w)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_CKWARN
 
 PERL_CALLCONV bool     Perl_ckwarn_d(pTHX_ U32 w)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_CKWARN_D
 
 PERL_CALLCONV void     Perl_clear_defarray(pTHX_ AV* av, bool abandon);
 #define PERL_ARGS_ASSERT_CLEAR_DEFARRAY        \
@@ -616,25 +694,32 @@ PERL_CALLCONV OP *        Perl_coresub_op(pTHX_ SV *const coreargssv, const int code, c
 #define PERL_ARGS_ASSERT_CORESUB_OP    \
        assert(coreargssv)
 PERL_CALLCONV void     Perl_create_eval_scope(pTHX_ OP *retop, U32 flags);
+#define PERL_ARGS_ASSERT_CREATE_EVAL_SCOPE
 PERL_CALLCONV_NO_RET void      Perl_croak(pTHX_ const char* pat, ...)
                        __attribute__noreturn__
                        __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
+#define PERL_ARGS_ASSERT_CROAK
 
 PERL_CALLCONV_NO_RET void      Perl_croak_caller(const char* pat, ...)
                        __attribute__noreturn__
                        __attribute__format__null_ok__(__printf__,1,2);
+#define PERL_ARGS_ASSERT_CROAK_CALLER
 
-PERL_STATIC_INLINE_NO_RET void S_croak_memory_wrap(void)
+PERL_STATIC_INLINE_NO_RET void Perl_croak_memory_wrap(void)
                        __attribute__noreturn__;
+#define PERL_ARGS_ASSERT_CROAK_MEMORY_WRAP
 
 PERL_CALLCONV_NO_RET void      Perl_croak_no_mem(void)
                        __attribute__noreturn__;
+#define PERL_ARGS_ASSERT_CROAK_NO_MEM
 
 PERL_CALLCONV_NO_RET void      Perl_croak_no_modify(void)
                        __attribute__noreturn__;
+#define PERL_ARGS_ASSERT_CROAK_NO_MODIFY
 
 PERL_CALLCONV_NO_RET void      Perl_croak_popstack(void)
                        __attribute__noreturn__;
+#define PERL_ARGS_ASSERT_CROAK_POPSTACK
 
 PERL_CALLCONV_NO_RET void      Perl_croak_sv(pTHX_ SV *baseex)
                        __attribute__noreturn__;
@@ -647,6 +732,7 @@ PERL_CALLCONV_NO_RET void   Perl_croak_xs_usage(const CV *const cv, const char *co
        assert(cv); assert(params)
 
 PERL_CALLCONV regexp_engine const *    Perl_current_re_engine(pTHX);
+#define PERL_ARGS_ASSERT_CURRENT_RE_ENGINE
 #ifndef NO_MATHOMS
 PERL_CALLCONV const char *     Perl_custom_op_desc(pTHX_ const OP *o)
                        __attribute__deprecated__
@@ -671,7 +757,6 @@ PERL_CALLCONV const char *  Perl_custom_op_name(pTHX_ const OP *o)
 PERL_CALLCONV void     Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop);
 #define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER    \
        assert(ppaddr); assert(xop)
-/* PERL_CALLCONV const XOP *   Perl_custom_op_xop(pTHX_ const OP *o); */
 PERL_CALLCONV void     Perl_cv_ckproto_len_flags(pTHX_ const CV* cv, const GV* gv, const char* p, const STRLEN len, const U32 flags);
 #define PERL_ARGS_ASSERT_CV_CKPROTO_LEN_FLAGS  \
        assert(cv)
@@ -683,11 +768,14 @@ PERL_CALLCONV CV* Perl_cv_clone_into(pTHX_ CV* proto, CV *target);
        assert(proto); assert(target)
 PERL_CALLCONV SV*      Perl_cv_const_sv(const CV *const cv)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CV_CONST_SV
 
 PERL_CALLCONV SV*      Perl_cv_const_sv_or_av(const CV *const cv)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CV_CONST_SV_OR_AV
 
 PERL_CALLCONV void     Perl_cv_forget_slab(pTHX_ CV *cv);
+#define PERL_ARGS_ASSERT_CV_FORGET_SLAB
 PERL_CALLCONV void     Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p);
 #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER   \
        assert(cv); assert(ckfun_p); assert(ckobj_p)
@@ -723,6 +811,7 @@ PERL_CALLCONV void  Perl_cx_dump(pTHX_ PERL_CONTEXT* cx);
        assert(cx)
 PERL_CALLCONV I32      Perl_cxinc(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CXINC
 
 PERL_CALLCONV void     Perl_deb(pTHX_ const char* pat, ...)
                        __attribute__format__(__printf__,pTHX_1,pTHX_2);
@@ -730,18 +819,23 @@ PERL_CALLCONV void        Perl_deb(pTHX_ const char* pat, ...)
        assert(pat)
 
 PERL_CALLCONV void     Perl_deb_stack_all(pTHX);
+#define PERL_ARGS_ASSERT_DEB_STACK_ALL
 PERL_CALLCONV I32      Perl_debop(pTHX_ const OP* o);
 #define PERL_ARGS_ASSERT_DEBOP \
        assert(o)
 PERL_CALLCONV void     Perl_debprofdump(pTHX);
+#define PERL_ARGS_ASSERT_DEBPROFDUMP
 PERL_CALLCONV I32      Perl_debstack(pTHX);
+#define PERL_ARGS_ASSERT_DEBSTACK
 PERL_CALLCONV I32      Perl_debstackptrs(pTHX);
+#define PERL_ARGS_ASSERT_DEBSTACKPTRS
 PERL_CALLCONV SV *     Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_DEFELEM_TARGET        \
        assert(sv)
 
 PERL_CALLCONV void     Perl_delete_eval_scope(pTHX);
+#define PERL_ARGS_ASSERT_DELETE_EVAL_SCOPE
 PERL_CALLCONV char*    Perl_delimcpy(char* to, const char* toend, const char* from, const char* fromend, int delim, I32* retlen);
 #define PERL_ARGS_ASSERT_DELIMCPY      \
        assert(to); assert(toend); assert(from); assert(fromend); assert(retlen)
@@ -749,9 +843,11 @@ PERL_CALLCONV char*        Perl_delimcpy_no_escape(char* to, const char* toend, const c
 #define PERL_ARGS_ASSERT_DELIMCPY_NO_ESCAPE    \
        assert(to); assert(toend); assert(from); assert(fromend); assert(retlen)
 PERL_CALLCONV void     Perl_despatch_signals(pTHX);
+#define PERL_ARGS_ASSERT_DESPATCH_SIGNALS
 PERL_CALLCONV_NO_RET OP*       Perl_die(pTHX_ const char* pat, ...)
                        __attribute__noreturn__
                        __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
+#define PERL_ARGS_ASSERT_DIE
 
 PERL_CALLCONV_NO_RET OP*       Perl_die_sv(pTHX_ SV *baseex)
                        __attribute__noreturn__;
@@ -779,6 +875,7 @@ PERL_CALLCONV int   Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode)
 #endif
 
 PERL_CALLCONV bool     Perl_do_close(pTHX_ GV* gv, bool not_implicit);
+#define PERL_ARGS_ASSERT_DO_CLOSE
 PERL_CALLCONV void     Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full);
 #define PERL_ARGS_ASSERT_DO_DUMP_PAD   \
        assert(file)
@@ -837,8 +934,10 @@ PERL_CALLCONV bool Perl_do_print(pTHX_ SV* sv, PerlIO* fp);
        assert(fp)
 PERL_CALLCONV OP*      Perl_do_readline(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_DO_READLINE
 
 PERL_CALLCONV bool     Perl_do_seek(pTHX_ GV* gv, Off_t pos, int whence);
+#define PERL_ARGS_ASSERT_DO_SEEK
 PERL_CALLCONV void     Perl_do_sprintf(pTHX_ SV* sv, SSize_t len, SV** sarg);
 #define PERL_ARGS_ASSERT_DO_SPRINTF    \
        assert(sv); assert(sarg)
@@ -870,13 +969,16 @@ PERL_CALLCONV OP* Perl_dofile(pTHX_ OP* term, I32 force_builtin);
        assert(term)
 PERL_CALLCONV bool     Perl_doing_taint(int argc, char** argv, char** env)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_DOING_TAINT
 
 PERL_CALLCONV OP *     Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref);
 #define PERL_ARGS_ASSERT_DOREF \
        assert(o)
 PERL_CALLCONV void     Perl_dounwind(pTHX_ I32 cxix);
+#define PERL_ARGS_ASSERT_DOUNWIND
 PERL_CALLCONV U8       Perl_dowantarray(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_DOWANTARRAY
 
 PERL_CALLCONV void     Perl_drand48_init_r(perl_drand48_t *random_state, U32 seed);
 #define PERL_ARGS_ASSERT_DRAND48_INIT_R        \
@@ -885,8 +987,11 @@ PERL_CALLCONV double       Perl_drand48_r(perl_drand48_t *random_state);
 #define PERL_ARGS_ASSERT_DRAND48_R     \
        assert(random_state)
 PERL_CALLCONV void     Perl_dump_all(pTHX);
+#define PERL_ARGS_ASSERT_DUMP_ALL
 PERL_CALLCONV void     Perl_dump_all_perl(pTHX_ bool justperl);
+#define PERL_ARGS_ASSERT_DUMP_ALL_PERL
 PERL_CALLCONV void     Perl_dump_eval(pTHX);
+#define PERL_ARGS_ASSERT_DUMP_EVAL
 PERL_CALLCONV void     Perl_dump_form(pTHX_ const GV* gv);
 #define PERL_ARGS_ASSERT_DUMP_FORM     \
        assert(gv)
@@ -911,6 +1016,7 @@ PERL_CALLCONV void Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char*
 #define PERL_ARGS_ASSERT_DUMP_VINDENT  \
        assert(file); assert(pat)
 PERL_CALLCONV STRLEN*  Perl_dup_warnings(pTHX_ STRLEN* warnings);
+#define PERL_ARGS_ASSERT_DUP_WARNINGS
 PERL_CALLCONV void     Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv);
 #define PERL_ARGS_ASSERT_EMULATE_COP_IO        \
        assert(c); assert(sv)
@@ -932,6 +1038,7 @@ PERL_CALLCONV bool Perl_feature_is_enabled(pTHX_ const char *const name, STRLEN
 #define PERL_ARGS_ASSERT_FEATURE_IS_ENABLED    \
        assert(name)
 PERL_CALLCONV SV*      Perl_filter_add(pTHX_ filter_t funcp, SV* datasv);
+#define PERL_ARGS_ASSERT_FILTER_ADD
 PERL_CALLCONV void     Perl_filter_del(pTHX_ filter_t funcp);
 #define PERL_ARGS_ASSERT_FILTER_DEL    \
        assert(funcp)
@@ -944,15 +1051,20 @@ PERL_CALLCONV void       Perl_finalize_optree(pTHX_ OP* o);
 #define PERL_ARGS_ASSERT_FINALIZE_OPTREE       \
        assert(o)
 PERL_CALLCONV CV *     Perl_find_lexical_cv(pTHX_ PADOFFSET off);
+#define PERL_ARGS_ASSERT_FIND_LEXICAL_CV
 PERL_CALLCONV CV*      Perl_find_runcv(pTHX_ U32 *db_seqp)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_FIND_RUNCV
 
 PERL_CALLCONV CV*      Perl_find_runcv_where(pTHX_ U8 cond, IV arg, U32 *db_seqp)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_FIND_RUNCV_WHERE
 
 PERL_CALLCONV SV*      Perl_find_rundefsv(pTHX);
+#define PERL_ARGS_ASSERT_FIND_RUNDEFSV
 PERL_CALLCONV PADOFFSET        Perl_find_rundefsvoffset(pTHX)
                        __attribute__deprecated__;
+#define PERL_ARGS_ASSERT_FIND_RUNDEFSVOFFSET
 
 PERL_CALLCONV char*    Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char *const *const search_ext, I32 flags);
 #define PERL_ARGS_ASSERT_FIND_SCRIPT   \
@@ -973,6 +1085,7 @@ PERL_STATIC_INLINE I32     Perl_foldEQ_locale(const char* a, const char* b, I32 len)
        assert(a); assert(b)
 #endif
 /* PERL_CALLCONV I32   foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */
+#define PERL_ARGS_ASSERT_FOLDEQ_UTF8
 PERL_CALLCONV I32      Perl_foldEQ_utf8_flags(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2, U32 flags);
 #define PERL_ARGS_ASSERT_FOLDEQ_UTF8_FLAGS     \
        assert(s1); assert(s2)
@@ -982,7 +1095,9 @@ PERL_CALLCONV char*        Perl_form(pTHX_ const char* pat, ...)
        assert(pat)
 
 PERL_CALLCONV void     Perl_free_tied_hv_pool(pTHX);
+#define PERL_ARGS_ASSERT_FREE_TIED_HV_POOL
 PERL_CALLCONV void     Perl_free_tmps(pTHX);
+#define PERL_ARGS_ASSERT_FREE_TMPS
 PERL_CALLCONV SV*      Perl_get_and_check_backslash_N_name(pTHX_ const char* s, const char* const e, const bool is_utf8, const char** error_msg)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME        \
@@ -993,6 +1108,7 @@ PERL_CALLCONV AV*  Perl_get_av(pTHX_ const char *name, I32 flags);
        assert(name)
 PERL_CALLCONV void*    Perl_get_context(void)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_GET_CONTEXT
 
 PERL_CALLCONV CV*      Perl_get_cv(pTHX_ const char* name, I32 flags);
 #define PERL_ARGS_ASSERT_GET_CV        \
@@ -1012,35 +1128,44 @@ PERL_CALLCONV HV*       Perl_get_hv(pTHX_ const char *name, I32 flags);
 PERL_CALLCONV const char*      Perl_get_no_modify(pTHX)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_GET_NO_MODIFY
 
 PERL_CALLCONV char**   Perl_get_op_descs(pTHX)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_GET_OP_DESCS
 
 PERL_CALLCONV char**   Perl_get_op_names(pTHX)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_GET_OP_NAMES
 
 PERL_CALLCONV U32*     Perl_get_opargs(pTHX)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_GET_OPARGS
 
 PERL_CALLCONV PPADDR_t*        Perl_get_ppaddr(pTHX)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_GET_PPADDR
 
 PERL_CALLCONV REGEXP * Perl_get_re_arg(pTHX_ SV *sv);
+#define PERL_ARGS_ASSERT_GET_RE_ARG
 PERL_CALLCONV SV*      Perl_get_sv(pTHX_ const char *name, I32 flags);
 #define PERL_ARGS_ASSERT_GET_SV        \
        assert(name)
 PERL_CALLCONV MGVTBL*  Perl_get_vtbl(pTHX_ int vtbl_id)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_GET_VTBL
 
 PERL_CALLCONV int      Perl_getcwd_sv(pTHX_ SV* sv);
 #define PERL_ARGS_ASSERT_GETCWD_SV     \
        assert(sv)
 PERL_CALLCONV void     Perl_gp_free(pTHX_ GV* gv);
+#define PERL_ARGS_ASSERT_GP_FREE
 PERL_CALLCONV GP*      Perl_gp_ref(pTHX_ GP* gp);
+#define PERL_ARGS_ASSERT_GP_REF
 PERL_CALLCONV bool     Perl_grok_atoUV(const char* pv, UV* valptr, const char** endptr);
 #define PERL_ARGS_ASSERT_GROK_ATOUV    \
        assert(pv); assert(valptr)
@@ -1069,16 +1194,21 @@ PERL_CALLCONV UV        Perl_grok_oct(pTHX_ const char* start, STRLEN* len_p, I32* flag
        assert(start); assert(len_p); assert(flags)
 #ifndef NO_MATHOMS
 PERL_CALLCONV GV*      Perl_gv_AVadd(pTHX_ GV *gv);
+#define PERL_ARGS_ASSERT_GV_AVADD
 #endif
 #ifndef NO_MATHOMS
 PERL_CALLCONV GV*      Perl_gv_HVadd(pTHX_ GV *gv);
+#define PERL_ARGS_ASSERT_GV_HVADD
 #endif
 #ifndef NO_MATHOMS
 PERL_CALLCONV GV*      Perl_gv_IOadd(pTHX_ GV* gv);
+#define PERL_ARGS_ASSERT_GV_IOADD
 #endif
 PERL_CALLCONV GV*      Perl_gv_add_by_type(pTHX_ GV *gv, svtype type);
+#define PERL_ARGS_ASSERT_GV_ADD_BY_TYPE
 /* PERL_CALLCONV GV*   gv_autoload4(pTHX_ HV* stash, const char* name, STRLEN len, I32 method)
                        __attribute__warn_unused_result__; */
+#define PERL_ARGS_ASSERT_GV_AUTOLOAD4
 
 PERL_CALLCONV GV*      Perl_gv_autoload_pv(pTHX_ HV* stash, const char* namepv, U32 flags)
                        __attribute__warn_unused_result__;
@@ -1104,6 +1234,7 @@ PERL_CALLCONV SV* Perl_gv_const_sv(pTHX_ GV* gv)
        assert(gv)
 
 PERL_CALLCONV void     Perl_gv_dump(pTHX_ GV* gv);
+#define PERL_ARGS_ASSERT_GV_DUMP
 #ifndef NO_MATHOMS
 PERL_CALLCONV void     Perl_gv_efullname(pTHX_ SV* sv, const GV* gv)
                        __attribute__deprecated__;
@@ -1126,7 +1257,9 @@ PERL_CALLCONV GV* Perl_gv_fetchfile_flags(pTHX_ const char *const name, const ST
 #define PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS    \
        assert(name)
 /* PERL_CALLCONV GV*   gv_fetchmeth(pTHX_ HV* stash, const char* name, STRLEN len, I32 level); */
+#define PERL_ARGS_ASSERT_GV_FETCHMETH
 /* PERL_CALLCONV GV*   gv_fetchmeth_autoload(pTHX_ HV* stash, const char* name, STRLEN len, I32 level); */
+#define PERL_ARGS_ASSERT_GV_FETCHMETH_AUTOLOAD
 PERL_CALLCONV GV*      Perl_gv_fetchmeth_pv(pTHX_ HV* stash, const char* name, I32 level, U32 flags);
 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV       \
        assert(name)
@@ -1188,8 +1321,10 @@ PERL_CALLCONV void       Perl_gv_fullname4(pTHX_ SV* sv, const GV* gv, const char* pre
        assert(sv); assert(gv)
 PERL_CALLCONV CV*      Perl_gv_handler(pTHX_ HV* stash, I32 id)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_GV_HANDLER
 
 /* PERL_CALLCONV void  gv_init(pTHX_ GV* gv, HV* stash, const char* name, STRLEN len, int multi); */
+#define PERL_ARGS_ASSERT_GV_INIT
 PERL_CALLCONV void     Perl_gv_init_pv(pTHX_ GV* gv, HV* stash, const char* name, U32 flags);
 #define PERL_ARGS_ASSERT_GV_INIT_PV    \
        assert(gv); assert(name)
@@ -1229,15 +1364,18 @@ PERL_CALLCONV SV*       Perl_hv_bucket_ratio(pTHX_ HV *hv)
        assert(hv)
 
 PERL_CALLCONV void     Perl_hv_clear(pTHX_ HV *hv);
+#define PERL_ARGS_ASSERT_HV_CLEAR
 PERL_CALLCONV void     Perl_hv_clear_placeholders(pTHX_ HV *hv);
 #define PERL_ARGS_ASSERT_HV_CLEAR_PLACEHOLDERS \
        assert(hv)
 PERL_CALLCONV void*    Perl_hv_common(pTHX_ HV *hv, SV *keysv, const char* key, STRLEN klen, int flags, int action, SV *val, U32 hash);
+#define PERL_ARGS_ASSERT_HV_COMMON
 PERL_CALLCONV void*    Perl_hv_common_key_len(pTHX_ HV *hv, const char *key, I32 klen_i32, const int action, SV *val, const U32 hash);
 #define PERL_ARGS_ASSERT_HV_COMMON_KEY_LEN     \
        assert(key)
 PERL_CALLCONV HV *     Perl_hv_copy_hints_hv(pTHX_ HV *const ohv)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_HV_COPY_HINTS_HV
 
 PERL_CALLCONV void     Perl_hv_delayfree_ent(pTHX_ HV *hv, HE *entry);
 #define PERL_ARGS_ASSERT_HV_DELAYFREE_ENT      \
@@ -1376,44 +1514,59 @@ PERL_CALLCONV SV*       Perl_hv_scalar(pTHX_ HV *hv)
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV SV**     Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash);
+#define PERL_ARGS_ASSERT_HV_STORE
 #endif
 #ifndef NO_MATHOMS
 PERL_CALLCONV HE*      Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash);
+#define PERL_ARGS_ASSERT_HV_STORE_ENT
 #endif
 #ifndef NO_MATHOMS
 PERL_CALLCONV SV**     Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags);
+#define PERL_ARGS_ASSERT_HV_STORE_FLAGS
 #endif
 /* PERL_CALLCONV void  hv_undef(pTHX_ HV *hv); */
+#define PERL_ARGS_ASSERT_HV_UNDEF
 PERL_CALLCONV void     Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags);
+#define PERL_ARGS_ASSERT_HV_UNDEF_FLAGS
 /* PERL_CALLCONV I32   ibcmp(pTHX_ const char* a, const char* b, I32 len)
                        __attribute__warn_unused_result__
                        __attribute__pure__; */
+#define PERL_ARGS_ASSERT_IBCMP
 
 /* PERL_CALLCONV I32   ibcmp_locale(pTHX_ const char* a, const char* b, I32 len)
                        __attribute__warn_unused_result__
                        __attribute__pure__; */
+#define PERL_ARGS_ASSERT_IBCMP_LOCALE
 
 /* PERL_CALLCONV I32   ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */
+#define PERL_ARGS_ASSERT_IBCMP_UTF8
 PERL_CALLCONV void     Perl_init_argv_symbols(pTHX_ int argc, char **argv);
 #define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS     \
        assert(argv)
 PERL_CALLCONV void     Perl_init_constants(pTHX);
+#define PERL_ARGS_ASSERT_INIT_CONSTANTS
 PERL_CALLCONV void     Perl_init_dbargs(pTHX);
+#define PERL_ARGS_ASSERT_INIT_DBARGS
 PERL_CALLCONV void     Perl_init_debugger(pTHX);
+#define PERL_ARGS_ASSERT_INIT_DEBUGGER
 PERL_CALLCONV int      Perl_init_i18nl10n(pTHX_ int printwarn);
+#define PERL_ARGS_ASSERT_INIT_I18NL10N
 #ifndef NO_MATHOMS
 PERL_CALLCONV int      Perl_init_i18nl14n(pTHX_ int printwarn)
                        __attribute__deprecated__;
+#define PERL_ARGS_ASSERT_INIT_I18NL14N
 #endif
 
 PERL_CALLCONV void     Perl_init_named_cv(pTHX_ CV *cv, OP *nameop);
 #define PERL_ARGS_ASSERT_INIT_NAMED_CV \
        assert(cv); assert(nameop)
 PERL_CALLCONV void     Perl_init_stacks(pTHX);
+#define PERL_ARGS_ASSERT_INIT_STACKS
 PERL_CALLCONV void     Perl_init_tm(pTHX_ struct tm *ptm);
 #define PERL_ARGS_ASSERT_INIT_TM       \
        assert(ptm)
 PERL_CALLCONV void     Perl_init_uniprops(pTHX);
+#define PERL_ARGS_ASSERT_INIT_UNIPROPS
 #ifndef NO_MATHOMS
 PERL_CALLCONV char*    Perl_instr(const char* big, const char* little)
                        __attribute__warn_unused_result__
@@ -1423,8 +1576,10 @@ PERL_CALLCONV char*      Perl_instr(const char* big, const char* little)
 #endif
 
 PERL_CALLCONV U32      Perl_intro_my(pTHX);
+#define PERL_ARGS_ASSERT_INTRO_MY
 PERL_CALLCONV OP*      Perl_invert(pTHX_ OP* cmd)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_INVERT
 
 PERL_CALLCONV bool     Perl_io_close(pTHX_ IO* io, GV *gv, bool not_implicit, bool warn_on_fail);
 #define PERL_ARGS_ASSERT_IO_CLOSE      \
@@ -1438,7 +1593,7 @@ PERL_CALLCONV bool        Perl_isALNUM_lazy(pTHX_ const char* p)
 #endif
 
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE Size_t      S_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e)
+PERL_STATIC_INLINE Size_t      Perl_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_ISC9_STRICT_UTF8_CHAR \
        assert(s0); assert(e)
@@ -1453,14 +1608,14 @@ PERL_CALLCONV bool      Perl_isIDFIRST_lazy(pTHX_ const char* p)
 #endif
 
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE Size_t      S_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e)
+PERL_STATIC_INLINE Size_t      Perl_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_ISSTRICT_UTF8_CHAR    \
        assert(s0); assert(e)
 #endif
 
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE Size_t      S_isUTF8_CHAR(const U8 * const s0, const U8 * const e)
+PERL_STATIC_INLINE Size_t      Perl_isUTF8_CHAR(const U8 * const s0, const U8 * const e)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_ISUTF8_CHAR   \
        assert(s0); assert(e)
@@ -1469,25 +1624,30 @@ PERL_STATIC_INLINE Size_t       S_isUTF8_CHAR(const U8 * const s0, const U8 * const e)
 /* PERL_CALLCONV bool  is_ascii_string(const U8* const s, STRLEN len)
                        __attribute__warn_unused_result__
                        __attribute__pure__; */
+#define PERL_ARGS_ASSERT_IS_ASCII_STRING
 
 /* PERL_CALLCONV bool  is_c9strict_utf8_string(const U8 *s, STRLEN len)
                        __attribute__warn_unused_result__; */
+#define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING
 
 /* PERL_CALLCONV bool  is_c9strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */
+#define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING_LOC
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE bool        S_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el);
+PERL_STATIC_INLINE bool        Perl_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el);
 #define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING_LOCLEN        \
        assert(s)
 #endif
 /* PERL_CALLCONV bool  is_invariant_string(const U8* const s, STRLEN len)
                        __attribute__warn_unused_result__
                        __attribute__pure__; */
+#define PERL_ARGS_ASSERT_IS_INVARIANT_STRING
 
 PERL_CALLCONV I32      Perl_is_lvalue_sub(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_LVALUE_SUB
 
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE bool        S_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name)
+PERL_STATIC_INLINE bool        Perl_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_IS_SAFE_SYSCALL       \
        assert(pv); assert(what); assert(op_name)
@@ -1495,10 +1655,12 @@ PERL_STATIC_INLINE bool S_is_safe_syscall(pTHX_ const char *pv, STRLEN len, cons
 
 /* PERL_CALLCONV bool  is_strict_utf8_string(const U8 *s, STRLEN len)
                        __attribute__warn_unused_result__; */
+#define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING
 
 /* PERL_CALLCONV bool  is_strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */
+#define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING_LOC
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE bool        S_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el);
+PERL_STATIC_INLINE bool        Perl_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el);
 #define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING_LOCLEN  \
        assert(s)
 #endif
@@ -1506,36 +1668,42 @@ PERL_STATIC_INLINE bool S_is_strict_utf8_string_loclen(const U8 *s, STRLEN len,
 PERL_CALLCONV bool     Perl_is_uni_alnum(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_ALNUM
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_alnum_lc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_ALNUM_LC
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_alnumc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_ALNUMC
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_alnumc_lc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_ALNUMC_LC
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_alpha(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_ALPHA
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_alpha_lc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_ALPHA_LC
 #endif
 
 #ifndef NO_MATHOMS
@@ -1543,6 +1711,7 @@ PERL_CALLCONV bool        Perl_is_uni_ascii(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_IS_UNI_ASCII
 #endif
 
 #ifndef NO_MATHOMS
@@ -1550,6 +1719,7 @@ PERL_CALLCONV bool        Perl_is_uni_ascii_lc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_IS_UNI_ASCII_LC
 #endif
 
 #ifndef NO_MATHOMS
@@ -1557,6 +1727,7 @@ PERL_CALLCONV bool        Perl_is_uni_blank(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_IS_UNI_BLANK
 #endif
 
 #ifndef NO_MATHOMS
@@ -1564,6 +1735,7 @@ PERL_CALLCONV bool        Perl_is_uni_blank_lc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_IS_UNI_BLANK_LC
 #endif
 
 #ifndef NO_MATHOMS
@@ -1571,6 +1743,7 @@ PERL_CALLCONV bool        Perl_is_uni_cntrl(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_IS_UNI_CNTRL
 #endif
 
 #ifndef NO_MATHOMS
@@ -1578,78 +1751,91 @@ PERL_CALLCONV bool      Perl_is_uni_cntrl_lc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_IS_UNI_CNTRL_LC
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_digit(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_DIGIT
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_digit_lc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_DIGIT_LC
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_graph(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_GRAPH
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_graph_lc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_GRAPH_LC
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_idfirst(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_IDFIRST
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_idfirst_lc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_IDFIRST_LC
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_lower(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_LOWER
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_lower_lc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_LOWER_LC
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_print(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_PRINT
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_print_lc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_PRINT_LC
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_punct(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_PUNCT
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_punct_lc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_PUNCT_LC
 #endif
 
 #ifndef NO_MATHOMS
@@ -1657,6 +1843,7 @@ PERL_CALLCONV bool        Perl_is_uni_space(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_IS_UNI_SPACE
 #endif
 
 #ifndef NO_MATHOMS
@@ -1664,18 +1851,21 @@ PERL_CALLCONV bool      Perl_is_uni_space_lc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_IS_UNI_SPACE_LC
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_upper(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_UPPER
 #endif
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_uni_upper_lc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_UNI_UPPER_LC
 #endif
 
 #ifndef NO_MATHOMS
@@ -1683,6 +1873,7 @@ PERL_CALLCONV bool        Perl_is_uni_xdigit(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_IS_UNI_XDIGIT
 #endif
 
 #ifndef NO_MATHOMS
@@ -1690,6 +1881,7 @@ PERL_CALLCONV bool        Perl_is_uni_xdigit_lc(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_IS_UNI_XDIGIT_LC
 #endif
 
 #ifndef NO_MATHOMS
@@ -1744,6 +1936,12 @@ PERL_CALLCONV STRLEN     Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end);
 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF      \
        assert(buf); assert(buf_end)
 #endif
+PERL_CALLCONV STRLEN   Perl_is_utf8_char_helper(const U8 * const s, const U8 * e, const U32 flags)
+                       __attribute__warn_unused_result__
+                       __attribute__pure__;
+#define PERL_ARGS_ASSERT_IS_UTF8_CHAR_HELPER   \
+       assert(s); assert(e)
+
 #ifndef NO_MATHOMS
 PERL_CALLCONV bool     Perl_is_utf8_cntrl(pTHX_ const U8 *p)
                        __attribute__deprecated__
@@ -1761,9 +1959,11 @@ PERL_CALLCONV bool       Perl_is_utf8_digit(pTHX_ const U8 *p)
 #endif
 
 /* PERL_CALLCONV bool  is_utf8_fixed_width_buf_flags(const U8 * const s, STRLEN len, const U32 flags); */
+#define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_FLAGS
 /* PERL_CALLCONV bool  is_utf8_fixed_width_buf_loc_flags(const U8 * const s, STRLEN len, const U8 **ep, const U32 flags); */
+#define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_LOC_FLAGS
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE bool        S_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags);
+PERL_STATIC_INLINE bool        Perl_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags);
 #define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_LOCLEN_FLAGS  \
        assert(s)
 #endif
@@ -1793,9 +1993,10 @@ PERL_CALLCONV bool       Perl_is_utf8_idfirst(pTHX_ const U8 *p)
 
 /* PERL_CALLCONV bool  is_utf8_invariant_string(const U8* const s, STRLEN len)
                        __attribute__warn_unused_result__; */
+#define PERL_ARGS_ASSERT_IS_UTF8_INVARIANT_STRING
 
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE bool        S_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep)
+PERL_STATIC_INLINE bool        Perl_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_IS_UTF8_INVARIANT_STRING_LOC  \
        assert(s)
@@ -1867,9 +2068,10 @@ PERL_CALLCONV bool       Perl_is_utf8_space(pTHX_ const U8 *p)
 
 /* PERL_CALLCONV bool  is_utf8_string(const U8 *s, STRLEN len)
                        __attribute__warn_unused_result__; */
+#define PERL_ARGS_ASSERT_IS_UTF8_STRING
 
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE bool        S_is_utf8_string_flags(const U8 *s, STRLEN len, const U32 flags)
+PERL_STATIC_INLINE bool        Perl_is_utf8_string_flags(const U8 *s, STRLEN len, const U32 flags)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_FLAGS  \
        assert(s)
@@ -1881,13 +2083,14 @@ PERL_CALLCONV bool      Perl_is_utf8_string_loc(const U8 *s, const STRLEN len, const
        assert(s); assert(ep)
 #endif
 /* PERL_CALLCONV bool  is_utf8_string_loc_flags(const U8 *s, STRLEN len, const U8 **ep, const U32 flags); */
+#define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC_FLAGS
 #ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE bool        Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el);
 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN \
        assert(s)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE bool        S_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags);
+PERL_STATIC_INLINE bool        Perl_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags);
 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN_FLAGS   \
        assert(s)
 #endif
@@ -1902,9 +2105,10 @@ PERL_CALLCONV bool       Perl_is_utf8_upper(pTHX_ const U8 *p)
 /* PERL_CALLCONV bool  is_utf8_valid_partial_char(const U8 * const s, const U8 * const e)
                        __attribute__warn_unused_result__
                        __attribute__pure__; */
+#define PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR
 
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE bool        S_is_utf8_valid_partial_char_flags(const U8 * const s, const U8 * const e, const U32 flags)
+PERL_STATIC_INLINE bool        Perl_is_utf8_valid_partial_char_flags(const U8 * const s, const U8 * const e, const U32 flags)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR_FLAGS      \
        assert(s); assert(e)
@@ -1937,6 +2141,7 @@ PERL_CALLCONV bool        Perl_is_utf8_xidfirst(pTHX_ const U8 *p)
 PERL_CALLCONV bool     Perl_isinfnan(NV nv)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_ISINFNAN
 
 PERL_CALLCONV bool     Perl_isinfnansv(pTHX_ SV *sv);
 #define PERL_ARGS_ASSERT_ISINFNANSV    \
@@ -1957,19 +2162,27 @@ PERL_CALLCONV void      Perl_leave_adjust_stacks(pTHX_ SV **from_sp, SV **to_sp, U8 g
 #define PERL_ARGS_ASSERT_LEAVE_ADJUST_STACKS   \
        assert(from_sp); assert(to_sp)
 PERL_CALLCONV void     Perl_leave_scope(pTHX_ I32 base);
+#define PERL_ARGS_ASSERT_LEAVE_SCOPE
 PERL_CALLCONV bool     Perl_lex_bufutf8(pTHX);
+#define PERL_ARGS_ASSERT_LEX_BUFUTF8
 PERL_CALLCONV void     Perl_lex_discard_to(pTHX_ char* ptr);
 #define PERL_ARGS_ASSERT_LEX_DISCARD_TO        \
        assert(ptr)
 PERL_CALLCONV char*    Perl_lex_grow_linestr(pTHX_ STRLEN len);
+#define PERL_ARGS_ASSERT_LEX_GROW_LINESTR
 PERL_CALLCONV bool     Perl_lex_next_chunk(pTHX_ U32 flags);
+#define PERL_ARGS_ASSERT_LEX_NEXT_CHUNK
 PERL_CALLCONV I32      Perl_lex_peek_unichar(pTHX_ U32 flags);
+#define PERL_ARGS_ASSERT_LEX_PEEK_UNICHAR
 PERL_CALLCONV void     Perl_lex_read_space(pTHX_ U32 flags);
+#define PERL_ARGS_ASSERT_LEX_READ_SPACE
 PERL_CALLCONV void     Perl_lex_read_to(pTHX_ char* ptr);
 #define PERL_ARGS_ASSERT_LEX_READ_TO   \
        assert(ptr)
 PERL_CALLCONV I32      Perl_lex_read_unichar(pTHX_ U32 flags);
+#define PERL_ARGS_ASSERT_LEX_READ_UNICHAR
 PERL_CALLCONV void     Perl_lex_start(pTHX_ SV* line, PerlIO *rsfp, U32 flags);
+#define PERL_ARGS_ASSERT_LEX_START
 PERL_CALLCONV void     Perl_lex_stuff_pv(pTHX_ const char* pv, U32 flags);
 #define PERL_ARGS_ASSERT_LEX_STUFF_PV  \
        assert(pv)
@@ -1983,6 +2196,7 @@ PERL_CALLCONV void        Perl_lex_unstuff(pTHX_ char* ptr);
 #define PERL_ARGS_ASSERT_LEX_UNSTUFF   \
        assert(ptr)
 PERL_CALLCONV OP*      Perl_list(pTHX_ OP* o);
+#define PERL_ARGS_ASSERT_LIST
 PERL_CALLCONV void     Perl_load_module(pTHX_ U32 flags, SV* name, SV* ver, ...);
 #define PERL_ARGS_ASSERT_LOAD_MODULE   \
        assert(name)
@@ -2022,6 +2236,7 @@ PERL_CALLCONV int Perl_magic_copycallchecker(pTHX_ SV* sv, MAGIC *mg, SV *nsv, c
 #define PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER \
        assert(sv); assert(mg); assert(nsv)
 PERL_CALLCONV void     Perl_magic_dump(pTHX_ const MAGIC *mg);
+#define PERL_ARGS_ASSERT_MAGIC_DUMP
 PERL_CALLCONV int      Perl_magic_existspack(pTHX_ SV* sv, const MAGIC* mg);
 #define PERL_ARGS_ASSERT_MAGIC_EXISTSPACK      \
        assert(sv); assert(mg)
@@ -2160,8 +2375,10 @@ PERL_CALLCONV int        Perl_magic_wipepack(pTHX_ SV* sv, MAGIC* mg);
 PERL_CALLCONV Malloc_t Perl_malloc(MEM_SIZE nbytes)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_MALLOC
 
 PERL_CALLCONV I32 *    Perl_markstack_grow(pTHX);
+#define PERL_ARGS_ASSERT_MARKSTACK_GROW
 PERL_CALLCONV SV*      Perl_mess(pTHX_ const char* pat, ...)
                        __attribute__format__(__printf__,pTHX_1,pTHX_2);
 #define PERL_ARGS_ASSERT_MESS  \
@@ -2171,6 +2388,7 @@ PERL_CALLCONV SV* Perl_mess_sv(pTHX_ SV* basemsg, bool consume);
 #define PERL_ARGS_ASSERT_MESS_SV       \
        assert(basemsg)
 PERL_CALLCONV Free_t   Perl_mfree(Malloc_t where);
+#define PERL_ARGS_ASSERT_MFREE
 PERL_CALLCONV int      Perl_mg_clear(pTHX_ SV* sv);
 #define PERL_ARGS_ASSERT_MG_CLEAR      \
        assert(sv)
@@ -2179,6 +2397,7 @@ PERL_CALLCONV int Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen)
        assert(sv); assert(nsv)
 PERL_CALLCONV MAGIC*   Perl_mg_find(const SV* sv, int type)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_MG_FIND
 
 PERL_CALLCONV MAGIC*   Perl_mg_find_mglob(pTHX_ SV* sv)
                        __attribute__warn_unused_result__;
@@ -2187,6 +2406,7 @@ PERL_CALLCONV MAGIC*      Perl_mg_find_mglob(pTHX_ SV* sv)
 
 PERL_CALLCONV MAGIC*   Perl_mg_findext(const SV* sv, int type, const MGVTBL *vtbl)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_MG_FINDEXT
 
 PERL_CALLCONV int      Perl_mg_free(pTHX_ SV* sv);
 #define PERL_ARGS_ASSERT_MG_FREE       \
@@ -2221,7 +2441,9 @@ PERL_CALLCONV void        Perl_mini_mktime(struct tm *ptm);
 #define PERL_ARGS_ASSERT_MINI_MKTIME   \
        assert(ptm)
 PERL_CALLCONV int      Perl_mode_from_discipline(pTHX_ const char* s, STRLEN len);
+#define PERL_ARGS_ASSERT_MODE_FROM_DISCIPLINE
 PERL_CALLCONV void *   Perl_more_bodies(pTHX_ const svtype sv_type, const size_t body_size, const size_t arena_size);
+#define PERL_ARGS_ASSERT_MORE_BODIES
 PERL_CALLCONV const char*      Perl_moreswitches(pTHX_ const char* s);
 #define PERL_ARGS_ASSERT_MORESWITCHES  \
        assert(s)
@@ -2274,19 +2496,27 @@ PERL_CALLCONV OP *      Perl_my_attrs(pTHX_ OP *o, OP *attrs);
 #define PERL_ARGS_ASSERT_MY_ATTRS      \
        assert(o)
 PERL_CALLCONV void     Perl_my_clearenv(pTHX);
+#define PERL_ARGS_ASSERT_MY_CLEARENV
 PERL_CALLCONV int      Perl_my_dirfd(DIR* dir);
+#define PERL_ARGS_ASSERT_MY_DIRFD
 PERL_CALLCONV_NO_RET void      Perl_my_exit(pTHX_ U32 status)
                        __attribute__noreturn__;
+#define PERL_ARGS_ASSERT_MY_EXIT
 
 PERL_CALLCONV_NO_RET void      Perl_my_failure_exit(pTHX)
                        __attribute__noreturn__;
+#define PERL_ARGS_ASSERT_MY_FAILURE_EXIT
 
 PERL_CALLCONV I32      Perl_my_fflush_all(pTHX);
+#define PERL_ARGS_ASSERT_MY_FFLUSH_ALL
 PERL_CALLCONV Pid_t    Perl_my_fork(void);
+#define PERL_ARGS_ASSERT_MY_FORK
 #ifndef NO_MATHOMS
 PERL_CALLCONV I32      Perl_my_lstat(pTHX);
+#define PERL_ARGS_ASSERT_MY_LSTAT
 #endif
 PERL_CALLCONV I32      Perl_my_lstat_flags(pTHX_ const U32 flags);
+#define PERL_ARGS_ASSERT_MY_LSTAT_FLAGS
 PERL_CALLCONV int      Perl_my_mkostemp_cloexec(char *templte, int flags)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_MY_MKOSTEMP_CLOEXEC   \
@@ -2301,17 +2531,22 @@ PERL_CALLCONV PerlIO*   Perl_my_popen_list(pTHX_ const char* mode, int n, SV ** ar
 #define PERL_ARGS_ASSERT_MY_POPEN_LIST \
        assert(mode); assert(args)
 PERL_CALLCONV void     Perl_my_setenv(pTHX_ const char* nam, const char* val);
+#define PERL_ARGS_ASSERT_MY_SETENV
 PERL_CALLCONV int      Perl_my_snprintf(char *buffer, const Size_t len, const char *format, ...)
                        __attribute__format__(__printf__,3,4);
 #define PERL_ARGS_ASSERT_MY_SNPRINTF   \
        assert(buffer); assert(format)
 
 PERL_CALLCONV int      Perl_my_socketpair(int family, int type, int protocol, int fd[2]);
+#define PERL_ARGS_ASSERT_MY_SOCKETPAIR
 #ifndef NO_MATHOMS
 PERL_CALLCONV I32      Perl_my_stat(pTHX);
+#define PERL_ARGS_ASSERT_MY_STAT
 #endif
 PERL_CALLCONV I32      Perl_my_stat_flags(pTHX_ const U32 flags);
+#define PERL_ARGS_ASSERT_MY_STAT_FLAGS
 PERL_CALLCONV char*    Perl_my_strerror(pTHX_ const int errnum);
+#define PERL_ARGS_ASSERT_MY_STRERROR
 PERL_CALLCONV char *   Perl_my_strftime(pTHX_ const char *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst)
                        __attribute__format__(__strftime__,pTHX_1,0);
 #define PERL_ARGS_ASSERT_MY_STRFTIME   \
@@ -2323,25 +2558,34 @@ PERL_CALLCONV NV        Perl_my_strtod(const char * const s, char ** e)
        assert(s)
 
 PERL_CALLCONV void     Perl_my_unexec(pTHX);
+#define PERL_ARGS_ASSERT_MY_UNEXEC
 PERL_CALLCONV int      Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap);
 #define PERL_ARGS_ASSERT_MY_VSNPRINTF  \
        assert(buffer); assert(format)
 PERL_CALLCONV OP*      Perl_newANONATTRSUB(pTHX_ I32 floor, OP *proto, OP *attrs, OP *block);
+#define PERL_ARGS_ASSERT_NEWANONATTRSUB
 PERL_CALLCONV OP*      Perl_newANONHASH(pTHX_ OP* o)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWANONHASH
 
 PERL_CALLCONV OP*      Perl_newANONLIST(pTHX_ OP* o)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWANONLIST
 
 PERL_CALLCONV OP*      Perl_newANONSUB(pTHX_ I32 floor, OP* proto, OP* block);
+#define PERL_ARGS_ASSERT_NEWANONSUB
 PERL_CALLCONV OP*      Perl_newASSIGNOP(pTHX_ I32 flags, OP* left, I32 optype, OP* right)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWASSIGNOP
 
 /* PERL_CALLCONV CV*   newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); */
+#define PERL_ARGS_ASSERT_NEWATTRSUB
 PERL_CALLCONV CV*      Perl_newATTRSUB_x(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block, bool o_is_gv);
+#define PERL_ARGS_ASSERT_NEWATTRSUB_X
 #ifndef NO_MATHOMS
 PERL_CALLCONV AV*      Perl_newAV(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWAV
 #endif
 
 PERL_CALLCONV OP*      Perl_newAVREF(pTHX_ OP* o)
@@ -2351,6 +2595,7 @@ PERL_CALLCONV OP* Perl_newAVREF(pTHX_ OP* o)
 
 PERL_CALLCONV OP*      Perl_newBINOP(pTHX_ I32 type, I32 flags, OP* first, OP* last)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWBINOP
 
 PERL_CALLCONV OP*      Perl_newCONDOP(pTHX_ I32 flags, OP* first, OP* trueop, OP* falseop)
                        __attribute__warn_unused_result__;
@@ -2358,14 +2603,19 @@ PERL_CALLCONV OP*       Perl_newCONDOP(pTHX_ I32 flags, OP* first, OP* trueop, OP* fal
        assert(first)
 
 PERL_CALLCONV CV*      Perl_newCONSTSUB(pTHX_ HV* stash, const char* name, SV* sv);
+#define PERL_ARGS_ASSERT_NEWCONSTSUB
 PERL_CALLCONV CV*      Perl_newCONSTSUB_flags(pTHX_ HV* stash, const char* name, STRLEN len, U32 flags, SV* sv);
+#define PERL_ARGS_ASSERT_NEWCONSTSUB_FLAGS
 PERL_CALLCONV OP*      Perl_newCVREF(pTHX_ I32 flags, OP* o)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWCVREF
 
 PERL_CALLCONV OP*      Perl_newDEFSVOP(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWDEFSVOP
 
 PERL_CALLCONV void     Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block);
+#define PERL_ARGS_ASSERT_NEWFORM
 PERL_CALLCONV OP*      Perl_newFOROP(pTHX_ I32 flags, OP* sv, OP* expr, OP* block, OP* cont)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_NEWFOROP      \
@@ -2386,8 +2636,10 @@ PERL_CALLCONV OP*        Perl_newGVOP(pTHX_ I32 type, I32 flags, GV* gv)
 
 PERL_CALLCONV OP*      Perl_newGVREF(pTHX_ I32 type, OP* o)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWGVREF
 
 /* PERL_CALLCONV GV*   newGVgen(pTHX_ const char* pack); */
+#define PERL_ARGS_ASSERT_NEWGVGEN
 PERL_CALLCONV GV*      Perl_newGVgen_flags(pTHX_ const char* pack, U32 flags)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_NEWGVGEN_FLAGS        \
@@ -2396,6 +2648,7 @@ PERL_CALLCONV GV* Perl_newGVgen_flags(pTHX_ const char* pack, U32 flags)
 #ifndef NO_MATHOMS
 PERL_CALLCONV HV*      Perl_newHV(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWHV
 #endif
 
 PERL_CALLCONV OP*      Perl_newHVREF(pTHX_ OP* o)
@@ -2405,14 +2658,17 @@ PERL_CALLCONV OP*       Perl_newHVREF(pTHX_ OP* o)
 
 PERL_CALLCONV HV*      Perl_newHVhv(pTHX_ HV *hv)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWHVHV
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV IO*      Perl_newIO(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWIO
 #endif
 
 PERL_CALLCONV OP*      Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP* first, OP* last)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWLISTOP
 
 PERL_CALLCONV OP*      Perl_newLOGOP(pTHX_ I32 optype, I32 flags, OP *first, OP *other)
                        __attribute__warn_unused_result__;
@@ -2426,6 +2682,7 @@ PERL_CALLCONV OP* Perl_newLOOPEX(pTHX_ I32 type, OP* label)
 
 PERL_CALLCONV OP*      Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP* expr, OP* block)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWLOOPOP
 
 PERL_CALLCONV OP*      Perl_newMETHOP(pTHX_ I32 type, I32 flags, OP* dynamic_meth)
                        __attribute__warn_unused_result__;
@@ -2442,12 +2699,15 @@ PERL_CALLCONV CV *      Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, O
        assert(o)
 PERL_CALLCONV OP*      Perl_newNULLLIST(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWNULLLIST
 
 PERL_CALLCONV OP*      Perl_newOP(pTHX_ I32 optype, I32 flags)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWOP
 
 PERL_CALLCONV PADNAMELIST *    Perl_newPADNAMELIST(size_t max)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWPADNAMELIST
 
 PERL_CALLCONV PADNAME *        Perl_newPADNAMEouter(PADNAME *outer)
                        __attribute__warn_unused_result__;
@@ -2461,12 +2721,14 @@ PERL_CALLCONV PADNAME * Perl_newPADNAMEpvn(const char *s, STRLEN len)
 
 PERL_CALLCONV OP*      Perl_newPMOP(pTHX_ I32 type, I32 flags)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWPMOP
 
 PERL_CALLCONV void     Perl_newPROG(pTHX_ OP* o);
 #define PERL_ARGS_ASSERT_NEWPROG       \
        assert(o)
 PERL_CALLCONV OP*      Perl_newPVOP(pTHX_ I32 type, I32 flags, char* pv)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWPVOP
 
 PERL_CALLCONV OP*      Perl_newRANGE(pTHX_ I32 flags, OP* left, OP* right)
                        __attribute__warn_unused_result__;
@@ -2485,18 +2747,22 @@ PERL_CALLCONV SV*       Perl_newRV_noinc(pTHX_ SV *const tmpRef)
 
 PERL_CALLCONV OP*      Perl_newSLICEOP(pTHX_ I32 flags, OP* subscript, OP* listop)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWSLICEOP
 
 PERL_CALLCONV OP*      Perl_newSTATEOP(pTHX_ I32 flags, char* label, OP* o)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWSTATEOP
 
 PERL_CALLCONV CV*      Perl_newSTUB(pTHX_ GV *gv, bool fake);
 #define PERL_ARGS_ASSERT_NEWSTUB       \
        assert(gv)
 #ifndef NO_MATHOMS
 PERL_CALLCONV CV*      Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block);
+#define PERL_ARGS_ASSERT_NEWSUB
 #endif
 PERL_CALLCONV SV*      Perl_newSV(pTHX_ const STRLEN len)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWSV
 
 PERL_CALLCONV OP*      Perl_newSVOP(pTHX_ I32 type, I32 flags, SV* sv)
                        __attribute__warn_unused_result__;
@@ -2510,6 +2776,7 @@ PERL_CALLCONV OP* Perl_newSVREF(pTHX_ OP* o)
 
 PERL_CALLCONV SV*      Perl_newSV_type(pTHX_ const svtype type)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWSV_TYPE
 
 PERL_CALLCONV SV*      Perl_newSVavdefelem(pTHX_ AV *av, SSize_t ix, bool extendible)
                        __attribute__warn_unused_result__;
@@ -2518,18 +2785,23 @@ PERL_CALLCONV SV*       Perl_newSVavdefelem(pTHX_ AV *av, SSize_t ix, bool extendible)
 
 PERL_CALLCONV SV*      Perl_newSVhek(pTHX_ const HEK *const hek)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWSVHEK
 
 PERL_CALLCONV SV*      Perl_newSViv(pTHX_ const IV i)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWSVIV
 
 PERL_CALLCONV SV*      Perl_newSVnv(pTHX_ const NV n)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWSVNV
 
 PERL_CALLCONV SV*      Perl_newSVpv(pTHX_ const char *const s, const STRLEN len)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWSVPV
 
 PERL_CALLCONV SV*      Perl_newSVpv_share(pTHX_ const char* s, U32 hash)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWSVPV_SHARE
 
 PERL_CALLCONV SV*      Perl_newSVpvf(pTHX_ const char *const pat, ...)
                        __attribute__warn_unused_result__
@@ -2539,12 +2811,15 @@ PERL_CALLCONV SV*       Perl_newSVpvf(pTHX_ const char *const pat, ...)
 
 PERL_CALLCONV SV*      Perl_newSVpvn(pTHX_ const char *const buffer, const STRLEN len)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWSVPVN
 
 PERL_CALLCONV SV*      Perl_newSVpvn_flags(pTHX_ const char *const s, const STRLEN len, const U32 flags)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWSVPVN_FLAGS
 
 PERL_CALLCONV SV*      Perl_newSVpvn_share(pTHX_ const char* s, I32 len, U32 hash)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWSVPVN_SHARE
 
 PERL_CALLCONV SV*      Perl_newSVrv(pTHX_ SV *const rv, const char *const classname);
 #define PERL_ARGS_ASSERT_NEWSVRV       \
@@ -2552,22 +2827,28 @@ PERL_CALLCONV SV*       Perl_newSVrv(pTHX_ SV *const rv, const char *const classname);
 #ifndef NO_MATHOMS
 PERL_CALLCONV SV*      Perl_newSVsv(pTHX_ SV *const old)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWSVSV
 #endif
 
 PERL_CALLCONV SV*      Perl_newSVsv_flags(pTHX_ SV *const old, I32 flags)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWSVSV_FLAGS
 
 /* PERL_CALLCONV SV*   newSVsv_nomg(pTHX_ SV *const old)
                        __attribute__warn_unused_result__; */
+#define PERL_ARGS_ASSERT_NEWSVSV_NOMG
 
 PERL_CALLCONV SV*      Perl_newSVuv(pTHX_ const UV u)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWSVUV
 
 PERL_CALLCONV OP*      Perl_newUNOP(pTHX_ I32 type, I32 flags, OP* first)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWUNOP
 
 PERL_CALLCONV OP*      Perl_newUNOP_AUX(pTHX_ I32 type, I32 flags, OP* first, UNOP_AUX_item *aux)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWUNOP_AUX
 
 PERL_CALLCONV OP*      Perl_newWHENOP(pTHX_ OP* cond, OP* block)
                        __attribute__warn_unused_result__;
@@ -2576,6 +2857,7 @@ PERL_CALLCONV OP* Perl_newWHENOP(pTHX_ OP* cond, OP* block)
 
 PERL_CALLCONV OP*      Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP* loop, OP* expr, OP* block, OP* cont, I32 has_my)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEWWHILEOP
 
 PERL_CALLCONV CV*      Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename);
 #define PERL_ARGS_ASSERT_NEWXS \
@@ -2591,6 +2873,7 @@ PERL_CALLCONV CV *        Perl_newXS_len_flags(pTHX_ const char *name, STRLEN len, XSUB
        assert(subaddr)
 PERL_CALLCONV PERL_SI* Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEW_STACKINFO
 
 PERL_CALLCONV SV*      Perl_new_version(pTHX_ SV *ver);
 #define PERL_ARGS_ASSERT_NEW_VERSION   \
@@ -2616,7 +2899,9 @@ PERL_CALLCONV_NO_RET void Perl_noperl_die(const char* pat, ...)
        assert(pat)
 
 PERL_CALLCONV int      Perl_nothreadhook(pTHX);
+#define PERL_ARGS_ASSERT_NOTHREADHOOK
 PERL_CALLCONV void     Perl_notify_parser_that_changed_to_utf8(pTHX);
+#define PERL_ARGS_ASSERT_NOTIFY_PARSER_THAT_CHANGED_TO_UTF8
 PERL_CALLCONV OP*      Perl_oopsAV(pTHX_ OP* o)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_OOPSAV        \
@@ -2628,8 +2913,11 @@ PERL_CALLCONV OP*        Perl_oopsHV(pTHX_ OP* o)
        assert(o)
 
 PERL_CALLCONV OP*      Perl_op_append_elem(pTHX_ I32 optype, OP* first, OP* last);
+#define PERL_ARGS_ASSERT_OP_APPEND_ELEM
 PERL_CALLCONV OP*      Perl_op_append_list(pTHX_ I32 optype, OP* first, OP* last);
+#define PERL_ARGS_ASSERT_OP_APPEND_LIST
 PERL_CALLCONV OPclass  Perl_op_class(pTHX_ const OP *o);
+#define PERL_ARGS_ASSERT_OP_CLASS
 PERL_CALLCONV void     Perl_op_clear(pTHX_ OP* o);
 #define PERL_ARGS_ASSERT_OP_CLEAR      \
        assert(o)
@@ -2638,16 +2926,20 @@ PERL_CALLCONV OP*       Perl_op_contextualize(pTHX_ OP* o, I32 context);
        assert(o)
 PERL_CALLCONV OP*      Perl_op_convert_list(pTHX_ I32 optype, I32 flags, OP* o)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_OP_CONVERT_LIST
 
 PERL_CALLCONV void     Perl_op_dump(pTHX_ const OP *o);
 #define PERL_ARGS_ASSERT_OP_DUMP       \
        assert(o)
 PERL_CALLCONV void     Perl_op_free(pTHX_ OP* arg);
+#define PERL_ARGS_ASSERT_OP_FREE
 PERL_CALLCONV OP*      Perl_op_linklist(pTHX_ OP *o);
 #define PERL_ARGS_ASSERT_OP_LINKLIST   \
        assert(o)
 /* PERL_CALLCONV OP*   op_lvalue(pTHX_ OP* o, I32 type); */
+#define PERL_ARGS_ASSERT_OP_LVALUE
 PERL_CALLCONV OP*      Perl_op_lvalue_flags(pTHX_ OP* o, I32 type, U32 flags);
+#define PERL_ARGS_ASSERT_OP_LVALUE_FLAGS
 PERL_CALLCONV void     Perl_op_null(pTHX_ OP* o);
 #define PERL_ARGS_ASSERT_OP_NULL       \
        assert(o)
@@ -2655,11 +2947,17 @@ PERL_CALLCONV OP*       Perl_op_parent(OP *o);
 #define PERL_ARGS_ASSERT_OP_PARENT     \
        assert(o)
 PERL_CALLCONV OP*      Perl_op_prepend_elem(pTHX_ I32 optype, OP* first, OP* last);
+#define PERL_ARGS_ASSERT_OP_PREPEND_ELEM
 PERL_CALLCONV void     Perl_op_refcnt_lock(pTHX);
+#define PERL_ARGS_ASSERT_OP_REFCNT_LOCK
 PERL_CALLCONV void     Perl_op_refcnt_unlock(pTHX);
+#define PERL_ARGS_ASSERT_OP_REFCNT_UNLOCK
 PERL_CALLCONV OP*      Perl_op_scope(pTHX_ OP* o);
+#define PERL_ARGS_ASSERT_OP_SCOPE
 PERL_CALLCONV OP*      Perl_op_sibling_splice(OP *parent, OP *start, int del_count, OP* insert);
+#define PERL_ARGS_ASSERT_OP_SIBLING_SPLICE
 PERL_CALLCONV OP*      Perl_op_unscope(pTHX_ OP* o);
+#define PERL_ARGS_ASSERT_OP_UNSCOPE
 PERL_CALLCONV void     Perl_optimize_optree(pTHX_ OP* o);
 #define PERL_ARGS_ASSERT_OPTIMIZE_OPTREE       \
        assert(o)
@@ -2693,10 +2991,13 @@ PERL_CALLCONV void      Perl_pad_add_weakref(pTHX_ CV* func);
 #define PERL_ARGS_ASSERT_PAD_ADD_WEAKREF       \
        assert(func)
 PERL_CALLCONV PADOFFSET        Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype);
+#define PERL_ARGS_ASSERT_PAD_ALLOC
 PERL_CALLCONV void     Perl_pad_block_start(pTHX_ int full);
+#define PERL_ARGS_ASSERT_PAD_BLOCK_START
 #ifndef NO_MATHOMS
 PERL_CALLCONV HV*      Perl_pad_compname_type(pTHX_ const PADOFFSET po)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_PAD_COMPNAME_TYPE
 #endif
 
 PERL_CALLCONV PADOFFSET        Perl_pad_findmy_pv(pTHX_ const char* name, U32 flags);
@@ -2712,15 +3013,20 @@ PERL_CALLCONV void      Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv
 #define PERL_ARGS_ASSERT_PAD_FIXUP_INNER_ANONS \
        assert(padlist); assert(old_cv); assert(new_cv)
 PERL_CALLCONV void     Perl_pad_free(pTHX_ PADOFFSET po);
+#define PERL_ARGS_ASSERT_PAD_FREE
 PERL_CALLCONV OP *     Perl_pad_leavemy(pTHX);
+#define PERL_ARGS_ASSERT_PAD_LEAVEMY
 PERL_CALLCONV PADLIST* Perl_pad_new(pTHX_ int flags)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_PAD_NEW
 
 PERL_CALLCONV void     Perl_pad_push(pTHX_ PADLIST *padlist, int depth);
 #define PERL_ARGS_ASSERT_PAD_PUSH      \
        assert(padlist)
 PERL_CALLCONV void     Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust);
+#define PERL_ARGS_ASSERT_PAD_SWIPE
 PERL_CALLCONV void     Perl_pad_tidy(pTHX_ padtidy_type type);
+#define PERL_ARGS_ASSERT_PAD_TIDY
 PERL_CALLCONV PAD **   Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val);
 #define PERL_ARGS_ASSERT_PADLIST_STORE \
        assert(padlist)
@@ -2739,15 +3045,25 @@ PERL_CALLCONV PADNAME **        Perl_padnamelist_store(pTHX_ PADNAMELIST *pnl, SSize_t
 #define PERL_ARGS_ASSERT_PADNAMELIST_STORE     \
        assert(pnl)
 PERL_CALLCONV OP*      Perl_parse_arithexpr(pTHX_ U32 flags);
+#define PERL_ARGS_ASSERT_PARSE_ARITHEXPR
 PERL_CALLCONV OP*      Perl_parse_barestmt(pTHX_ U32 flags);
+#define PERL_ARGS_ASSERT_PARSE_BARESTMT
 PERL_CALLCONV OP*      Perl_parse_block(pTHX_ U32 flags);
+#define PERL_ARGS_ASSERT_PARSE_BLOCK
 PERL_CALLCONV OP*      Perl_parse_fullexpr(pTHX_ U32 flags);
+#define PERL_ARGS_ASSERT_PARSE_FULLEXPR
 PERL_CALLCONV OP*      Perl_parse_fullstmt(pTHX_ U32 flags);
+#define PERL_ARGS_ASSERT_PARSE_FULLSTMT
 PERL_CALLCONV SV*      Perl_parse_label(pTHX_ U32 flags);
+#define PERL_ARGS_ASSERT_PARSE_LABEL
 PERL_CALLCONV OP*      Perl_parse_listexpr(pTHX_ U32 flags);
+#define PERL_ARGS_ASSERT_PARSE_LISTEXPR
 PERL_CALLCONV OP*      Perl_parse_stmtseq(pTHX_ U32 flags);
+#define PERL_ARGS_ASSERT_PARSE_STMTSEQ
 PERL_CALLCONV OP*      Perl_parse_subsignature(pTHX_ U32 flags);
+#define PERL_ARGS_ASSERT_PARSE_SUBSIGNATURE
 PERL_CALLCONV OP*      Perl_parse_termexpr(pTHX_ U32 flags);
+#define PERL_ARGS_ASSERT_PARSE_TERMEXPR
 PERL_CALLCONV U32      Perl_parse_unicode_opts(pTHX_ const char **popt);
 #define PERL_ARGS_ASSERT_PARSE_UNICODE_OPTS    \
        assert(popt)
@@ -2755,7 +3071,9 @@ PERL_CALLCONV void        Perl_parser_free(pTHX_ const yy_parser *parser);
 #define PERL_ARGS_ASSERT_PARSER_FREE   \
        assert(parser)
 PERL_CALLCONV void     Perl_peep(pTHX_ OP* o);
+#define PERL_ARGS_ASSERT_PEEP
 PERL_CALLCONV PerlInterpreter* perl_alloc(void);
+#define PERL_ARGS_ASSERT_PERL_ALLOC
 PERL_CALLCONV void     perl_construct(PerlInterpreter *my_perl);
 #define PERL_ARGS_ASSERT_PERL_CONSTRUCT        \
        assert(my_perl)
@@ -2772,10 +3090,12 @@ PERL_CALLCONV int       perl_run(PerlInterpreter *my_perl);
 #define PERL_ARGS_ASSERT_PERL_RUN      \
        assert(my_perl)
 PERL_CALLCONV void     Perl_pmop_dump(pTHX_ PMOP* pm);
+#define PERL_ARGS_ASSERT_PMOP_DUMP
 PERL_CALLCONV OP*      Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl, UV flags, I32 floor);
 #define PERL_ARGS_ASSERT_PMRUNTIME     \
        assert(o); assert(expr)
 PERL_CALLCONV void     Perl_pop_scope(pTHX);
+#define PERL_ARGS_ASSERT_POP_SCOPE
 PERL_CALLCONV void     Perl_populate_isa(pTHX_ const char *name, STRLEN len, ...);
 #define PERL_ARGS_ASSERT_POPULATE_ISA  \
        assert(name)
@@ -2786,6 +3106,7 @@ PERL_CALLCONV I32 Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, char
 #define PERL_ARGS_ASSERT_PREGEXEC      \
        assert(prog); assert(stringarg); assert(strend); assert(strbeg); assert(screamer)
 PERL_CALLCONV void     Perl_pregfree(pTHX_ REGEXP* r);
+#define PERL_ARGS_ASSERT_PREGFREE
 PERL_CALLCONV void     Perl_pregfree2(pTHX_ REGEXP *rx);
 #define PERL_ARGS_ASSERT_PREGFREE2     \
        assert(rx)
@@ -2794,6 +3115,7 @@ PERL_CALLCONV const char* Perl_prescan_version(pTHX_ const char *s, bool strict,
        assert(s)
 PERL_CALLCONV void     Perl_ptr_table_clear(pTHX_ PTR_TBL_t *const tbl)
                        __attribute__deprecated__;
+#define PERL_ARGS_ASSERT_PTR_TABLE_CLEAR
 
 PERL_CALLCONV void*    Perl_ptr_table_fetch(pTHX_ PTR_TBL_t *const tbl, const void *const sv)
                        __attribute__warn_unused_result__;
@@ -2801,8 +3123,10 @@ PERL_CALLCONV void*      Perl_ptr_table_fetch(pTHX_ PTR_TBL_t *const tbl, const void
        assert(tbl)
 
 PERL_CALLCONV void     Perl_ptr_table_free(pTHX_ PTR_TBL_t *const tbl);
+#define PERL_ARGS_ASSERT_PTR_TABLE_FREE
 PERL_CALLCONV PTR_TBL_t*       Perl_ptr_table_new(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_PTR_TABLE_NEW
 
 PERL_CALLCONV void     Perl_ptr_table_split(pTHX_ PTR_TBL_t *const tbl);
 #define PERL_ARGS_ASSERT_PTR_TABLE_SPLIT       \
@@ -2811,6 +3135,7 @@ PERL_CALLCONV void        Perl_ptr_table_store(pTHX_ PTR_TBL_t *const tbl, const void *
 #define PERL_ARGS_ASSERT_PTR_TABLE_STORE       \
        assert(tbl); assert(newsv)
 PERL_CALLCONV void     Perl_push_scope(pTHX);
+#define PERL_ARGS_ASSERT_PUSH_SCOPE
 PERL_CALLCONV char*    Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim);
 #define PERL_ARGS_ASSERT_PV_DISPLAY    \
        assert(dsv); assert(pv)
@@ -2840,14 +3165,19 @@ PERL_CALLCONV REGEXP*   Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_cou
        assert(eng)
 PERL_CALLCONV Malloc_t Perl_realloc(Malloc_t where, MEM_SIZE nbytes)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_REALLOC
 
 PERL_CALLCONV void     Perl_reentrant_free(pTHX);
+#define PERL_ARGS_ASSERT_REENTRANT_FREE
 PERL_CALLCONV void     Perl_reentrant_init(pTHX);
+#define PERL_ARGS_ASSERT_REENTRANT_INIT
 PERL_CALLCONV void*    Perl_reentrant_retry(const char *f, ...);
 #define PERL_ARGS_ASSERT_REENTRANT_RETRY       \
        assert(f)
 PERL_CALLCONV void     Perl_reentrant_size(pTHX);
+#define PERL_ARGS_ASSERT_REENTRANT_SIZE
 PERL_CALLCONV HV *     Perl_refcounted_he_chain_2hv(pTHX_ const struct refcounted_he *c, U32 flags);
+#define PERL_ARGS_ASSERT_REFCOUNTED_HE_CHAIN_2HV
 PERL_CALLCONV SV *     Perl_refcounted_he_fetch_pv(pTHX_ const struct refcounted_he *chain, const char *key, U32 hash, U32 flags);
 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PV        \
        assert(key)
@@ -2858,7 +3188,9 @@ PERL_CALLCONV SV *        Perl_refcounted_he_fetch_sv(pTHX_ const struct refcounted_he
 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_SV        \
        assert(key)
 PERL_CALLCONV void     Perl_refcounted_he_free(pTHX_ struct refcounted_he *he);
+#define PERL_ARGS_ASSERT_REFCOUNTED_HE_FREE
 PERL_CALLCONV struct refcounted_he *   Perl_refcounted_he_inc(pTHX_ struct refcounted_he *he);
+#define PERL_ARGS_ASSERT_REFCOUNTED_HE_INC
 PERL_CALLCONV struct refcounted_he *   Perl_refcounted_he_new_pv(pTHX_ struct refcounted_he *parent, const char *key, U32 hash, SV *value, U32 flags);
 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PV  \
        assert(key)
@@ -2917,15 +3249,20 @@ PERL_CALLCONV void      Perl_regfree_internal(pTHX_ REGEXP *const rx);
 #define PERL_ARGS_ASSERT_REGFREE_INTERNAL      \
        assert(rx)
 PERL_CALLCONV void     Perl_reginitcolors(pTHX);
+#define PERL_ARGS_ASSERT_REGINITCOLORS
 PERL_CALLCONV regnode* Perl_regnext(pTHX_ regnode* p)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_REGNEXT
 
 PERL_CALLCONV void     Perl_repeatcpy(char* to, const char* from, I32 len, IV count);
 #define PERL_ARGS_ASSERT_REPEATCPY     \
        assert(to); assert(from)
 PERL_CALLCONV void     Perl_report_evil_fh(pTHX_ const GV *gv);
+#define PERL_ARGS_ASSERT_REPORT_EVIL_FH
 PERL_CALLCONV void     Perl_report_uninit(pTHX_ const SV *uninit_sv);
+#define PERL_ARGS_ASSERT_REPORT_UNINIT
 PERL_CALLCONV void     Perl_report_wrongway_fh(pTHX_ const GV *gv, const char have);
+#define PERL_ARGS_ASSERT_REPORT_WRONGWAY_FH
 PERL_CALLCONV void     Perl_require_pv(pTHX_ const char* pv);
 #define PERL_ARGS_ASSERT_REQUIRE_PV    \
        assert(pv)
@@ -2936,14 +3273,20 @@ PERL_CALLCONV char*     Perl_rninstr(const char* big, const char* bigend, const char
        assert(big); assert(bigend); assert(little); assert(lend)
 
 PERL_CALLCONV void     Perl_rpeep(pTHX_ OP* o);
+#define PERL_ARGS_ASSERT_RPEEP
 PERL_CALLCONV Sighandler_t     Perl_rsignal(pTHX_ int i, Sighandler_t t);
+#define PERL_ARGS_ASSERT_RSIGNAL
 PERL_CALLCONV int      Perl_rsignal_restore(pTHX_ int i, Sigsave_t* t);
+#define PERL_ARGS_ASSERT_RSIGNAL_RESTORE
 PERL_CALLCONV int      Perl_rsignal_save(pTHX_ int i, Sighandler_t t1, Sigsave_t* save);
 #define PERL_ARGS_ASSERT_RSIGNAL_SAVE  \
        assert(save)
 PERL_CALLCONV Sighandler_t     Perl_rsignal_state(pTHX_ int i);
+#define PERL_ARGS_ASSERT_RSIGNAL_STATE
 PERL_CALLCONV int      Perl_runops_debug(pTHX);
+#define PERL_ARGS_ASSERT_RUNOPS_DEBUG
 PERL_CALLCONV int      Perl_runops_standard(pTHX);
+#define PERL_ARGS_ASSERT_RUNOPS_STANDARD
 PERL_CALLCONV CV*      Perl_rv2cv_op_cv(pTHX_ OP *cvop, U32 flags);
 #define PERL_ARGS_ASSERT_RV2CV_OP_CV   \
        assert(cvop)
@@ -2953,14 +3296,18 @@ PERL_CALLCONV void      Perl_rxres_save(pTHX_ void **rsp, REGEXP *rx);
 PERL_CALLCONV Malloc_t Perl_safesyscalloc(MEM_SIZE elements, MEM_SIZE size)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SAFESYSCALLOC
 
 PERL_CALLCONV Free_t   Perl_safesysfree(Malloc_t where);
+#define PERL_ARGS_ASSERT_SAFESYSFREE
 PERL_CALLCONV Malloc_t Perl_safesysmalloc(MEM_SIZE nbytes)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SAFESYSMALLOC
 
 PERL_CALLCONV Malloc_t Perl_safesysrealloc(Malloc_t where, MEM_SIZE nbytes)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SAFESYSREALLOC
 
 PERL_CALLCONV void     Perl_save_I16(pTHX_ I16* intp);
 #define PERL_ARGS_ASSERT_SAVE_I16      \
@@ -2974,11 +3321,13 @@ PERL_CALLCONV void      Perl_save_I8(pTHX_ I8* bytep);
 PERL_CALLCONV void     Perl_save_adelete(pTHX_ AV *av, SSize_t key);
 #define PERL_ARGS_ASSERT_SAVE_ADELETE  \
        assert(av)
-/* PERL_CALLCONV void  Perl_save_aelem(pTHX_ AV* av, SSize_t idx, SV **sptr); */
+/* PERL_CALLCONV void  save_aelem(pTHX_ AV* av, SSize_t idx, SV **sptr); */
+#define PERL_ARGS_ASSERT_SAVE_AELEM
 PERL_CALLCONV void     Perl_save_aelem_flags(pTHX_ AV* av, SSize_t idx, SV **sptr, const U32 flags);
 #define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS      \
        assert(av); assert(sptr)
 PERL_CALLCONV I32      Perl_save_alloc(pTHX_ I32 size, I32 pad);
+#define PERL_ARGS_ASSERT_SAVE_ALLOC
 PERL_CALLCONV void     Perl_save_aptr(pTHX_ AV** aptr);
 #define PERL_ARGS_ASSERT_SAVE_APTR     \
        assert(aptr)
@@ -2998,14 +3347,18 @@ PERL_CALLCONV void      Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void
 #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR       \
        assert(p)
 PERL_CALLCONV void     Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void* p);
+#define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR_X
 #ifndef NO_MATHOMS
 PERL_CALLCONV void     Perl_save_freeop(pTHX_ OP* o);
+#define PERL_ARGS_ASSERT_SAVE_FREEOP
 #endif
 #ifndef NO_MATHOMS
 PERL_CALLCONV void     Perl_save_freepv(pTHX_ char* pv);
+#define PERL_ARGS_ASSERT_SAVE_FREEPV
 #endif
 #ifndef NO_MATHOMS
 PERL_CALLCONV void     Perl_save_freesv(pTHX_ SV* sv);
+#define PERL_ARGS_ASSERT_SAVE_FREESV
 #endif
 PERL_CALLCONV void     Perl_save_generic_pvref(pTHX_ char** str);
 #define PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF    \
@@ -3022,11 +3375,13 @@ PERL_CALLCONV HV*       Perl_save_hash(pTHX_ GV* gv);
 PERL_CALLCONV void     Perl_save_hdelete(pTHX_ HV *hv, SV *keysv);
 #define PERL_ARGS_ASSERT_SAVE_HDELETE  \
        assert(hv); assert(keysv)
-/* PERL_CALLCONV void  Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr); */
+/* PERL_CALLCONV void  save_helem(pTHX_ HV *hv, SV *key, SV **sptr); */
+#define PERL_ARGS_ASSERT_SAVE_HELEM
 PERL_CALLCONV void     Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags);
 #define PERL_ARGS_ASSERT_SAVE_HELEM_FLAGS      \
        assert(hv); assert(key); assert(sptr)
 PERL_CALLCONV void     Perl_save_hints(pTHX);
+#define PERL_ARGS_ASSERT_SAVE_HINTS
 PERL_CALLCONV void     Perl_save_hptr(pTHX_ HV** hptr);
 #define PERL_ARGS_ASSERT_SAVE_HPTR     \
        assert(hptr)
@@ -3067,15 +3422,21 @@ PERL_CALLCONV void      Perl_save_nogv(pTHX_ GV* gv)
 
 #ifndef NO_MATHOMS
 PERL_CALLCONV void     Perl_save_op(pTHX);
+#define PERL_ARGS_ASSERT_SAVE_OP
 #endif
 PERL_CALLCONV void     Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off);
+#define PERL_ARGS_ASSERT_SAVE_PADSV_AND_MORTALIZE
 PERL_CALLCONV void     Perl_save_pptr(pTHX_ char** pptr);
 #define PERL_ARGS_ASSERT_SAVE_PPTR     \
        assert(pptr)
 PERL_CALLCONV void     Perl_save_pushi32ptr(pTHX_ const I32 i, void *const ptr, const int type);
+#define PERL_ARGS_ASSERT_SAVE_PUSHI32PTR
 PERL_CALLCONV void     Perl_save_pushptr(pTHX_ void *const ptr, const int type);
+#define PERL_ARGS_ASSERT_SAVE_PUSHPTR
 PERL_CALLCONV void     Perl_save_pushptrptr(pTHX_ void *const ptr1, void *const ptr2, const int type);
+#define PERL_ARGS_ASSERT_SAVE_PUSHPTRPTR
 PERL_CALLCONV void     Perl_save_re_context(pTHX);
+#define PERL_ARGS_ASSERT_SAVE_RE_CONTEXT
 PERL_CALLCONV SV*      Perl_save_scalar(pTHX_ GV* gv);
 #define PERL_ARGS_ASSERT_SAVE_SCALAR   \
        assert(gv)
@@ -3100,18 +3461,22 @@ PERL_CALLCONV void      Perl_save_vptr(pTHX_ void *ptr);
 PERL_CALLCONV char*    Perl_savepv(pTHX_ const char* pv)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SAVEPV
 
 PERL_CALLCONV char*    Perl_savepvn(pTHX_ const char* pv, I32 len)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SAVEPVN
 
 PERL_CALLCONV char*    Perl_savesharedpv(pTHX_ const char* pv)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SAVESHAREDPV
 
 PERL_CALLCONV char*    Perl_savesharedpvn(pTHX_ const char *const pv, const STRLEN len)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SAVESHAREDPVN
 
 PERL_CALLCONV char*    Perl_savesharedsvpv(pTHX_ SV *sv)
                        __attribute__malloc__
@@ -3120,7 +3485,9 @@ PERL_CALLCONV char*       Perl_savesharedsvpv(pTHX_ SV *sv)
        assert(sv)
 
 PERL_CALLCONV void     Perl_savestack_grow(pTHX);
+#define PERL_ARGS_ASSERT_SAVESTACK_GROW
 PERL_CALLCONV void     Perl_savestack_grow_cnt(pTHX_ I32 need);
+#define PERL_ARGS_ASSERT_SAVESTACK_GROW_CNT
 PERL_CALLCONV char*    Perl_savesvpv(pTHX_ SV* sv)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
@@ -3128,8 +3495,11 @@ PERL_CALLCONV char*      Perl_savesvpv(pTHX_ SV* sv)
        assert(sv)
 
 PERL_CALLCONV void     Perl_savetmps(pTHX);
+#define PERL_ARGS_ASSERT_SAVETMPS
 PERL_CALLCONV OP*      Perl_sawparens(pTHX_ OP* o);
+#define PERL_ARGS_ASSERT_SAWPARENS
 PERL_CALLCONV OP*      Perl_scalar(pTHX_ OP* o);
+#define PERL_ARGS_ASSERT_SCALAR
 PERL_CALLCONV OP*      Perl_scalarvoid(pTHX_ OP* o);
 #define PERL_ARGS_ASSERT_SCALARVOID    \
        assert(o)
@@ -3160,20 +3530,29 @@ PERL_CALLCONV char*     Perl_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, in
 #define PERL_ARGS_ASSERT_SCAN_WORD     \
        assert(s); assert(dest); assert(slp)
 PERL_CALLCONV U32      Perl_seed(pTHX);
+#define PERL_ARGS_ASSERT_SEED
 PERL_CALLCONV void     Perl_set_caret_X(pTHX);
+#define PERL_ARGS_ASSERT_SET_CARET_X
 PERL_CALLCONV void     Perl_set_context(void *t);
 #define PERL_ARGS_ASSERT_SET_CONTEXT   \
        assert(t)
 PERL_CALLCONV void     Perl_set_numeric_standard(pTHX);
+#define PERL_ARGS_ASSERT_SET_NUMERIC_STANDARD
 PERL_CALLCONV void     Perl_set_numeric_underlying(pTHX);
+#define PERL_ARGS_ASSERT_SET_NUMERIC_UNDERLYING
 PERL_CALLCONV void     Perl_setdefout(pTHX_ GV* gv);
 #define PERL_ARGS_ASSERT_SETDEFOUT     \
        assert(gv)
 PERL_CALLCONV void     Perl_setfd_cloexec(int fd);
+#define PERL_ARGS_ASSERT_SETFD_CLOEXEC
 PERL_CALLCONV void     Perl_setfd_cloexec_for_nonsysfd(pTHX_ int fd);
+#define PERL_ARGS_ASSERT_SETFD_CLOEXEC_FOR_NONSYSFD
 PERL_CALLCONV void     Perl_setfd_cloexec_or_inhexec_by_sysfdness(pTHX_ int fd);
+#define PERL_ARGS_ASSERT_SETFD_CLOEXEC_OR_INHEXEC_BY_SYSFDNESS
 PERL_CALLCONV void     Perl_setfd_inhexec(int fd);
+#define PERL_ARGS_ASSERT_SETFD_INHEXEC
 PERL_CALLCONV void     Perl_setfd_inhexec_for_sysfd(pTHX_ int fd);
+#define PERL_ARGS_ASSERT_SETFD_INHEXEC_FOR_SYSFD
 PERL_CALLCONV HEK*     Perl_share_hek(pTHX_ const char* str, SSize_t len, U32 hash);
 #define PERL_ARGS_ASSERT_SHARE_HEK     \
        assert(str)
@@ -3195,6 +3574,7 @@ PERL_CALLCONV PerlIO*     Perl_start_glob(pTHX_ SV *tmpglob, IO *io);
 #define PERL_ARGS_ASSERT_START_GLOB    \
        assert(tmpglob); assert(io)
 PERL_CALLCONV I32      Perl_start_subparse(pTHX_ I32 is_format, U32 flags);
+#define PERL_ARGS_ASSERT_START_SUBPARSE
 PERL_CALLCONV NV       Perl_str_to_version(pTHX_ SV *sv)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_STR_TO_VERSION        \
@@ -3226,6 +3606,7 @@ PERL_CALLCONV IV  Perl_sv_2iv_flags(pTHX_ SV *const sv, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_2IV_FLAGS  \
        assert(sv)
 PERL_CALLCONV SV*      Perl_sv_2mortal(pTHX_ SV *const sv);
+#define PERL_ARGS_ASSERT_SV_2MORTAL
 PERL_CALLCONV SV*      Perl_sv_2num(pTHX_ SV *const sv);
 #define PERL_ARGS_ASSERT_SV_2NUM       \
        assert(sv)
@@ -3343,14 +3724,20 @@ PERL_CALLCONV void      Perl_sv_chop(pTHX_ SV *const sv, const char *const ptr);
 #define PERL_ARGS_ASSERT_SV_CHOP       \
        assert(sv)
 PERL_CALLCONV I32      Perl_sv_clean_all(pTHX);
+#define PERL_ARGS_ASSERT_SV_CLEAN_ALL
 PERL_CALLCONV void     Perl_sv_clean_objs(pTHX);
+#define PERL_ARGS_ASSERT_SV_CLEAN_OBJS
 PERL_CALLCONV void     Perl_sv_clear(pTHX_ SV *const orig_sv);
 #define PERL_ARGS_ASSERT_SV_CLEAR      \
        assert(orig_sv)
 PERL_CALLCONV I32      Perl_sv_cmp(pTHX_ SV *const sv1, SV *const sv2);
+#define PERL_ARGS_ASSERT_SV_CMP
 PERL_CALLCONV I32      Perl_sv_cmp_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags);
+#define PERL_ARGS_ASSERT_SV_CMP_FLAGS
 PERL_CALLCONV I32      Perl_sv_cmp_locale(pTHX_ SV *const sv1, SV *const sv2);
+#define PERL_ARGS_ASSERT_SV_CMP_LOCALE
 PERL_CALLCONV I32      Perl_sv_cmp_locale_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags);
+#define PERL_ARGS_ASSERT_SV_CMP_LOCALE_FLAGS
 #ifndef NO_MATHOMS
 PERL_CALLCONV void     Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv);
 #define PERL_ARGS_ASSERT_SV_COPYPV     \
@@ -3359,9 +3746,12 @@ PERL_CALLCONV void       Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv);
 PERL_CALLCONV void     Perl_sv_copypv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_COPYPV_FLAGS       \
        assert(dsv); assert(ssv)
-/* PERL_CALLCONV void  Perl_sv_copypv_nomg(pTHX_ SV *const dsv, SV *const ssv); */
+/* PERL_CALLCONV void  sv_copypv_nomg(pTHX_ SV *const dsv, SV *const ssv); */
+#define PERL_ARGS_ASSERT_SV_COPYPV_NOMG
 PERL_CALLCONV void     Perl_sv_dec(pTHX_ SV *const sv);
+#define PERL_ARGS_ASSERT_SV_DEC
 PERL_CALLCONV void     Perl_sv_dec_nomg(pTHX_ SV *const sv);
+#define PERL_ARGS_ASSERT_SV_DEC_NOMG
 PERL_CALLCONV void     Perl_sv_del_backref(pTHX_ SV *const tsv, SV *const sv);
 #define PERL_ARGS_ASSERT_SV_DEL_BACKREF        \
        assert(tsv); assert(sv)
@@ -3386,6 +3776,7 @@ PERL_CALLCONV bool        Perl_sv_derived_from_sv(pTHX_ SV* sv, SV *namesv, U32 flags)
        assert(sv); assert(namesv)
 
 PERL_CALLCONV bool     Perl_sv_destroyable(pTHX_ SV *sv);
+#define PERL_ARGS_ASSERT_SV_DESTROYABLE
 PERL_CALLCONV bool     Perl_sv_does(pTHX_ SV* sv, const char *const name)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SV_DOES       \
@@ -3407,10 +3798,13 @@ PERL_CALLCONV bool      Perl_sv_does_sv(pTHX_ SV* sv, SV* namesv, U32 flags)
        assert(sv); assert(namesv)
 
 PERL_CALLCONV void     Perl_sv_dump(pTHX_ SV* sv);
+#define PERL_ARGS_ASSERT_SV_DUMP
 #ifndef NO_MATHOMS
 PERL_CALLCONV I32      Perl_sv_eq(pTHX_ SV* sv1, SV* sv2);
+#define PERL_ARGS_ASSERT_SV_EQ
 #endif
 PERL_CALLCONV I32      Perl_sv_eq_flags(pTHX_ SV* sv1, SV* sv2, const U32 flags);
+#define PERL_ARGS_ASSERT_SV_EQ_FLAGS
 #ifndef NO_MATHOMS
 PERL_CALLCONV void     Perl_sv_force_normal(pTHX_ SV *sv);
 #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL       \
@@ -3420,10 +3814,12 @@ PERL_CALLCONV void      Perl_sv_force_normal_flags(pTHX_ SV *const sv, const U32 flag
 #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS \
        assert(sv)
 PERL_CALLCONV void     Perl_sv_free(pTHX_ SV *const sv);
+#define PERL_ARGS_ASSERT_SV_FREE
 PERL_CALLCONV void     Perl_sv_free2(pTHX_ SV *const sv, const U32 refcnt);
 #define PERL_ARGS_ASSERT_SV_FREE2      \
        assert(sv)
 PERL_CALLCONV void     Perl_sv_free_arenas(pTHX);
+#define PERL_ARGS_ASSERT_SV_FREE_ARENAS
 PERL_CALLCONV SV*      Perl_sv_get_backrefs(SV *const sv);
 #define PERL_ARGS_ASSERT_SV_GET_BACKREFS       \
        assert(sv)
@@ -3434,7 +3830,9 @@ PERL_CALLCONV char*       Perl_sv_grow(pTHX_ SV *const sv, STRLEN newlen);
 #define PERL_ARGS_ASSERT_SV_GROW       \
        assert(sv)
 PERL_CALLCONV void     Perl_sv_inc(pTHX_ SV *const sv);
+#define PERL_ARGS_ASSERT_SV_INC
 PERL_CALLCONV void     Perl_sv_inc_nomg(pTHX_ SV *const sv);
+#define PERL_ARGS_ASSERT_SV_INC_NOMG
 #ifndef NO_MATHOMS
 PERL_CALLCONV void     Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen);
 #define PERL_ARGS_ASSERT_SV_INSERT     \
@@ -3447,6 +3845,7 @@ PERL_CALLCONV int Perl_sv_isa(pTHX_ SV* sv, const char *const name);
 #define PERL_ARGS_ASSERT_SV_ISA        \
        assert(name)
 PERL_CALLCONV int      Perl_sv_isobject(pTHX_ SV* sv);
+#define PERL_ARGS_ASSERT_SV_ISOBJECT
 #ifndef NO_MATHOMS
 PERL_CALLCONV IV       Perl_sv_iv(pTHX_ SV* sv)
                        __attribute__deprecated__;
@@ -3455,7 +3854,9 @@ PERL_CALLCONV IV  Perl_sv_iv(pTHX_ SV* sv)
 #endif
 
 PERL_CALLCONV STRLEN   Perl_sv_len(pTHX_ SV *const sv);
+#define PERL_ARGS_ASSERT_SV_LEN
 PERL_CALLCONV STRLEN   Perl_sv_len_utf8(pTHX_ SV *const sv);
+#define PERL_ARGS_ASSERT_SV_LEN_UTF8
 PERL_CALLCONV STRLEN   Perl_sv_len_utf8_nomg(pTHX_ SV *const sv);
 #define PERL_ARGS_ASSERT_SV_LEN_UTF8_NOMG      \
        assert(sv)
@@ -3471,24 +3872,31 @@ PERL_CALLCONV MAGIC *   Perl_sv_magicext_mglob(pTHX_ SV *sv);
 #ifndef NO_MATHOMS
 PERL_CALLCONV SV*      Perl_sv_mortalcopy(pTHX_ SV *const oldsv)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SV_MORTALCOPY
 #endif
 
 PERL_CALLCONV SV*      Perl_sv_mortalcopy_flags(pTHX_ SV *const oldsv, U32 flags)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SV_MORTALCOPY_FLAGS
 
 PERL_CALLCONV SV*      Perl_sv_newmortal(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SV_NEWMORTAL
 
 PERL_CALLCONV SV*      Perl_sv_newref(pTHX_ SV *const sv);
+#define PERL_ARGS_ASSERT_SV_NEWREF
 #ifndef NO_MATHOMS
 PERL_CALLCONV void     Perl_sv_nolocking(pTHX_ SV *sv)
                        __attribute__deprecated__;
+#define PERL_ARGS_ASSERT_SV_NOLOCKING
 #endif
 
 PERL_CALLCONV void     Perl_sv_nosharing(pTHX_ SV *sv);
+#define PERL_ARGS_ASSERT_SV_NOSHARING
 #ifndef NO_MATHOMS
 PERL_CALLCONV void     Perl_sv_nounlocking(pTHX_ SV *sv)
                        __attribute__deprecated__;
+#define PERL_ARGS_ASSERT_SV_NOUNLOCKING
 #endif
 
 #ifndef NO_MATHOMS
@@ -3499,11 +3907,12 @@ PERL_CALLCONV NV        Perl_sv_nv(pTHX_ SV* sv)
 #endif
 
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE bool        S_sv_only_taint_gmagic(SV *sv);
+PERL_STATIC_INLINE bool        Perl_sv_only_taint_gmagic(SV *sv);
 #define PERL_ARGS_ASSERT_SV_ONLY_TAINT_GMAGIC  \
        assert(sv)
 #endif
 PERL_CALLCONV char*    Perl_sv_peek(pTHX_ SV* sv);
+#define PERL_ARGS_ASSERT_SV_PEEK
 PERL_CALLCONV void     Perl_sv_pos_b2u(pTHX_ SV *const sv, I32 *const offsetp);
 #define PERL_ARGS_ASSERT_SV_POS_B2U    \
        assert(offsetp)
@@ -3594,10 +4003,12 @@ PERL_CALLCONV void      Perl_sv_replace(pTHX_ SV *const sv, SV *const nsv);
 #define PERL_ARGS_ASSERT_SV_REPLACE    \
        assert(sv); assert(nsv)
 PERL_CALLCONV void     Perl_sv_report_used(pTHX);
+#define PERL_ARGS_ASSERT_SV_REPORT_USED
 PERL_CALLCONV void     Perl_sv_reset(pTHX_ const char* s, HV *const stash);
 #define PERL_ARGS_ASSERT_SV_RESET      \
        assert(s)
 PERL_CALLCONV void     Perl_sv_resetpvn(pTHX_ const char* s, STRLEN len, HV *const stash);
+#define PERL_ARGS_ASSERT_SV_RESETPVN
 PERL_CALLCONV SV*      Perl_sv_rvunweaken(pTHX_ SV *const sv);
 #define PERL_ARGS_ASSERT_SV_RVUNWEAKEN \
        assert(sv)
@@ -3694,6 +4105,7 @@ PERL_CALLCONV void        Perl_sv_setuv_mg(pTHX_ SV *const sv, const UV u);
 #define PERL_ARGS_ASSERT_SV_SETUV_MG   \
        assert(sv)
 PERL_CALLCONV SV*      Perl_sv_string_from_errnum(pTHX_ int errnum, SV* tgtsv);
+#define PERL_ARGS_ASSERT_SV_STRING_FROM_ERRNUM
 #ifndef NO_MATHOMS
 PERL_CALLCONV void     Perl_sv_taint(pTHX_ SV* sv);
 #define PERL_ARGS_ASSERT_SV_TAINT      \
@@ -3705,6 +4117,7 @@ PERL_CALLCONV bool        Perl_sv_tainted(pTHX_ SV *const sv)
        assert(sv)
 
 PERL_CALLCONV I32      Perl_sv_true(pTHX_ SV *const sv);
+#define PERL_ARGS_ASSERT_SV_TRUE
 PERL_CALLCONV char*    Perl_sv_uni_display(pTHX_ SV *dsv, SV *ssv, STRLEN pvlim, UV flags)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SV_UNI_DISPLAY        \
@@ -3755,6 +4168,7 @@ PERL_CALLCONV bool        Perl_sv_utf8_downgrade_flags(pTHX_ SV *const sv, const bool f
 #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_FLAGS       \
        assert(sv)
 /* PERL_CALLCONV bool  sv_utf8_downgrade_nomg(pTHX_ SV *const sv, const bool fail_ok); */
+#define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_NOMG
 PERL_CALLCONV void     Perl_sv_utf8_encode(pTHX_ SV *const sv);
 #define PERL_ARGS_ASSERT_SV_UTF8_ENCODE        \
        assert(sv)
@@ -3764,10 +4178,12 @@ PERL_CALLCONV STRLEN    Perl_sv_utf8_upgrade(pTHX_ SV *sv);
        assert(sv)
 #endif
 /* PERL_CALLCONV STRLEN        sv_utf8_upgrade_flags(pTHX_ SV *const sv, const I32 flags); */
+#define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS
 PERL_CALLCONV STRLEN   Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV *const sv, const I32 flags, STRLEN extra);
 #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW    \
        assert(sv)
 /* PERL_CALLCONV STRLEN        sv_utf8_upgrade_nomg(pTHX_ SV *sv); */
+#define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_NOMG
 #ifndef NO_MATHOMS
 PERL_CALLCONV UV       Perl_sv_uv(pTHX_ SV* sv)
                        __attribute__deprecated__;
@@ -3805,7 +4221,9 @@ PERL_CALLCONV SV* Perl_swash_init(pTHX_ const char* pkg, const char* name, SV* l
        assert(pkg); assert(name); assert(listsv)
 
 PERL_CALLCONV void     Perl_switch_to_global_locale(void);
+#define PERL_ARGS_ASSERT_SWITCH_TO_GLOBAL_LOCALE
 PERL_CALLCONV bool     Perl_sync_locale(void);
+#define PERL_ARGS_ASSERT_SYNC_LOCALE
 PERL_CALLCONV void     Perl_sys_init(int* argc, char*** argv);
 #define PERL_ARGS_ASSERT_SYS_INIT      \
        assert(argc); assert(argv)
@@ -3813,17 +4231,23 @@ PERL_CALLCONV void      Perl_sys_init3(int* argc, char*** argv, char*** env);
 #define PERL_ARGS_ASSERT_SYS_INIT3     \
        assert(argc); assert(argv); assert(env)
 PERL_CALLCONV void     Perl_sys_term(void);
+#define PERL_ARGS_ASSERT_SYS_TERM
 PERL_CALLCONV void     Perl_taint_env(pTHX);
+#define PERL_ARGS_ASSERT_TAINT_ENV
 PERL_CALLCONV void     Perl_taint_proper(pTHX_ const char* f, const char *const s);
 #define PERL_ARGS_ASSERT_TAINT_PROPER  \
        assert(s)
 PERL_CALLCONV void     Perl_thread_locale_init(void);
+#define PERL_ARGS_ASSERT_THREAD_LOCALE_INIT
 PERL_CALLCONV void     Perl_thread_locale_term(void);
+#define PERL_ARGS_ASSERT_THREAD_LOCALE_TERM
 PERL_CALLCONV OP *     Perl_tied_method(pTHX_ SV *methname, SV **sp, SV *const sv, const MAGIC *const mg, const U32 flags, U32 argc, ...);
 #define PERL_ARGS_ASSERT_TIED_METHOD   \
        assert(methname); assert(sp); assert(sv); assert(mg)
 PERL_CALLCONV SSize_t  Perl_tmps_grow_p(pTHX_ SSize_t ix);
-/* PERL_CALLCONV UV    Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp); */
+#define PERL_ARGS_ASSERT_TMPS_GROW_P
+/* PERL_CALLCONV UV    to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp); */
+#define PERL_ARGS_ASSERT_TO_UNI_FOLD
 PERL_CALLCONV UV       Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp);
 #define PERL_ARGS_ASSERT_TO_UNI_LOWER  \
        assert(p); assert(lenp)
@@ -3831,6 +4255,7 @@ PERL_CALLCONV UV  Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp);
 PERL_CALLCONV U32      Perl_to_uni_lower_lc(pTHX_ U32 c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_TO_UNI_LOWER_LC
 #endif
 
 PERL_CALLCONV UV       Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp);
@@ -3840,6 +4265,7 @@ PERL_CALLCONV UV  Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp);
 PERL_CALLCONV U32      Perl_to_uni_title_lc(pTHX_ U32 c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_TO_UNI_TITLE_LC
 #endif
 
 PERL_CALLCONV UV       Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp);
@@ -3849,6 +4275,7 @@ PERL_CALLCONV UV  Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp);
 PERL_CALLCONV U32      Perl_to_uni_upper_lc(pTHX_ U32 c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_TO_UNI_UPPER_LC
 #endif
 
 #ifndef NO_MATHOMS
@@ -3880,7 +4307,9 @@ PERL_CALLCONV UV  Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
 #endif
 
 PERL_CALLCONV bool     Perl_try_amagic_bin(pTHX_ int method, int flags);
+#define PERL_ARGS_ASSERT_TRY_AMAGIC_BIN
 PERL_CALLCONV bool     Perl_try_amagic_un(pTHX_ int method, int flags);
+#define PERL_ARGS_ASSERT_TRY_AMAGIC_UN
 #ifndef NO_MATHOMS
 PERL_CALLCONV SSize_t  Perl_unpack_str(pTHX_ const char *pat, const char *patend, const char *s, const char *strbeg, const char *strend, char **new_s, I32 ocnt, U32 flags)
                        __attribute__deprecated__;
@@ -3892,7 +4321,9 @@ PERL_CALLCONV SSize_t     Perl_unpackstring(pTHX_ const char *pat, const char *paten
 #define PERL_ARGS_ASSERT_UNPACKSTRING  \
        assert(pat); assert(patend); assert(s); assert(strend)
 PERL_CALLCONV void     Perl_unshare_hek(pTHX_ HEK* hek);
+#define PERL_ARGS_ASSERT_UNSHARE_HEK
 PERL_CALLCONV void     Perl_unsharepvn(pTHX_ const char* sv, I32 len, U32 hash);
+#define PERL_ARGS_ASSERT_UNSHAREPVN
 PERL_CALLCONV SV*      Perl_upg_version(pTHX_ SV *ver, bool qv);
 #define PERL_ARGS_ASSERT_UPG_VERSION   \
        assert(ver)
@@ -3953,6 +4384,11 @@ PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen)
 PERL_CALLCONV UV       Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen);
 #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF     \
        assert(s); assert(send)
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE UV  Perl_utf8_to_uvchr_buf_helper(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen);
+#define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF_HELPER      \
+       assert(s); assert(send)
+#endif
 #ifndef NO_MATHOMS
 PERL_CALLCONV UV       Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
                        __attribute__deprecated__;
@@ -3972,7 +4408,7 @@ PERL_CALLCONV UV  Perl_utf8n_to_uvchr_error(const U8 *s, STRLEN curlen, STRLEN *r
 #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_ERROR  \
        assert(s)
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE UV  S_utf8n_to_uvchr_msgs(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 * errors, AV ** msgs);
+PERL_STATIC_INLINE UV  Perl_utf8n_to_uvchr_msgs(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 * errors, AV ** msgs);
 #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_MSGS   \
        assert(s)
 #endif
@@ -3983,8 +4419,11 @@ PERL_CALLCONV void       Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop
 #define PERL_ARGS_ASSERT_UTILIZE       \
        assert(idop)
 /* PERL_CALLCONV U8*   uvchr_to_utf8(pTHX_ U8 *d, UV uv); */
+#define PERL_ARGS_ASSERT_UVCHR_TO_UTF8
 /* PERL_CALLCONV U8*   uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); */
+#define PERL_ARGS_ASSERT_UVCHR_TO_UTF8_FLAGS
 /* PERL_CALLCONV U8*   uvchr_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, UV flags, HV ** msgs); */
+#define PERL_ARGS_ASSERT_UVCHR_TO_UTF8_FLAGS_MSGS
 PERL_CALLCONV U8*      Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, const UV flags);
 #define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS        \
        assert(d)
@@ -4019,6 +4458,7 @@ PERL_CALLCONV int Perl_vcmp(pTHX_ SV *lhv, SV *rhv);
        assert(lhv); assert(rhv)
 PERL_CALLCONV_NO_RET void      Perl_vcroak(pTHX_ const char* pat, va_list* args)
                        __attribute__noreturn__;
+#define PERL_ARGS_ASSERT_VCROAK
 
 PERL_CALLCONV void     Perl_vdeb(pTHX_ const char* pat, va_list* args);
 #define PERL_ARGS_ASSERT_VDEB  \
@@ -4081,11 +4521,13 @@ PERL_CALLCONV void      Perl_warner(pTHX_ U32 err, const char* pat, ...)
 
 PERL_CALLCONV I32      Perl_was_lvalue_sub(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_WAS_LVALUE_SUB
 
 PERL_CALLCONV void     Perl_watch(pTHX_ char** addr);
 #define PERL_ARGS_ASSERT_WATCH \
        assert(addr)
 /* PERL_CALLCONV I32   whichsig(pTHX_ const char* sig); */
+#define PERL_ARGS_ASSERT_WHICHSIG
 PERL_CALLCONV I32      Perl_whichsig_pv(pTHX_ const char* sig);
 #define PERL_ARGS_ASSERT_WHICHSIG_PV   \
        assert(sig)
@@ -4105,6 +4547,7 @@ PERL_CALLCONV void        Perl_write_to_stderr(pTHX_ SV* msv);
 #define PERL_ARGS_ASSERT_WRITE_TO_STDERR       \
        assert(msv)
 PERL_CALLCONV void     Perl_xs_boot_epilog(pTHX_ const I32 ax);
+#define PERL_ARGS_ASSERT_XS_BOOT_EPILOG
 PERL_CALLCONV I32      Perl_xs_handshake(const U32 key, void * v_my_perl, const char * file, ...);
 #define PERL_ARGS_ASSERT_XS_HANDSHAKE  \
        assert(v_my_perl); assert(file)
@@ -4115,10 +4558,15 @@ PERL_CALLCONV int       Perl_yyerror_pv(pTHX_ const char *const s, U32 flags);
 #define PERL_ARGS_ASSERT_YYERROR_PV    \
        assert(s)
 PERL_CALLCONV int      Perl_yyerror_pvn(pTHX_ const char *const s, STRLEN len, U32 flags);
+#define PERL_ARGS_ASSERT_YYERROR_PVN
 PERL_CALLCONV int      Perl_yylex(pTHX);
+#define PERL_ARGS_ASSERT_YYLEX
 PERL_CALLCONV int      Perl_yyparse(pTHX_ int gramtype);
+#define PERL_ARGS_ASSERT_YYPARSE
 PERL_CALLCONV void     Perl_yyquit(pTHX);
+#define PERL_ARGS_ASSERT_YYQUIT
 PERL_CALLCONV void     Perl_yyunlex(pTHX);
+#define PERL_ARGS_ASSERT_YYUNLEX
 #if ! defined(HAS_MEMRCHR) && (defined(PERL_CORE) || defined(PERL_EXT))
 #ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE void *      S_my_memrchr(const char * s, const char c, const STRLEN len);
@@ -4137,15 +4585,19 @@ STATIC int      S_sv_2iuv_non_preserve(pTHX_ SV *const sv);
 #endif
 #if !(defined(HAS_NL_LANGINFO) && defined(PERL_LANGINFO_H))
 PERL_CALLCONV const char*      Perl_langinfo(const int item);
+#define PERL_ARGS_ASSERT_PERL_LANGINFO
 #endif
 #if !(defined(HAS_NL_LANGINFO))
 #  if defined(PERL_IN_LOCALE_C)
 STATIC const char*     S_my_nl_langinfo(const int item, bool toggle);
+#define PERL_ARGS_ASSERT_MY_NL_LANGINFO
 #  endif
 #endif
 #if !(defined(HAS_SIGACTION) && defined(SA_SIGINFO))
 PERL_CALLCONV Signal_t Perl_csighandler(int sig);
+#define PERL_ARGS_ASSERT_CSIGHANDLER
 PERL_CALLCONV Signal_t Perl_sighandler(int sig);
+#define PERL_ARGS_ASSERT_SIGHANDLER
 #endif
 #if !(defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION))
 PERL_CALLCONV bool     Perl_do_exec(pTHX_ const char* cmd);
@@ -4168,8 +4620,9 @@ PERL_CALLCONV_NO_RET int  Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg)
 #endif
 #if !defined(EBCDIC)
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE unsigned int        S__variant_byte_number(PERL_UINTMAX_T word)
+PERL_STATIC_INLINE unsigned int        Perl_variant_byte_number(PERL_UINTMAX_T word)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_VARIANT_BYTE_NUMBER
 #endif
 
 #endif
@@ -4206,13 +4659,16 @@ PERL_CALLCONV I32       Perl_same_dirent(pTHX_ const char* a, const char* b);
 PERL_CALLCONV int      Perl_signbit(NV f)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#define PERL_ARGS_ASSERT_PERL_SIGNBIT
 
 #endif
 #if !defined(HAS_STRLCAT)
 PERL_CALLCONV Size_t   Perl_my_strlcat(char *dst, const char *src, Size_t size);
+#define PERL_ARGS_ASSERT_MY_STRLCAT
 #endif
 #if !defined(HAS_STRLCPY)
 PERL_CALLCONV Size_t   Perl_my_strlcpy(char *dst, const char *src, Size_t size);
+#define PERL_ARGS_ASSERT_MY_STRLCPY
 #endif
 #if !defined(HAS_STRNLEN)
 PERL_CALLCONV Size_t   Perl_my_strnlen(const char *str, Size_t maxlen);
@@ -4222,6 +4678,7 @@ PERL_CALLCONV Size_t      Perl_my_strnlen(const char *str, Size_t maxlen);
 #if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP)
 PERL_CALLCONV I32      Perl_my_chsize(pTHX_ int fd, Off_t length)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_MY_CHSIZE
 
 #endif
 #if !defined(NV_PRESERVES_UV)
@@ -4308,6 +4765,7 @@ PERL_STATIC_INLINE void   S_invlist_trim(SV* invlist);
 #endif
 #if !defined(PERL_IMPLICIT_SYS)
 PERL_CALLCONV I32      Perl_my_pclose(pTHX_ PerlIO* ptr);
+#define PERL_ARGS_ASSERT_MY_PCLOSE
 PERL_CALLCONV PerlIO*  Perl_my_popen(pTHX_ const char* cmd, const char* mode);
 #define PERL_ARGS_ASSERT_MY_POPEN      \
        assert(cmd); assert(mode)
@@ -4321,92 +4779,92 @@ STATIC SV *     S_incpush_if_exists(pTHX_ AV *const av, SV *dir, SV *const stem);
 #endif
 #if !defined(PERL_NO_INLINE_FUNCTIONS)
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_popblock(pTHX_ PERL_CONTEXT *cx);
+PERL_STATIC_INLINE void        Perl_cx_popblock(pTHX_ PERL_CONTEXT *cx);
 #define PERL_ARGS_ASSERT_CX_POPBLOCK   \
        assert(cx)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_popeval(pTHX_ PERL_CONTEXT *cx);
+PERL_STATIC_INLINE void        Perl_cx_popeval(pTHX_ PERL_CONTEXT *cx);
 #define PERL_ARGS_ASSERT_CX_POPEVAL    \
        assert(cx)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_popformat(pTHX_ PERL_CONTEXT *cx);
+PERL_STATIC_INLINE void        Perl_cx_popformat(pTHX_ PERL_CONTEXT *cx);
 #define PERL_ARGS_ASSERT_CX_POPFORMAT  \
        assert(cx)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_popgiven(pTHX_ PERL_CONTEXT *cx);
+PERL_STATIC_INLINE void        Perl_cx_popgiven(pTHX_ PERL_CONTEXT *cx);
 #define PERL_ARGS_ASSERT_CX_POPGIVEN   \
        assert(cx)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_poploop(pTHX_ PERL_CONTEXT *cx);
+PERL_STATIC_INLINE void        Perl_cx_poploop(pTHX_ PERL_CONTEXT *cx);
 #define PERL_ARGS_ASSERT_CX_POPLOOP    \
        assert(cx)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_popsub(pTHX_ PERL_CONTEXT *cx);
+PERL_STATIC_INLINE void        Perl_cx_popsub(pTHX_ PERL_CONTEXT *cx);
 #define PERL_ARGS_ASSERT_CX_POPSUB     \
        assert(cx)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_popsub_args(pTHX_ PERL_CONTEXT *cx);
+PERL_STATIC_INLINE void        Perl_cx_popsub_args(pTHX_ PERL_CONTEXT *cx);
 #define PERL_ARGS_ASSERT_CX_POPSUB_ARGS        \
        assert(cx)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_popsub_common(pTHX_ PERL_CONTEXT *cx);
+PERL_STATIC_INLINE void        Perl_cx_popsub_common(pTHX_ PERL_CONTEXT *cx);
 #define PERL_ARGS_ASSERT_CX_POPSUB_COMMON      \
        assert(cx)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_popwhen(pTHX_ PERL_CONTEXT *cx);
+PERL_STATIC_INLINE void        Perl_cx_popwhen(pTHX_ PERL_CONTEXT *cx);
 #define PERL_ARGS_ASSERT_CX_POPWHEN    \
        assert(cx)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE PERL_CONTEXT *      S_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix);
+PERL_STATIC_INLINE PERL_CONTEXT *      Perl_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix);
 #define PERL_ARGS_ASSERT_CX_PUSHBLOCK  \
        assert(sp)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv);
+PERL_STATIC_INLINE void        Perl_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv);
 #define PERL_ARGS_ASSERT_CX_PUSHEVAL   \
        assert(cx)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv);
+PERL_STATIC_INLINE void        Perl_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv);
 #define PERL_ARGS_ASSERT_CX_PUSHFORMAT \
        assert(cx); assert(cv)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv);
+PERL_STATIC_INLINE void        Perl_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv);
 #define PERL_ARGS_ASSERT_CX_PUSHGIVEN  \
        assert(cx)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV *itersave);
+PERL_STATIC_INLINE void        Perl_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV *itersave);
 #define PERL_ARGS_ASSERT_CX_PUSHLOOP_FOR       \
        assert(cx); assert(itervarp)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx);
+PERL_STATIC_INLINE void        Perl_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx);
 #define PERL_ARGS_ASSERT_CX_PUSHLOOP_PLAIN     \
        assert(cx)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs);
+PERL_STATIC_INLINE void        Perl_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs);
 #define PERL_ARGS_ASSERT_CX_PUSHSUB    \
        assert(cx); assert(cv)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_pushwhen(pTHX_ PERL_CONTEXT *cx);
+PERL_STATIC_INLINE void        Perl_cx_pushwhen(pTHX_ PERL_CONTEXT *cx);
 #define PERL_ARGS_ASSERT_CX_PUSHWHEN   \
        assert(cx)
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_cx_topblock(pTHX_ PERL_CONTEXT *cx);
+PERL_STATIC_INLINE void        Perl_cx_topblock(pTHX_ PERL_CONTEXT *cx);
 #define PERL_ARGS_ASSERT_CX_TOPBLOCK   \
        assert(cx)
 #endif
@@ -4462,6 +4920,7 @@ PERL_CALLCONV void        Perl_pad_setsv(pTHX_ PADOFFSET po, SV* sv);
 #define PERL_ARGS_ASSERT_PAD_SETSV     \
        assert(sv)
 PERL_CALLCONV SV*      Perl_pad_sv(pTHX_ PADOFFSET po);
+#define PERL_ARGS_ASSERT_PAD_SV
 PERL_CALLCONV void     Perl_set_padlist(CV * cv, PADLIST * padlist);
 #define PERL_ARGS_ASSERT_SET_PADLIST   \
        assert(cv)
@@ -4475,6 +4934,7 @@ STATIC void       S_print_collxfrm_input_and_return(pTHX_ const char * const s, const
        assert(s); assert(e)
 STATIC char *  S_setlocale_debug_string(const int category, const char* const locale, const char* const retval)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SETLOCALE_DEBUG_STRING
 
 #    endif
 #  endif
@@ -4515,7 +4975,9 @@ PERL_CALLCONV int Perl_re_indentf(pTHX_ const char *fmt, U32 depth, ...);
 #define PERL_ARGS_ASSERT_RE_INDENTF    \
        assert(fmt)
 STATIC void    S_regdump_extflags(pTHX_ const char *lead, const U32 flags);
+#define PERL_ARGS_ASSERT_REGDUMP_EXTFLAGS
 STATIC void    S_regdump_intflags(pTHX_ const char *lead, const U32 flags);
+#define PERL_ARGS_ASSERT_REGDUMP_INTFLAGS
 STATIC bool    S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode_offset p, const regnode_offset val, U32 depth)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_REGTAIL_STUDY \
@@ -4584,10 +5046,12 @@ PERL_CALLCONV I32       Perl_do_shmio(pTHX_ I32 optype, SV** mark, SV** sp);
 #if defined(HAS_NL_LANGINFO)
 #  if defined(PERL_IN_LOCALE_C)
 STATIC const char*     S_my_nl_langinfo(const nl_item item, bool toggle);
+#define PERL_ARGS_ASSERT_MY_NL_LANGINFO
 #  endif
 #endif
 #if defined(HAS_NL_LANGINFO) && defined(PERL_LANGINFO_H)
 PERL_CALLCONV const char*      Perl_langinfo(const nl_item item);
+#define PERL_ARGS_ASSERT_PERL_LANGINFO
 #endif
 #if defined(HAS_PIPE)
 PERL_CALLCONV int      Perl_PerlProc_pipe_cloexec(pTHX_ int *pipefd)
@@ -4598,19 +5062,25 @@ PERL_CALLCONV int       Perl_PerlProc_pipe_cloexec(pTHX_ int *pipefd)
 #endif
 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
 PERL_CALLCONV Signal_t Perl_csighandler(int sig, siginfo_t *info, void *uap);
+#define PERL_ARGS_ASSERT_CSIGHANDLER
 PERL_CALLCONV Signal_t Perl_sighandler(int sig, siginfo_t *info, void *uap);
+#define PERL_ARGS_ASSERT_SIGHANDLER
 #endif
 #if defined(HAS_SOCKET)
 PERL_CALLCONV int      Perl_PerlSock_accept_cloexec(pTHX_ int listenfd, struct sockaddr *addr, Sock_size_t *addrlen)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_PERLSOCK_ACCEPT_CLOEXEC
 
 PERL_CALLCONV int      Perl_PerlSock_socket_cloexec(pTHX_ int domain, int type, int protocol)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_PERLSOCK_SOCKET_CLOEXEC
 
 #endif
 #if defined(HAVE_INTERP_INTERN)
 PERL_CALLCONV void     Perl_sys_intern_clear(pTHX);
+#define PERL_ARGS_ASSERT_SYS_INTERN_CLEAR
 PERL_CALLCONV void     Perl_sys_intern_init(pTHX);
+#define PERL_ARGS_ASSERT_SYS_INTERN_INIT
 #  if defined(USE_ITHREADS)
 PERL_CALLCONV void     Perl_sys_intern_dup(pTHX_ struct interp_intern* src, struct interp_intern* dst);
 #define PERL_ARGS_ASSERT_SYS_INTERN_DUP        \
@@ -4626,6 +5096,7 @@ PERL_CALLCONV int Perl_get_mstats(pTHX_ perl_mstats_t *buf, int buflen, int leve
        assert(buf)
 PERL_CALLCONV MEM_SIZE Perl_malloc_good_size(size_t nbytes)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_MALLOC_GOOD_SIZE
 
 PERL_CALLCONV MEM_SIZE Perl_malloced_size(void *p)
                        __attribute__warn_unused_result__;
@@ -4669,7 +5140,7 @@ PERL_CALLCONV void        Perl_Slab_to_rw(pTHX_ OPSLAB *const slab);
 #endif
 #if defined(PERL_CORE) || defined (PERL_EXT)
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE bool        S_is_utf8_non_invariant_string(const U8* const s, STRLEN len)
+PERL_STATIC_INLINE bool        Perl_is_utf8_non_invariant_string(const U8* const s, STRLEN len)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_IS_UTF8_NON_INVARIANT_STRING  \
        assert(s)
@@ -4698,6 +5169,7 @@ PERL_STATIC_INLINE Size_t S_variant_under_utf8_count(const U8* const s, const U8
 #if defined(PERL_CR_FILTER)
 #  if defined(PERL_IN_TOKE_C)
 STATIC I32     S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen);
+#define PERL_ARGS_ASSERT_CR_TEXTFILTER
 STATIC void    S_strip_return(pTHX_ SV *sv);
 #define PERL_ARGS_ASSERT_STRIP_RETURN  \
        assert(sv)
@@ -4718,21 +5190,27 @@ PERL_CALLCONV PADOFFSET Perl_op_refcnt_dec(pTHX_ OP *o);
 #define PERL_ARGS_ASSERT_OP_REFCNT_DEC \
        assert(o)
 PERL_CALLCONV OP *     Perl_op_refcnt_inc(pTHX_ OP *o);
+#define PERL_ARGS_ASSERT_OP_REFCNT_INC
 #endif
 #if defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION)
-/* PERL_CALLCONV bool  Perl_do_exec(pTHX_ const char* cmd); */
+PERL_CALLCONV bool     Perl_do_exec(pTHX_ const char* cmd);
+#define PERL_ARGS_ASSERT_DO_EXEC       \
+       assert(cmd)
 #endif
 #if defined(PERL_DONT_CREATE_GVSV)
 #ifndef NO_MATHOMS
 PERL_CALLCONV GV*      Perl_gv_SVadd(pTHX_ GV *gv);
+#define PERL_ARGS_ASSERT_GV_SVADD
 #endif
 #endif
 #if defined(PERL_GLOBAL_STRUCT)
 PERL_CALLCONV struct perl_vars *       Perl_GetVars(pTHX);
+#define PERL_ARGS_ASSERT_GETVARS
 PERL_CALLCONV void     Perl_free_global_struct(pTHX_ struct perl_vars *plvarsp);
 #define PERL_ARGS_ASSERT_FREE_GLOBAL_STRUCT    \
        assert(plvarsp)
 PERL_CALLCONV struct perl_vars*        Perl_init_global_struct(pTHX);
+#define PERL_ARGS_ASSERT_INIT_GLOBAL_STRUCT
 #endif
 #if defined(PERL_GLOBAL_STRUCT_PRIVATE)
 #  if defined(PERL_IMPLICIT_CONTEXT)
@@ -4748,6 +5226,7 @@ PERL_CALLCONV void*       Perl_my_cxt_init(pTHX_ const char *my_cxt_key, size_t size);
 PERL_CALLCONV_NO_RET void      Perl_croak_nocontext(const char* pat, ...)
                        __attribute__noreturn__
                        __attribute__format__null_ok__(__printf__,1,2);
+#define PERL_ARGS_ASSERT_CROAK_NOCONTEXT
 
 PERL_CALLCONV void     Perl_deb_nocontext(const char* pat, ...)
                        __attribute__format__(__printf__,1,2);
@@ -4757,6 +5236,7 @@ PERL_CALLCONV void        Perl_deb_nocontext(const char* pat, ...)
 PERL_CALLCONV_NO_RET OP*       Perl_die_nocontext(const char* pat, ...)
                        __attribute__noreturn__
                        __attribute__format__null_ok__(__printf__,1,2);
+#define PERL_ARGS_ASSERT_DIE_NOCONTEXT
 
 PERL_CALLCONV char*    Perl_form_nocontext(const char* pat, ...)
                        __attribute__format__(__printf__,1,2);
@@ -4852,6 +5332,7 @@ STATIC void       S_exec_failed(pTHX_ const char *cmd, int fd, int do_report);
        assert(cmd)
 STATIC bool    S_ingroup(pTHX_ Gid_t testgid, bool effective)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_INGROUP
 
 STATIC bool    S_openn_cleanup(pTHX_ GV *gv, IO *io, PerlIO *fp, char *mode, const char *oname, PerlIO *saveifp, PerlIO *saveofp, int savefd, char savetype, int writing, bool was_fdopen, const char *type, Stat_t *statbufp);
 #define PERL_ARGS_ASSERT_OPENN_CLEANUP \
@@ -4894,6 +5375,7 @@ STATIC Size_t     S_do_trans_simple_utf8(pTHX_ SV * const sv)
 #endif
 #if defined(PERL_IN_DUMP_C)
 STATIC CV*     S_deb_curcv(pTHX_ I32 ix);
+#define PERL_ARGS_ASSERT_DEB_CURCV
 STATIC void    S_debprof(pTHX_ const OP *o);
 #define PERL_ARGS_ASSERT_DEBPROF       \
        assert(o)
@@ -4901,6 +5383,7 @@ STATIC SV*        S_pm_description(pTHX_ const PMOP *pm);
 #define PERL_ARGS_ASSERT_PM_DESCRIPTION        \
        assert(pm)
 STATIC UV      S_sequence_num(pTHX_ const OP *o);
+#define PERL_ARGS_ASSERT_SEQUENCE_NUM
 #endif
 #if defined(PERL_IN_DUMP_C) || defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_SCOPE_C)
 PERL_CALLCONV void     Perl_hv_kill_backrefs(pTHX_ HV *hv);
@@ -4913,6 +5396,7 @@ STATIC bool       S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len,
        assert(stash); assert(name)
 #ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE GV* S_gv_fetchmeth_internal(pTHX_ HV* stash, SV* meth, const char* name, STRLEN len, I32 level, U32 flags);
+#define PERL_ARGS_ASSERT_GV_FETCHMETH_INTERNAL
 #endif
 STATIC void    S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type);
 #define PERL_ARGS_ASSERT_GV_INIT_SVTYPE        \
@@ -4963,6 +5447,7 @@ STATIC struct xpvhv_aux*  S_hv_auxinit_internal(struct xpvhv_aux *iter);
 #define PERL_ARGS_ASSERT_HV_AUXINIT_INTERNAL   \
        assert(iter)
 STATIC SV*     S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash);
+#define PERL_ARGS_ASSERT_HV_DELETE_COMMON
 STATIC SV*     S_hv_free_ent_ret(pTHX_ HV *hv, HE *entry);
 #define PERL_ARGS_ASSERT_HV_FREE_ENT_RET       \
        assert(hv); assert(entry)
@@ -4979,9 +5464,11 @@ PERL_STATIC_NO_RET void  S_hv_notallowed(pTHX_ int flags, const char *key, I32 kl
 
 STATIC HE*     S_new_he(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NEW_HE
 
 #ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE U32 S_ptr_hash(PTRV u);
+#define PERL_ARGS_ASSERT_PTR_HASH
 #endif
 STATIC SV *    S_refcounted_he_value(pTHX_ const struct refcounted_he *he);
 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE   \
@@ -4998,6 +5485,7 @@ STATIC HEK*       S_share_hek_flags(pTHX_ const char *str, STRLEN len, U32 hash, int f
        assert(str)
 
 STATIC void    S_unshare_hek_or_pvn(pTHX_ const HEK* hek, const char* str, I32 len, U32 hash);
+#define PERL_ARGS_ASSERT_UNSHARE_HEK_OR_PVN
 #endif
 #if defined(PERL_IN_HV_C) || defined(PERL_IN_MG_C) || defined(PERL_IN_SV_C)
 PERL_CALLCONV void     Perl_sv_kill_backrefs(pTHX_ SV *const sv, AV *const av);
@@ -5019,22 +5507,30 @@ PERL_STATIC_INLINE const char * S_save_to_buffer(const char * string, char **buf
 
 #  if defined(USE_LOCALE)
 STATIC const char*     S_category_name(const int category);
+#define PERL_ARGS_ASSERT_CATEGORY_NAME
 STATIC void    S_new_collate(pTHX_ const char* newcoll);
+#define PERL_ARGS_ASSERT_NEW_COLLATE
 STATIC void    S_new_ctype(pTHX_ const char* newctype);
 #define PERL_ARGS_ASSERT_NEW_CTYPE     \
        assert(newctype)
 STATIC void    S_new_numeric(pTHX_ const char* newnum);
+#define PERL_ARGS_ASSERT_NEW_NUMERIC
 STATIC void    S_restore_switched_locale(pTHX_ const int category, const char * const original_locale);
+#define PERL_ARGS_ASSERT_RESTORE_SWITCHED_LOCALE
 STATIC void    S_set_numeric_radix(pTHX_ const bool use_locale);
+#define PERL_ARGS_ASSERT_SET_NUMERIC_RADIX
 STATIC char*   S_stdize_locale(pTHX_ char* locs);
 #define PERL_ARGS_ASSERT_STDIZE_LOCALE \
        assert(locs)
 STATIC const char*     S_switch_category_locale_to_template(pTHX_ const int switch_category, const int template_category, const char * template_locale);
+#define PERL_ARGS_ASSERT_SWITCH_CATEGORY_LOCALE_TO_TEMPLATE
 #    if defined(USE_POSIX_2008_LOCALE)
 STATIC const char*     S_emulate_setlocale(const int category, const char* locale, unsigned int index, const bool is_index_valid);
+#define PERL_ARGS_ASSERT_EMULATE_SETLOCALE
 #    endif
 #    if defined(WIN32)
 STATIC char*   S_win32_setlocale(pTHX_ int category, const char* locale);
+#define PERL_ARGS_ASSERT_WIN32_SETLOCALE
 #    endif
 #  endif
 #endif
@@ -5061,10 +5557,12 @@ STATIC int      S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth);
 #define PERL_ARGS_ASSERT_MAGIC_METHPACK        \
        assert(sv); assert(mg); assert(meth)
 STATIC void    S_restore_magic(pTHX_ const void *p);
+#define PERL_ARGS_ASSERT_RESTORE_MAGIC
 STATIC void    S_save_magic_flags(pTHX_ I32 mgs_ix, SV *sv, U32 flags);
 #define PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS      \
        assert(sv)
 STATIC void    S_unwind_handler_stack(pTHX_ const void *p);
+#define PERL_ARGS_ASSERT_UNWIND_HANDLER_STACK
 #endif
 #if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C)
 PERL_CALLCONV bool     Perl_translate_substr_offsets(STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp);
@@ -5091,6 +5589,7 @@ STATIC void       S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp
        assert(stash); assert(target); assert(imopsp)
 STATIC I32     S_assignment_type(pTHX_ const OP *o)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_ASSIGNMENT_TYPE
 
 STATIC void    S_bad_type_gv(pTHX_ I32 n, GV *gv, const OP *kid, const char *t);
 #define PERL_ARGS_ASSERT_BAD_TYPE_GV   \
@@ -5117,10 +5616,12 @@ STATIC OP*      S_fold_constants(pTHX_ OP * const o);
 #define PERL_ARGS_ASSERT_FOLD_CONSTANTS        \
        assert(o)
 STATIC OP*     S_force_list(pTHX_ OP* arg, bool nullit);
+#define PERL_ARGS_ASSERT_FORCE_LIST
 STATIC void    S_forget_pmop(pTHX_ PMOP *const o);
 #define PERL_ARGS_ASSERT_FORGET_PMOP   \
        assert(o)
 STATIC void    S_gen_constant_list(pTHX_ OP* o);
+#define PERL_ARGS_ASSERT_GEN_CONSTANT_LIST
 STATIC void    S_inplace_aassign(pTHX_ OP* o);
 #define PERL_ARGS_ASSERT_INPLACE_AASSIGN       \
        assert(o)
@@ -5130,10 +5631,12 @@ STATIC bool     S_is_handle_constructor(const OP *o, I32 numargs)
        assert(o)
 
 STATIC OP*     S_listkids(pTHX_ OP* o);
+#define PERL_ARGS_ASSERT_LISTKIDS
 STATIC bool    S_looks_like_bool(pTHX_ const OP* o);
 #define PERL_ARGS_ASSERT_LOOKS_LIKE_BOOL       \
        assert(o)
 STATIC OP*     S_modkids(pTHX_ OP *o, I32 type);
+#define PERL_ARGS_ASSERT_MODKIDS
 STATIC void    S_move_proto_attr(pTHX_ OP **proto, OP **attrs, const GV *name, bool curstash);
 #define PERL_ARGS_ASSERT_MOVE_PROTO_ATTR       \
        assert(proto); assert(attrs); assert(name)
@@ -5145,6 +5648,7 @@ STATIC OP*        S_newGIVWHENOP(pTHX_ OP* cond, OP *block, I32 enter_opcode, I32 leave
        assert(block)
 #ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE OP* S_newMETHOP_internal(pTHX_ I32 type, I32 flags, OP* dynamic_meth, SV* const_meth);
+#define PERL_ARGS_ASSERT_NEWMETHOP_INTERNAL
 #endif
 STATIC OP*     S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp)
                        __attribute__warn_unused_result__;
@@ -5179,15 +5683,20 @@ STATIC bool     S_process_special_blocks(pTHX_ I32 floor, const char *const fullname
 #define PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS        \
        assert(fullname); assert(gv); assert(cv)
 STATIC OP*     S_ref_array_or_hash(pTHX_ OP* cond);
+#define PERL_ARGS_ASSERT_REF_ARRAY_OR_HASH
 STATIC OP*     S_refkids(pTHX_ OP* o, I32 type);
+#define PERL_ARGS_ASSERT_REFKIDS
 STATIC bool    S_scalar_mod_type(const OP *o, I32 type)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SCALAR_MOD_TYPE
 
 STATIC OP*     S_scalarboolean(pTHX_ OP *o);
 #define PERL_ARGS_ASSERT_SCALARBOOLEAN \
        assert(o)
 STATIC OP*     S_scalarkids(pTHX_ OP* o);
+#define PERL_ARGS_ASSERT_SCALARKIDS
 STATIC OP*     S_scalarseq(pTHX_ OP* o);
+#define PERL_ARGS_ASSERT_SCALARSEQ
 STATIC OP*     S_search_const(pTHX_ OP *o)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SEARCH_CONST  \
@@ -5231,10 +5740,19 @@ STATIC PADOFFSET        S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 fla
 #define PERL_ARGS_ASSERT_PAD_FINDLEX   \
        assert(namepv); assert(cv); assert(out_name); assert(out_flags)
 STATIC void    S_pad_reset(pTHX);
+#define PERL_ARGS_ASSERT_PAD_RESET
+#endif
+#if defined(PERL_IN_PAD_C) || defined(PERL_IN_OP_C)
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE bool        S_PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq);
+#define PERL_ARGS_ASSERT_PADNAMEIN_SCOPE       \
+       assert(pn)
+#endif
 #endif
 #if defined(PERL_IN_PERLY_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_TOKE_C)
 #ifndef NO_MATHOMS
 PERL_CALLCONV OP*      Perl_ref(pTHX_ OP* o, I32 type);
+#define PERL_ARGS_ASSERT_REF
 #endif
 #endif
 #if defined(PERL_IN_PERL_C)
@@ -5242,6 +5760,7 @@ STATIC void       S_find_beginning(pTHX_ SV* linestr_sv, PerlIO *rsfp);
 #define PERL_ARGS_ASSERT_FIND_BEGINNING        \
        assert(linestr_sv); assert(rsfp)
 STATIC void    S_forbid_setid(pTHX_ const char flag, const bool suidscript);
+#define PERL_ARGS_ASSERT_FORBID_SETID
 STATIC void    S_incpush(pTHX_ const char *const dir, STRLEN len, U32 flags);
 #define PERL_ARGS_ASSERT_INCPUSH       \
        assert(dir)
@@ -5249,32 +5768,43 @@ STATIC void     S_incpush_use_sep(pTHX_ const char *p, STRLEN len, U32 flags);
 #define PERL_ARGS_ASSERT_INCPUSH_USE_SEP       \
        assert(p)
 STATIC void    S_init_ids(pTHX);
+#define PERL_ARGS_ASSERT_INIT_IDS
 STATIC void    S_init_interp(pTHX);
+#define PERL_ARGS_ASSERT_INIT_INTERP
 STATIC void    S_init_main_stash(pTHX);
+#define PERL_ARGS_ASSERT_INIT_MAIN_STASH
 STATIC void    S_init_perllib(pTHX);
+#define PERL_ARGS_ASSERT_INIT_PERLLIB
 STATIC void    S_init_postdump_symbols(pTHX_ int argc, char **argv, char **env);
 #define PERL_ARGS_ASSERT_INIT_POSTDUMP_SYMBOLS \
        assert(argv)
 STATIC void    S_init_predump_symbols(pTHX);
+#define PERL_ARGS_ASSERT_INIT_PREDUMP_SYMBOLS
 STATIC SV*     S_mayberelocate(pTHX_ const char *const dir, STRLEN len, U32 flags);
 #define PERL_ARGS_ASSERT_MAYBERELOCATE \
        assert(dir)
 PERL_STATIC_NO_RET void        S_minus_v(pTHX)
                        __attribute__noreturn__;
+#define PERL_ARGS_ASSERT_MINUS_V
 
 PERL_STATIC_NO_RET void        S_my_exit_jump(pTHX)
                        __attribute__noreturn__;
+#define PERL_ARGS_ASSERT_MY_EXIT_JUMP
 
 STATIC void    S_nuke_stacks(pTHX);
+#define PERL_ARGS_ASSERT_NUKE_STACKS
 STATIC PerlIO *        S_open_script(pTHX_ const char *scriptname, bool dosearch, bool *suidscript);
 #define PERL_ARGS_ASSERT_OPEN_SCRIPT   \
        assert(scriptname); assert(suidscript)
 STATIC void*   S_parse_body(pTHX_ char **env, XSINIT_t xsinit);
+#define PERL_ARGS_ASSERT_PARSE_BODY
 PERL_STATIC_NO_RET void        S_run_body(pTHX_ I32 oldscope)
                        __attribute__noreturn__;
+#define PERL_ARGS_ASSERT_RUN_BODY
 
 PERL_STATIC_NO_RET void        S_usage(pTHX)
                        __attribute__noreturn__;
+#define PERL_ARGS_ASSERT_USAGE
 
 #endif
 #if defined(PERL_IN_PP_C)
@@ -5282,6 +5812,7 @@ STATIC size_t     S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping);
 #define PERL_ARGS_ASSERT_DO_CHOMP      \
        assert(retval); assert(sv)
 STATIC OP*     S_do_delete_local(pTHX);
+#define PERL_ARGS_ASSERT_DO_DELETE_LOCAL
 STATIC SV*     S_refto(pTHX_ SV* sv)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_REFTO \
@@ -5302,6 +5833,13 @@ PERL_CALLCONV GV*        Perl_softref2xv(pTHX_ SV *const sv, const char *const what, co
        assert(sv); assert(what); assert(spp)
 
 #endif
+#if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C)
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE const char *        S_get_regex_charset_name(const U32 flags, STRLEN* const lenp);
+#define PERL_ARGS_ASSERT_GET_REGEX_CHARSET_NAME        \
+       assert(lenp)
+#endif
+#endif
 #if defined(PERL_IN_PP_CTL_C)
 STATIC PerlIO *        S_check_type_and_open(pTHX_ SV *name)
                        __attribute__warn_unused_result__;
@@ -5312,10 +5850,13 @@ STATIC void     S_destroy_matcher(pTHX_ PMOP* matcher);
 #define PERL_ARGS_ASSERT_DESTROY_MATCHER       \
        assert(matcher)
 STATIC OP*     S_do_smartmatch(pTHX_ HV* seen_this, HV* seen_other, const bool copied);
+#define PERL_ARGS_ASSERT_DO_SMARTMATCH
 STATIC OP*     S_docatch(pTHX_ Perl_ppaddr_t firstpp)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_DOCATCH
 
 STATIC bool    S_doeval_compile(pTHX_ U8 gimme, CV* outside, U32 seq, HV* hh);
+#define PERL_ARGS_ASSERT_DOEVAL_COMPILE
 STATIC OP*     S_dofindlabel(pTHX_ OP *o, const char *label, STRLEN len, U32 flags, OP **opstack, OP **oplimit)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_DOFINDLABEL   \
@@ -5326,9 +5867,11 @@ STATIC MAGIC *   S_doparseform(pTHX_ SV *sv);
        assert(sv)
 STATIC I32     S_dopoptoeval(pTHX_ I32 startingblock)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_DOPOPTOEVAL
 
 STATIC I32     S_dopoptogivenfor(pTHX_ I32 startingblock)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_DOPOPTOGIVENFOR
 
 STATIC I32     S_dopoptolabel(pTHX_ const char *label, STRLEN len, U32 flags)
                        __attribute__warn_unused_result__;
@@ -5337,6 +5880,7 @@ STATIC I32        S_dopoptolabel(pTHX_ const char *label, STRLEN len, U32 flags)
 
 STATIC I32     S_dopoptoloop(pTHX_ I32 startingblock)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_DOPOPTOLOOP
 
 STATIC I32     S_dopoptosub_at(pTHX_ const PERL_CONTEXT* cxstk, I32 startingblock)
                        __attribute__warn_unused_result__;
@@ -5345,6 +5889,7 @@ STATIC I32        S_dopoptosub_at(pTHX_ const PERL_CONTEXT* cxstk, I32 startingblock)
 
 STATIC I32     S_dopoptowhen(pTHX_ I32 startingblock)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_DOPOPTOWHEN
 
 STATIC PMOP*   S_make_matcher(pTHX_ REGEXP* re)
                        __attribute__warn_unused_result__;
@@ -5358,6 +5903,7 @@ STATIC bool       S_matcher_matches_sv(pTHX_ PMOP* matcher, SV* sv)
 
 STATIC bool    S_num_overflow(NV value, I32 fldsize, I32 frcsize)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_NUM_OVERFLOW
 
 #ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE bool        S_path_is_searchable(const char *name)
@@ -5476,6 +6022,7 @@ STATIC OP*        S_doform(pTHX_ CV *cv, GV *gv, OP *retop);
 #define PERL_ARGS_ASSERT_DOFORM        \
        assert(cv); assert(gv)
 STATIC SV *    S_space_join_names_mortal(pTHX_ char *const *array);
+#define PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL
 #endif
 #if defined(PERL_IN_REGCOMP_C)
 STATIC SV*     S__make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node)
@@ -5489,6 +6036,7 @@ STATIC void       S_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 c
 #ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_ADD_CP_TO_INVLIST
 #endif
 
 STATIC U32     S_add_data(RExC_state_t* const pRExC_state, const char* const s, const U32 n)
@@ -5504,6 +6052,7 @@ STATIC void       S_change_engine_size(pTHX_ RExC_state_t *pRExC_state, const Ptrdiff_
        assert(pRExC_state)
 STATIC const char *    S_cntrl_to_mnemonic(const U8 c)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CNTRL_TO_MNEMONIC
 
 #ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE U8  S_compute_EXACTish(RExC_state_t *pRExC_state);
@@ -5649,6 +6198,7 @@ STATIC regnode_offset     S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U3
        assert(pRExC_state); assert(flagp)
 STATIC unsigned int    S_regex_set_precedence(const U8 my_operator)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_REGEX_SET_PRECEDENCE
 
 STATIC void    S_reginsert(pTHX_ RExC_state_t *pRExC_state, const U8 op, const regnode_offset operand, const U32 depth);
 #define PERL_ARGS_ASSERT_REGINSERT     \
@@ -5793,6 +6343,7 @@ PERL_STATIC_INLINE UV*    S_invlist_array(SV* const invlist)
 #ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE bool        S_is_invlist(SV* const invlist)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_INVLIST
 #endif
 
 #endif
@@ -5811,6 +6362,7 @@ PERL_STATIC_INLINE char*  S_form_short_octal_warning(pTHX_ const char * const s,
 
 PERL_CALLCONV char     Perl_grok_bslash_c(pTHX_ const char source, const bool output_warning)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_GROK_BSLASH_C
 
 PERL_CALLCONV bool     Perl_grok_bslash_o(pTHX_ char** s, const char* const send, UV* uv, const char** error_msg, const bool output_warning, const bool strict, const bool silence_non_portable, const bool utf8)
                        __attribute__warn_unused_result__;
@@ -5833,8 +6385,10 @@ PERL_STATIC_INLINE I32   S_regcurly(const char *s)
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C)
 PERL_CALLCONV SV*      Perl__add_range_to_invlist(pTHX_ SV* invlist, UV start, UV end)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT__ADD_RANGE_TO_INVLIST
 
 /* PERL_CALLCONV void  _invlist_intersection(pTHX_ SV* const a, SV* const b, SV** i); */
+#define PERL_ARGS_ASSERT__INVLIST_INTERSECTION
 PERL_CALLCONV void     Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** i);
 #define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND    \
        assert(b); assert(i)
@@ -5842,12 +6396,15 @@ PERL_CALLCONV void      Perl__invlist_invert(pTHX_ SV* const invlist);
 #define PERL_ARGS_ASSERT__INVLIST_INVERT       \
        assert(invlist)
 /* PERL_CALLCONV void  _invlist_subtract(pTHX_ SV* const a, SV* const b, SV** result); */
+#define PERL_ARGS_ASSERT__INVLIST_SUBTRACT
 /* PERL_CALLCONV void  _invlist_union(pTHX_ SV* const a, SV* const b, SV** output); */
+#define PERL_ARGS_ASSERT__INVLIST_UNION
 PERL_CALLCONV void     Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** output);
 #define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND   \
        assert(b); assert(output)
 PERL_CALLCONV SV*      Perl__new_invlist(pTHX_ IV initial_size)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT__NEW_INVLIST
 
 PERL_CALLCONV SV*      Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV** other_elements_ptr)
                        __attribute__warn_unused_result__;
@@ -6007,10 +6564,12 @@ PERL_CALLCONV bool      Perl__is_grapheme(pTHX_ const U8 * strbeg, const U8 * s, cons
 #if defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C)
 PERL_CALLCONV bool     Perl_isFOO_lc(pTHX_ const U8 classnum, const U8 character)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_ISFOO_LC
 
 #endif
 #if defined(PERL_IN_SCOPE_C)
 STATIC void    S_save_pushptri32ptr(pTHX_ void *const ptr1, const I32 i, void *const ptr2, const int type);
+#define PERL_ARGS_ASSERT_SAVE_PUSHPTRI32PTR
 STATIC SV*     S_save_scalar_at(pTHX_ SV **sptr, const U32 flags);
 #define PERL_ARGS_ASSERT_SAVE_SCALAR_AT        \
        assert(sptr)
@@ -6049,6 +6608,7 @@ STATIC void       S_glob_assign_glob(pTHX_ SV *const dstr, SV *const sstr, const int d
 #define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB      \
        assert(dstr); assert(sstr)
 STATIC SV *    S_more_sv(pTHX);
+#define PERL_ARGS_ASSERT_MORE_SV
 STATIC void    S_not_a_number(pTHX_ SV *const sv);
 #define PERL_ARGS_ASSERT_NOT_A_NUMBER  \
        assert(sv)
@@ -6119,11 +6679,14 @@ STATIC void     S_unreferenced_to_tmp_stack(pTHX_ AV *const unreferenced);
 #if defined(PERL_IN_SV_C) || defined (PERL_IN_OP_C)
 PERL_CALLCONV SV *     Perl_varname(pTHX_ const GV *const gv, const char gvtype, PADOFFSET targ, const SV *const keyname, SSize_t aindex, int subscript_type)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_VARNAME
 
 #endif
 #if defined(PERL_IN_TOKE_C)
 STATIC int     S_ao(pTHX_ int toketype);
+#define PERL_ARGS_ASSERT_AO
 STATIC void    S_check_uni(pTHX);
+#define PERL_ARGS_ASSERT_CHECK_UNI
 STATIC void    S_checkcomma(pTHX_ const char *s, const char *name, const char *what);
 #define PERL_ARGS_ASSERT_CHECKCOMMA    \
        assert(s); assert(name); assert(what)
@@ -6141,7 +6704,9 @@ STATIC void       S_force_ident(pTHX_ const char *s, int kind);
 #define PERL_ARGS_ASSERT_FORCE_IDENT   \
        assert(s)
 STATIC void    S_force_ident_maybe_lex(pTHX_ char pit);
+#define PERL_ARGS_ASSERT_FORCE_IDENT_MAYBE_LEX
 STATIC void    S_force_next(pTHX_ I32 type);
+#define PERL_ARGS_ASSERT_FORCE_NEXT
 STATIC char*   S_force_strict_version(pTHX_ char *s);
 #define PERL_ARGS_ASSERT_FORCE_STRICT_VERSION  \
        assert(s)
@@ -6170,6 +6735,7 @@ STATIC I32        S_lop(pTHX_ I32 f, U8 x, char *s);
        assert(s)
 PERL_STATIC_NO_RET void        S_missingterm(pTHX_ char *s, STRLEN len)
                        __attribute__noreturn__;
+#define PERL_ARGS_ASSERT_MISSINGTERM
 
 STATIC SV*     S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, STRLEN keylen, SV *sv, SV *pv, const char *type, STRLEN typelen, const char ** error_msg);
 #define PERL_ARGS_ASSERT_NEW_CONSTANT  \
@@ -6181,6 +6747,7 @@ STATIC void       S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_pa
 #define PERL_ARGS_ASSERT_PARSE_IDENT   \
        assert(s); assert(d); assert(e)
 STATIC int     S_pending_ident(pTHX);
+#define PERL_ARGS_ASSERT_PENDING_IDENT
 STATIC char*   S_scan_const(pTHX_ char *start)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SCAN_CONST    \
@@ -6221,12 +6788,15 @@ STATIC char*    S_scan_trans(pTHX_ char *start)
 
 STATIC I32     S_sublex_done(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SUBLEX_DONE
 
 STATIC I32     S_sublex_push(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SUBLEX_PUSH
 
 STATIC I32     S_sublex_start(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SUBLEX_START
 
 STATIC char*   S_swallow_bom(pTHX_ U8 *s)
                        __attribute__warn_unused_result__;
@@ -6242,6 +6812,7 @@ STATIC SV*        S_tokeq(pTHX_ SV *sv);
 #define PERL_ARGS_ASSERT_TOKEQ \
        assert(sv)
 STATIC void    S_update_debugger_info(pTHX_ SV *orig_sv, const char *const buf, STRLEN len);
+#define PERL_ARGS_ASSERT_UPDATE_DEBUGGER_INFO
 STATIC int     S_yywarn(pTHX_ const char *const s, U32 flags);
 #define PERL_ARGS_ASSERT_YYWARN        \
        assert(s)
@@ -6315,6 +6886,7 @@ STATIC SV*        S_swatch_get(pTHX_ SV* swash, UV start, UV span)
 
 STATIC U8      S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp, const char dummy)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_TO_LOWER_LATIN1
 
 STATIC UV      S_turkic_fc(pTHX_ const U8 * const p, const U8 * const e, U8* ustrp, STRLEN *lenp);
 #define PERL_ARGS_ASSERT_TURKIC_FC     \
@@ -6346,8 +6918,11 @@ PERL_CALLCONV UV Perl__to_fold_latin1(const U8 c, U8 *p, STRLEN *lenp, const uns
 #endif
 #if defined(PERL_IN_UTIL_C)
 STATIC bool    S_ckwarn_common(pTHX_ U32 w);
+#define PERL_ARGS_ASSERT_CKWARN_COMMON
 STATIC bool    S_invoke_exception_hook(pTHX_ SV *ex, bool warn);
+#define PERL_ARGS_ASSERT_INVOKE_EXCEPTION_HOOK
 STATIC SV*     S_mess_alloc(pTHX);
+#define PERL_ARGS_ASSERT_MESS_ALLOC
 STATIC SV *    S_with_queued_errors(pTHX_ SV *ex);
 #define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS    \
        assert(ex)
@@ -6373,6 +6948,7 @@ PERL_CALLCONV Malloc_t    Perl_mem_log_realloc(const UV n, const UV typesize, const
 #endif
 #if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C)
 STATIC void    S_pidgone(pTHX_ Pid_t pid, int status);
+#define PERL_ARGS_ASSERT_PIDGONE
 #endif
 #if defined(UNLINK_ALL_VERSIONS)
 PERL_CALLCONV I32      Perl_unlnk(pTHX_ const char* f);
@@ -6384,8 +6960,11 @@ PERL_CALLCONV bool       Perl_dump_c_backtrace(pTHX_ PerlIO* fp, int max_depth, int sk
 #define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE      \
        assert(fp)
 /* PERL_CALLCONV void  free_c_backtrace(pTHX_ Perl_c_backtrace* bt); */
+#define PERL_ARGS_ASSERT_FREE_C_BACKTRACE
 PERL_CALLCONV Perl_c_backtrace*        Perl_get_c_backtrace(pTHX_ int max_depth, int skip);
+#define PERL_ARGS_ASSERT_GET_C_BACKTRACE
 PERL_CALLCONV SV*      Perl_get_c_backtrace_dump(pTHX_ int max_depth, int skip);
+#define PERL_ARGS_ASSERT_GET_C_BACKTRACE_DUMP
 #endif
 #if defined(USE_DTRACE)
 PERL_CALLCONV void     Perl_dtrace_probe_call(pTHX_ CV *cv, bool is_call);
@@ -6398,6 +6977,7 @@ PERL_CALLCONV void        Perl_dtrace_probe_op(pTHX_ const OP *op);
 #define PERL_ARGS_ASSERT_DTRACE_PROBE_OP       \
        assert(op)
 PERL_CALLCONV void     Perl_dtrace_probe_phase(pTHX_ enum perl_phase phase);
+#define PERL_ARGS_ASSERT_DTRACE_PROBE_PHASE
 #endif
 #if defined(USE_ITHREADS)
 PERL_CALLCONV PADOFFSET        Perl_alloccopstash(pTHX_ HV *hv);
@@ -6510,6 +7090,7 @@ PERL_CALLCONV SV* Perl_sv_dup_inc(pTHX_ const SV *const sstr, CLONE_PARAMS *cons
 #endif
 #if defined(USE_LOCALE)                    && (   defined(PERL_IN_LOCALE_C)            || defined(PERL_IN_MG_C)                || defined (PERL_EXT_POSIX)             || defined (PERL_EXT_LANGINFO))
 PERL_CALLCONV bool     Perl__is_cur_LC_category_utf8(pTHX_ int category);
+#define PERL_ARGS_ASSERT__IS_CUR_LC_CATEGORY_UTF8
 #endif
 #if defined(USE_LOCALE_COLLATE)
 PERL_CALLCONV int      Perl_magic_setcollxfrm(pTHX_ SV* sv, MAGIC* mg);
@@ -6533,39 +7114,60 @@ PERL_CALLCONV char*     Perl_sv_collxfrm_flags(pTHX_ SV *const sv, STRLEN *const nxp
 #endif
 #if defined(USE_PERLIO)
 PERL_CALLCONV void     Perl_PerlIO_clearerr(pTHX_ PerlIO *f);
+#define PERL_ARGS_ASSERT_PERLIO_CLEARERR
 PERL_CALLCONV int      Perl_PerlIO_close(pTHX_ PerlIO *f);
+#define PERL_ARGS_ASSERT_PERLIO_CLOSE
 PERL_CALLCONV int      Perl_PerlIO_eof(pTHX_ PerlIO *f);
+#define PERL_ARGS_ASSERT_PERLIO_EOF
 PERL_CALLCONV int      Perl_PerlIO_error(pTHX_ PerlIO *f);
+#define PERL_ARGS_ASSERT_PERLIO_ERROR
 PERL_CALLCONV int      Perl_PerlIO_fileno(pTHX_ PerlIO *f);
+#define PERL_ARGS_ASSERT_PERLIO_FILENO
 PERL_CALLCONV int      Perl_PerlIO_fill(pTHX_ PerlIO *f);
+#define PERL_ARGS_ASSERT_PERLIO_FILL
 PERL_CALLCONV int      Perl_PerlIO_flush(pTHX_ PerlIO *f);
+#define PERL_ARGS_ASSERT_PERLIO_FLUSH
 PERL_CALLCONV STDCHAR *        Perl_PerlIO_get_base(pTHX_ PerlIO *f);
+#define PERL_ARGS_ASSERT_PERLIO_GET_BASE
 PERL_CALLCONV SSize_t  Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_PERLIO_GET_BUFSIZ
 
 PERL_CALLCONV SSize_t  Perl_PerlIO_get_cnt(pTHX_ PerlIO *f)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_PERLIO_GET_CNT
 
 PERL_CALLCONV STDCHAR *        Perl_PerlIO_get_ptr(pTHX_ PerlIO *f);
+#define PERL_ARGS_ASSERT_PERLIO_GET_PTR
 PERL_CALLCONV SSize_t  Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
 #define PERL_ARGS_ASSERT_PERLIO_READ   \
        assert(vbuf)
 PERL_CALLCONV void     Perl_PerlIO_restore_errno(pTHX_ PerlIO *f);
+#define PERL_ARGS_ASSERT_PERLIO_RESTORE_ERRNO
 PERL_CALLCONV void     Perl_PerlIO_save_errno(pTHX_ PerlIO *f);
+#define PERL_ARGS_ASSERT_PERLIO_SAVE_ERRNO
 PERL_CALLCONV int      Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
+#define PERL_ARGS_ASSERT_PERLIO_SEEK
 PERL_CALLCONV void     Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, SSize_t cnt);
+#define PERL_ARGS_ASSERT_PERLIO_SET_CNT
 PERL_CALLCONV void     Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR *ptr, SSize_t cnt);
+#define PERL_ARGS_ASSERT_PERLIO_SET_PTRCNT
 PERL_CALLCONV void     Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f);
+#define PERL_ARGS_ASSERT_PERLIO_SETLINEBUF
 PERL_CALLCONV PerlIO * Perl_PerlIO_stderr(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_PERLIO_STDERR
 
 PERL_CALLCONV PerlIO * Perl_PerlIO_stdin(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_PERLIO_STDIN
 
 PERL_CALLCONV PerlIO * Perl_PerlIO_stdout(pTHX)
                        __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_PERLIO_STDOUT
 
 PERL_CALLCONV Off_t    Perl_PerlIO_tell(pTHX_ PerlIO *f);
+#define PERL_ARGS_ASSERT_PERLIO_TELL
 PERL_CALLCONV SSize_t  Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
 #define PERL_ARGS_ASSERT_PERLIO_UNREAD \
        assert(vbuf)
index 6532397..bad39d7 100755 (executable)
@@ -81,15 +81,16 @@ my ($embed, $core, $ext, $api) = setup_embed();
        }
 
        my ($flags,$retval,$plain_func,@args) = @$_;
-        if ($flags =~ / ( [^AabDdEefhiMmNnOoPpRrSsTUuWXx] ) /x) {
+        if ($flags =~ / ( [^AabCDdEefGhiMmNnOoPpRrSsTUuWXx] ) /x) {
            die_at_end "flag $1 is not legal (for function $plain_func)";
        }
        my @nonnull;
+       my $args_assert_line = ( $flags !~ /G/ );
         my $has_depth = ( $flags =~ /W/ );
        my $has_context = ( $flags !~ /T/ );
        my $never_returns = ( $flags =~ /r/ );
        my $binarycompat = ( $flags =~ /b/ );
-       my $commented_out = ( ! $binarycompat && $flags =~ /m/ );
+       my $commented_out = ( $flags =~ /m/ );
        my $is_malloc = ( $flags =~ /a/ );
        my $can_ignore = ( $flags !~ /R/ ) && ( $flags !~ /P/ ) && !$is_malloc;
        my @names_of_nn;
@@ -99,10 +100,13 @@ my ($embed, $core, $ext, $api) = setup_embed();
            warn "It is nonsensical to require the return value of a void function ($plain_func) to be checked";
        }
 
-       die_at_end "$plain_func: S flag is mutually exclusive from the i and p plags"
-                                           if $flags =~ /S/ && $flags =~ /[ip]/;
+       die_at_end "$plain_func: S and p flags are mutually exclusive"
+                                           if $flags =~ /S/ && $flags =~ /p/;
+       die_at_end "$plain_func: m and $1 flags are mutually exclusive"
+                                       if $flags =~ /m/ && $flags =~ /([pS])/;
 
-       die_at_end "$plain_func: u flag only usable with m" if $flags =~ /u/ && $flags !~ /m/;
+       die_at_end "$plain_func: u flag only usable with m" if $flags =~ /u/
+                                                           && $flags !~ /m/;
 
        my $static_inline = 0;
        if ($flags =~ /([Si])/) {
@@ -128,6 +132,14 @@ my ($embed, $core, $ext, $api) = setup_embed();
 
        die_at_end "For '$plain_func', M flag requires p flag"
                                            if $flags =~ /M/ && $flags !~ /p/;
+       die_at_end "For '$plain_func', C flag requires one of [pim] flag"
+                                           if $flags =~ /C/ && $flags !~ /[ibmp]/;
+       die_at_end "For '$plain_func', X flag requires p or i flag"
+                                           if $flags =~ /X/ && $flags !~ /[ip]/;
+       die_at_end "For '$plain_func', X and m flags are mutually exclusive"
+                                           if $flags =~ /X/ && $flags =~ /m/;
+       die_at_end "For '$plain_func', i with [ACX] requires p flag"
+                       if $flags =~ /i/ && $flags =~ /[ACX]/ && $flags !~ /p/;
        die_at_end "For '$plain_func', b and m flags are mutually exclusive"
                 . " (try M flag)" if $flags =~ /b/ && $flags =~ /m/;
        die_at_end "For '$plain_func', b flag without M flag requires D flag"
@@ -135,13 +147,13 @@ my ($embed, $core, $ext, $api) = setup_embed();
 
        $func = full_name($plain_func, $flags);
        $ret = "";
-       $ret .= "#ifndef NO_MATHOMS\n" if $binarycompat;
-       $ret .= "#ifndef PERL_NO_INLINE_FUNCTIONS\n" if $static_inline;
        $ret .= "$retval\t$func(";
        if ( $has_context ) {
            $ret .= @args ? "pTHX_ " : "pTHX";
        }
        if (@args) {
+           die_at_end "n flag is contradicted by having arguments"
+                                                               if $flags =~ /n/;
            my $n;
            for my $arg ( @args ) {
                ++$n;
@@ -225,12 +237,14 @@ my ($embed, $core, $ext, $api) = setup_embed();
        }
        $ret .= ";";
        $ret = "/* $ret */" if $commented_out;
-       if (@names_of_nn) {
-           $ret .= "\n#define PERL_ARGS_ASSERT_\U$plain_func\E\t\\\n\t"
-               . join '; ', map "assert($_)", @names_of_nn;
-       }
-       $ret .= "\n#endif" if $static_inline;
-       $ret .= "\n#endif" if $binarycompat;
+
+       $ret .= "\n#define PERL_ARGS_ASSERT_\U$plain_func\E"
+                                           if $args_assert_line || @names_of_nn;
+       $ret .= "\t\\\n\t" . join '; ', map "assert($_)", @names_of_nn
+                                                               if @names_of_nn;
+
+       $ret = "#ifndef PERL_NO_INLINE_FUNCTIONS\n$ret\n#endif" if $static_inline;
+       $ret = "#ifndef NO_MATHOMS\n$ret\n#endif" if $binarycompat;
        $ret .= @attrs ? "\n\n" : "\n";
 
        print $pr $ret;
index af991cb..d7e1c5a 100644 (file)
@@ -33,7 +33,8 @@ sub add_level {
            @entries = @$funcs;
        } else {
            foreach (@$funcs) {
-               if ($_->[0] =~ /A/) {
+                if ($_->[0] =~ /[AC]/) { # 'C' is like 'A' for our purposes
+                                         # here
                    push @entries, $_ if $wanted eq 'A';
                } elsif ($_->[0] =~ /E/) {
                    push @entries, $_ if $wanted eq 'E';
index 97ea458..a6e5f87 100644 (file)
--- a/regexec.c
+++ b/regexec.c
@@ -579,7 +579,7 @@ S_find_span_end(U8 * s, const U8 * send, const U8 span_byte)
             span_word |= span_word << 4;
 
             /* That reduces the problem to what this function solves */
-            return s + _variant_byte_number(span_word);
+            return s + variant_byte_number(span_word);
 
 #endif
 
@@ -657,7 +657,7 @@ S_find_next_masked(U8 * s, const U8 * send, const U8 byte, const U8 mask)
             masked &= PERL_VARIANTS_WORD_MASK;
 
             /* This reduces the problem to that solved by this function */
-            s += _variant_byte_number(masked);
+            s += variant_byte_number(masked);
             return s;
 
         } while (s + PERL_WORDSIZE <= send);
@@ -723,7 +723,7 @@ S_find_span_end_mask(U8 * s, const U8 * send, const U8 span_byte, const U8 mask)
             masked |= masked << 1;
             masked |= masked << 2;
             masked |= masked << 4;
-            return s + _variant_byte_number(masked);
+            return s + variant_byte_number(masked);
 
 #endif
 
index ccbc64a..c85060a 100644 (file)
--- a/regexp.h
+++ b/regexp.h
@@ -629,7 +629,7 @@ and check for NULL.
 #  define ReREFCNT_dec(re)     SvREFCNT_dec(re)
 #  define ReREFCNT_inc(re)     ((REGEXP *) SvREFCNT_inc(re))
 #endif
-#define ReANY(re)              S_ReANY((const REGEXP *)(re))
+#define ReANY(re)              Perl_ReANY((const REGEXP *)(re))
 
 /* FIXME for plugins. */
 
diff --git a/sv.h b/sv.h
index 365a7b2..ffeac41 100644 (file)
--- a/sv.h
+++ b/sv.h
@@ -93,8 +93,8 @@ Type flag for scalars.  See L</svtype>.
 =for apidoc AmnU||SVt_PVMG
 Type flag for scalars.  See L</svtype>.
 
-=for apidoc AmnU||SVt_INVLIST
-Type flag for scalars.  See L</svtype>.
+=for apidoc CmnU||SVt_INVLIST
+Type flag for scalars.  See L<perlapi/svtype>.
 
 =for apidoc AmnU||SVt_REGEXP
 Type flag for regular expressions.  See L</svtype>.
@@ -272,18 +272,18 @@ struct p5rx {
 Returns the value of the object's reference count. Exposed
 to perl code via Internals::SvREFCNT().
 
-=for apidoc Am|SV*|SvREFCNT_inc|SV* sv
+=for apidoc SvREFCNT_inc
 Increments the reference count of the given SV, returning the SV.
 
-All of the following C<SvREFCNT_inc>* macros are optimized versions of
+All of the following C<SvREFCNT_inc>* are optimized versions of
 C<SvREFCNT_inc>, and can be replaced with C<SvREFCNT_inc>.
 
-=for apidoc Am|SV*|SvREFCNT_inc_NN|SV* sv
+=for apidoc SvREFCNT_inc_NN
 Same as C<SvREFCNT_inc>, but can only be used if you know C<sv>
 is not C<NULL>.  Since we don't have to check the NULLness, it's faster
 and smaller.
 
-=for apidoc Am|void|SvREFCNT_inc_void|SV* sv
+=for apidoc SvREFCNT_inc_void
 Same as C<SvREFCNT_inc>, but can only be used if you don't need the
 return value.  The macro doesn't need to return a meaningful value.
 
@@ -312,10 +312,10 @@ value, and you know that C<sv> is not C<NULL>.  The macro doesn't need
 to return a meaningful value, or check for NULLness, so it's smaller
 and faster.
 
-=for apidoc Am|void|SvREFCNT_dec|SV* sv
+=for apidoc SvREFCNT_dec
 Decrements the reference count of the given SV.  C<sv> may be C<NULL>.
 
-=for apidoc Am|void|SvREFCNT_dec_NN|SV* sv
+=for apidoc SvREFCNT_dec_NN
 Same as C<SvREFCNT_dec>, but can only be used if you know C<sv>
 is not C<NULL>.  Since we don't have to check the NULLness, it's faster
 and smaller.
@@ -334,10 +334,10 @@ perform the upgrade if necessary.  See C<L</svtype>>.
 #define SvFLAGS(sv)    (sv)->sv_flags
 #define SvREFCNT(sv)   (sv)->sv_refcnt
 
-#define SvREFCNT_inc(sv)               S_SvREFCNT_inc(MUTABLE_SV(sv))
+#define SvREFCNT_inc(sv)               Perl_SvREFCNT_inc(MUTABLE_SV(sv))
 #define SvREFCNT_inc_simple(sv)                SvREFCNT_inc(sv)
-#define SvREFCNT_inc_NN(sv)            S_SvREFCNT_inc_NN(MUTABLE_SV(sv))
-#define SvREFCNT_inc_void(sv)          S_SvREFCNT_inc_void(MUTABLE_SV(sv))
+#define SvREFCNT_inc_NN(sv)            Perl_SvREFCNT_inc_NN(MUTABLE_SV(sv))
+#define SvREFCNT_inc_void(sv)          Perl_SvREFCNT_inc_void(MUTABLE_SV(sv))
 
 /* These guys don't need the curly blocks */
 #define SvREFCNT_inc_simple_void(sv)   STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END
@@ -345,8 +345,8 @@ perform the upgrade if necessary.  See C<L</svtype>>.
 #define SvREFCNT_inc_void_NN(sv)       (void)(++SvREFCNT(MUTABLE_SV(sv)))
 #define SvREFCNT_inc_simple_void_NN(sv)        (void)(++SvREFCNT(MUTABLE_SV(sv)))
 
-#define SvREFCNT_dec(sv)       S_SvREFCNT_dec(aTHX_ MUTABLE_SV(sv))
-#define SvREFCNT_dec_NN(sv)    S_SvREFCNT_dec_NN(aTHX_ MUTABLE_SV(sv))
+#define SvREFCNT_dec(sv)       Perl_SvREFCNT_dec(aTHX_ MUTABLE_SV(sv))
+#define SvREFCNT_dec_NN(sv)    Perl_SvREFCNT_dec_NN(aTHX_ MUTABLE_SV(sv))
 
 #define SVTYPEMASK     0xff
 #define SvTYPE(sv)     ((svtype)((sv)->sv_flags & SVTYPEMASK))
@@ -1081,8 +1081,8 @@ C<sv_force_normal> does nothing.
 
 #define SvPADTMP_on(sv)                (SvFLAGS(sv) |= SVs_PADTMP)
 #define SvPADTMP_off(sv)       (SvFLAGS(sv) &= ~SVs_PADTMP)
-#define SvPADSTALE_on(sv)      S_SvPADSTALE_on(MUTABLE_SV(sv))
-#define SvPADSTALE_off(sv)     S_SvPADSTALE_off(MUTABLE_SV(sv))
+#define SvPADSTALE_on(sv)      Perl_SvPADSTALE_on(MUTABLE_SV(sv))
+#define SvPADSTALE_off(sv)     Perl_SvPADSTALE_off(MUTABLE_SV(sv))
 
 #define SvTEMP(sv)             (SvFLAGS(sv) & SVs_TEMP)
 #define SvTEMP_on(sv)          (SvFLAGS(sv) |= SVs_TEMP)
index d9000a6..97aaafe 100644 (file)
@@ -31,7 +31,9 @@ unless (-d 't' && -f 'MANIFEST') {
     open my $fh, '<', $proto or die "Can't open $proto: $!";
 
     while (<$fh>) {
-       $declared{$1}++ if /^#define\s+(PERL_ARGS_ASSERT[A-Za-z0-9_]+)\s+/;
+        # The trailing '.' distinguishes real from dummy macros that have no
+        # real asserts
+       $declared{$1}++ if /^#define\s+(PERL_ARGS_ASSERT[A-Za-z0-9_]+)\s+./;
     }
 }
 
diff --git a/utf8.c b/utf8.c
index 07e4df7..0d88d52 100644 (file)
--- a/utf8.c
+++ b/utf8.c
@@ -145,14 +145,14 @@ S_new_msg_hv(pTHX_ const char * const message, /* The message text */
 =for apidoc uvoffuni_to_utf8_flags
 
 THIS FUNCTION SHOULD BE USED IN ONLY VERY SPECIALIZED CIRCUMSTANCES.
-Instead, B<Almost all code should use L</uvchr_to_utf8> or
-L</uvchr_to_utf8_flags>>.
+Instead, B<Almost all code should use L<perlapi/uvchr_to_utf8> or
+L<perlapi/uvchr_to_utf8_flags>>.
 
 This function is like them, but the input is a strict Unicode
 (as opposed to native) code point.  Only in very rare circumstances should code
 not be using the native code point.
 
-For details, see the description for L</uvchr_to_utf8_flags>.
+For details, see the description for L<perlapi/uvchr_to_utf8_flags>.
 
 =cut
 */
@@ -921,7 +921,7 @@ S_does_utf8_overflow(const U8 * const s,
 #undef FF_OVERLONG_PREFIX
 
 STRLEN
-Perl__is_utf8_char_helper(const U8 * const s, const U8 * e, const U32 flags)
+Perl_is_utf8_char_helper(const U8 * const s, const U8 * e, const U32 flags)
 {
     STRLEN len;
     const U8 *x;
@@ -958,7 +958,7 @@ Perl__is_utf8_char_helper(const U8 * const s, const U8 * e, const U32 flags)
      *
      */
 
-    PERL_ARGS_ASSERT__IS_UTF8_CHAR_HELPER;
+    PERL_ARGS_ASSERT_IS_UTF8_CHAR_HELPER;
 
     assert(0 == (flags & ~(UTF8_DISALLOW_ILLEGAL_INTERCHANGE
                           |UTF8_DISALLOW_PERL_EXTENDED)));
@@ -1189,7 +1189,8 @@ S_unexpected_non_continuation_text(pTHX_ const U8 * const s,
 =for apidoc utf8n_to_uvchr
 
 THIS FUNCTION SHOULD BE USED IN ONLY VERY SPECIALIZED CIRCUMSTANCES.
-Most code should use L</utf8_to_uvchr_buf>() rather than call this directly.
+Most code should use L</utf8_to_uvchr_buf>() rather than call this
+directly.
 
 Bottom level UTF-8 decode routine.
 Returns the native code point value of the first character in the string C<s>,
@@ -1304,7 +1305,8 @@ Perl_utf8n_to_uvchr(const U8 *s,
 =for apidoc utf8n_to_uvchr_error
 
 THIS FUNCTION SHOULD BE USED IN ONLY VERY SPECIALIZED CIRCUMSTANCES.
-Most code should use L</utf8_to_uvchr_buf>() rather than call this directly.
+Most code should use L</utf8_to_uvchr_buf>() rather than call this
+directly.
 
 This function is for code that needs to know what the precise malformation(s)
 are when an error is found.  If you also need to know the generated warning
@@ -1463,7 +1465,8 @@ Perl_utf8n_to_uvchr_error(const U8 *s,
 =for apidoc utf8n_to_uvchr_msgs
 
 THIS FUNCTION SHOULD BE USED IN ONLY VERY SPECIALIZED CIRCUMSTANCES.
-Most code should use L</utf8_to_uvchr_buf>() rather than call this directly.
+Most code should use L</utf8_to_uvchr_buf>() rather than call this
+directly.
 
 This function is for code that needs to know what the precise malformation(s)
 are when an error is found, and wants the corresponding warning and/or error
@@ -2271,7 +2274,7 @@ Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen)
 {
     PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF;
 
-    return _utf8_to_uvchr_buf(s, send, retlen);
+    return utf8_to_uvchr_buf_helper(s, send, retlen);
 }
 
 /* This is marked as deprecated
@@ -2280,9 +2283,9 @@ Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen)
 
 Only in very rare circumstances should code need to be dealing in Unicode
 (as opposed to native) code points.  In those few cases, use
-C<L<NATIVE_TO_UNI(utf8_to_uvchr_buf(...))|/utf8_to_uvchr_buf>> instead.  If you
-are not absolutely sure this is one of those cases, then assume it isn't and
-use plain C<utf8_to_uvchr_buf> instead.
+C<L<NATIVE_TO_UNI(utf8_to_uvchr_buf(...))|perlapi/utf8_to_uvchr_buf>> instead.
+If you are not absolutely sure this is one of those cases, then assume it isn't
+and use plain C<utf8_to_uvchr_buf> instead.
 
 Returns the Unicode (not-native) code point of the first character in the
 string C<s> which
@@ -2295,7 +2298,8 @@ NULL) to -1.  If those warnings are off, the computed value if well-defined (or
 the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen>
 is set (if C<retlen> isn't NULL) so that (S<C<s> + C<*retlen>>) is the
 next possible position in C<s> that could begin a non-malformed character.
-See L</utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is returned.
+See L<perlapi/utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is
+returned.
 
 =cut
 */
@@ -5409,15 +5413,15 @@ Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv)
 /*
 =for apidoc utf8n_to_uvuni
 
-Instead use L</utf8_to_uvchr_buf>, or rarely, L</utf8n_to_uvchr>.
+Instead use L<perlapi/utf8_to_uvchr_buf>, or rarely, L<perlapi/utf8n_to_uvchr>.
 
 This function was useful for code that wanted to handle both EBCDIC and
 ASCII platforms with Unicode properties, but starting in Perl v5.20, the
 distinctions between the platforms have mostly been made invisible to most
 code, so this function is quite unlikely to be what you want.  If you do need
 this precise functionality, use instead
-C<L<NATIVE_TO_UNI(utf8_to_uvchr_buf(...))|/utf8_to_uvchr_buf>>
-or C<L<NATIVE_TO_UNI(utf8n_to_uvchr(...))|/utf8n_to_uvchr>>.
+C<L<NATIVE_TO_UNI(utf8_to_uvchr_buf(...))|perlapi/utf8_to_uvchr_buf>>
+or C<L<NATIVE_TO_UNI(utf8n_to_uvchr(...))|perlapi/utf8n_to_uvchr>>.
 
 =cut
 */
@@ -5433,8 +5437,8 @@ Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)
 /*
 =for apidoc uvuni_to_utf8_flags
 
-Instead you almost certainly want to use L</uvchr_to_utf8> or
-L</uvchr_to_utf8_flags>.
+Instead you almost certainly want to use L<perlapi/uvchr_to_utf8> or
+L<perlapi/uvchr_to_utf8_flags>.
 
 This function is a deprecated synonym for L</uvoffuni_to_utf8_flags>,
 which itself, while not deprecated, should be used only in isolated
diff --git a/utf8.h b/utf8.h
index 3e35860..e6c7864 100644 (file)
--- a/utf8.h
+++ b/utf8.h
@@ -69,7 +69,7 @@ the string is invariant.
 #define uvchr_to_utf8_flags_msgs(d,uv,flags,msgs)                              \
                 uvoffuni_to_utf8_flags_msgs(d,NATIVE_TO_UNI(uv),flags, msgs)
 #define utf8_to_uvchr_buf(s, e, lenp)                                          \
-                   _utf8_to_uvchr_buf((const U8 *) (s), (const U8 *) e, lenp)
+            utf8_to_uvchr_buf_helper((const U8 *) (s), (const U8 *) e, lenp)
 #define utf8n_to_uvchr(s, len, lenp, flags)                                    \
                                 utf8n_to_uvchr_error(s, len, lenp, flags, 0)
 #define utf8n_to_uvchr_error(s, len, lenp, flags, errors)                      \
@@ -851,14 +851,14 @@ fit in an IV on the current machine.
                     && (    NATIVE_UTF8_TO_I8(*(s)) >  0xF9                 \
                         || (NATIVE_UTF8_TO_I8(*((s) + 1)) >= 0xA2))         \
                     &&  LIKELY((s) + UTF8SKIP(s) <= (e)))                   \
-                    ? _is_utf8_char_helper(s, s + UTF8SKIP(s), 0) : 0)
+                    ?  is_utf8_char_helper(s, s + UTF8SKIP(s), 0) : 0)
 #else
 #   define UTF8_IS_SUPER(s, e)                                              \
                    ((    LIKELY((e) > (s) + 3)                              \
                      &&  (*(U8*) (s)) >= 0xF4                               \
                      && ((*(U8*) (s)) >  0xF4 || (*((U8*) (s) + 1) >= 0x90))\
                      &&  LIKELY((s) + UTF8SKIP(s) <= (e)))                  \
-                    ? _is_utf8_char_helper(s, s + UTF8SKIP(s), 0) : 0)
+                    ?  is_utf8_char_helper(s, s + UTF8SKIP(s), 0) : 0)
 #endif
 
 /* These are now machine generated, and the 'given' clause is no longer
@@ -1029,7 +1029,7 @@ L</is_utf8_string_loclen_flags> to check entire strings.
       ? 1                                                                   \
       : UNLIKELY(((e) - (s)) < UTF8SKIP(s))                                 \
         ? 0                                                                 \
-        : _is_utf8_char_helper(s, e, flags))
+        : is_utf8_char_helper(s, e, flags))
 
 /* Do not use; should be deprecated.  Use isUTF8_CHAR() instead; this is
  * retained solely for backwards compatibility */