From 26c36404b91665c3b131afad3f05a1ec75110c47 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Wed, 10 Sep 2025 19:36:26 -0600 Subject: [PATCH 01/14] regen/HeaderParser: Fix conflated 0,empty This thought the string '0' meant empty; it should be testing that the string isn't empty. --- regen/HeaderParser.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/regen/HeaderParser.pm b/regen/HeaderParser.pm index 594f3d1f900c..7c2415b5ab58 100644 --- a/regen/HeaderParser.pm +++ b/regen/HeaderParser.pm @@ -1012,7 +1012,7 @@ sub _wrap_and_line_up_cond { if ($rest =~ s!(\s*/\*.*?\*/)\s*\z!! || $rest =~ s!(\s*\*/\s*)\z!!) { $rest_tail= $1; } - if ($rest) { + if ($rest ne "") { $rest= $self->tidy_cond($rest); $rest= $rest_head . $rest . $rest_tail; } From d06865785e49b064f1194b124c720e5ce2605724 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Sun, 24 Aug 2025 11:24:06 -0600 Subject: [PATCH 02/14] regen/embed.pl: Remove duplicate push This got duplicated in recent rebasing --- regen/embed.pl | 2 -- 1 file changed, 2 deletions(-) diff --git a/regen/embed.pl b/regen/embed.pl index 7254be71b47a..e427fa6f8c5e 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -321,8 +321,6 @@ sub generate_proto_h { warn "$func: $arg should not have NZ\n" if $nz; } - push( @nonnull, $n ) if $nn; - # Make sure each arg has at least a type and a var name. # An arg of "int" is valid C, but want it to be "int foo". my $argtype = ( $arg =~ m/^(\w+(?:\s*\*+)?)/ )[0]; From 60fe9551b9a0a892cb685cee35e6d5aedd8c8ad8 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Sun, 24 Aug 2025 11:25:07 -0600 Subject: [PATCH 03/14] regen/embed.pl: Move 'my' declaration The next commit will want this to be available earlier. --- regen/embed.pl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/regen/embed.pl b/regen/embed.pl index e427fa6f8c5e..aa555d696660 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -166,6 +166,7 @@ sub generate_proto_h { my $can_ignore = $flags !~ /[RP]/ && !$is_malloc; my $extensions_only = ( $flags =~ /E/ ); my @asserts; + my @attrs; my $func; if (! $can_ignore && $retval eq 'void') { @@ -362,7 +363,6 @@ sub generate_proto_h { push @asserts, @$assertions if $assertions; - my @attrs; if ( $flags =~ /r/ ) { push @attrs, "__attribute__noreturn__"; } From 8fdea23ccec3cc44372e615cad1c67ec988c3a69 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Wed, 3 Sep 2025 16:30:00 -0600 Subject: [PATCH 04/14] regen/embed.pl: Avoid trailing blank Though code later strips this off, it's best to not put it in in the first place --- regen/embed.pl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/regen/embed.pl b/regen/embed.pl index aa555d696660..9866c5cf61c2 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -434,7 +434,7 @@ sub generate_proto_h { # used. $ret = "#${ind}if defined(PERL_CORE) || defined(PERL_EXT)\n" . $ret - . " \n#${ind}endif" + . "\n#${ind}endif" if $extensions_only; # We don't hide the ARGS_ASSERT macro; having that defined does no From e3c6b293f2b3d98199555bcd5e1aa73a719eeac2 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Wed, 3 Sep 2025 16:44:49 -0600 Subject: [PATCH 05/14] regen/embed.pl: Indent here-doc for clarity --- regen/embed.pl | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/regen/embed.pl b/regen/embed.pl index 9866c5cf61c2..17c9ac003744 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -481,14 +481,15 @@ sub generate_proto_h { my $clean= normalize_group_content($proto_buffer); my $fh = open_print_header("proto.h"); + print $fh <<~"EOF"; - START_EXTERN_C - $clean - #ifdef PERL_CORE - # include "pp_proto.h" - #endif - END_EXTERN_C - EOF + START_EXTERN_C + $clean + #ifdef PERL_CORE + # include "pp_proto.h" + #endif + END_EXTERN_C + EOF read_only_bottom_close_and_rename($fh) if ! $error_count; } From 8de2fd0622cbee9c4ef8c347d72fd6f049f2b09a Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Tue, 16 Sep 2025 07:05:07 -0600 Subject: [PATCH 06/14] dump.c: Collapse duplicate macro calls Instead store the result of the first one in a variable, and use that going forward. --- dump.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/dump.c b/dump.c index 4dbf4788960f..4e3fee4e2ad3 100644 --- a/dump.c +++ b/dump.c @@ -990,18 +990,19 @@ S_do_pmop_dump_bar(pTHX_ I32 level, UV bar, PerlIO *file, const PMOP *pm, S_opdump_indent(aTHX_ (OP*)pm, level, bar, file, "PMOFFSET = %" IVdf "\n", (IV)pm->op_pmoffset); #endif + REGEXP * re = PM_GETRE(pm); S_opdump_indent(aTHX_ (OP*)pm, level, bar, file, - "REGEX = 0x%" UVxf "\n", PTR2UV(PM_GETRE(pm))); + "REGEX = 0x%" UVxf "\n", PTR2UV(re)); - if (PM_GETRE(pm)) { + if (re) { char ch = (pm->op_pmflags & PMf_ONCE) ? '?' : '/'; S_opdump_indent(aTHX_ (OP*)pm, level, bar, file, "PMf_PRE %c%.*s%c\n", - ch,(int)RX_PRELEN(PM_GETRE(pm)), RX_PRECOMP(PM_GETRE(pm)), ch); + ch,(int)RX_PRELEN(re), RX_PRECOMP(re), ch); } else S_opdump_indent(aTHX_ (OP*)pm, level, bar, file, "PMf_PRE (RUNTIME)\n"); - if (pm->op_pmflags || PM_GETRE(pm)) { + if (pm->op_pmflags || re) { SV * const tmpsv = pm_description(pm); S_opdump_indent(aTHX_ (OP*)pm, level, bar, file, "PMFLAGS = (%s)\n", SvCUR(tmpsv) ? SvPVX_const(tmpsv) + 1 : ""); From 17fb8b309746dc590131673a6bffdbef9266fe3c Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Tue, 16 Sep 2025 06:54:50 -0600 Subject: [PATCH 07/14] op.c: Collapse duplicate macro calls Instead, store the result of the first one in a variable, and use that going forward --- op.c | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/op.c b/op.c index 890acc37285f..d432e88855bf 100644 --- a/op.c +++ b/op.c @@ -8035,11 +8035,13 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl, UV flags, I32 floor) konst = TRUE; } else konst = FALSE; - if (konst - && !(repl_has_vars - && (!PM_GETRE(pm) - || !RX_PRELEN(PM_GETRE(pm)) - || RX_EXTFLAGS(PM_GETRE(pm)) & RXf_EVAL_SEEN))) + + REGEXP * re; + if ( konst + && ! ( repl_has_vars + && ( ! (re = PM_GETRE(pm)) + || ! RX_PRELEN(re) + || (RX_EXTFLAGS(re) & RXf_EVAL_SEEN)))) { pm->op_pmflags |= PMf_CONST; /* const for long enough */ op_prepend_elem(o->op_type, scalar(repl), o); From 1cda32e49cb5584adba49b7e59c9c7fa9afc3ffc Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Tue, 16 Sep 2025 06:14:49 -0600 Subject: [PATCH 08/14] op.h: Remove some code duplication There are two sets of macros here, the raw version does no checking; and the non-raw, which does. Instead of duplicating the complicated expressions, use the raw version inside the non-raw one to make it a bit easier to read --- op.h | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/op.h b/op.h index 1ee8d06ed543..4401567b3440 100644 --- a/op.h +++ b/op.h @@ -304,12 +304,12 @@ struct pmop { * processing or asserts */ #ifdef USE_ITHREADS #define PM_GETRE_raw(o) (REGEXP*)(PL_regex_pad[(o)->op_pmoffset]) -#define PM_GETRE(o) (SvTYPE(PL_regex_pad[(o)->op_pmoffset]) == SVt_REGEXP \ - ? (REGEXP*)(PL_regex_pad[(o)->op_pmoffset]) : NULL) +#define PM_GETRE(o) (SvTYPE(PM_GETRE_raw(o)) == SVt_REGEXP \ + ? PM_GETRE_raw(o) : NULL) -#define PM_SETRE_raw(o,r) STMT_START { \ - PL_regex_pad[(o)->op_pmoffset] = MUTABLE_SV(r); \ - } STMT_END +#define PM_SETRE_raw(o,r) STMT_START { \ + PL_regex_pad[(o)->op_pmoffset] = MUTABLE_SV(r);\ + } STMT_END /* The assignment is just to enforce type safety (or at least get a warning). */ /* With first class regexps not via a reference one needs to assign @@ -321,13 +321,13 @@ struct pmop { #define PM_SETRE(o,r) STMT_START { \ REGEXP *const pm_setre_ = (r); \ assert(pm_setre_); \ - PL_regex_pad[(o)->op_pmoffset] = MUTABLE_SV(pm_setre_); \ + PM_SETRE_raw(o, pm_setre_); \ } STMT_END #else #define PM_GETRE_raw(o) ((o)->op_pmregexp) -#define PM_GETRE(o) ((o)->op_pmregexp) +#define PM_GETRE(o) PM_GETRE_raw(o) #define PM_SETRE_raw(o,r) ((o)->op_pmregexp = (r)) -#define PM_SETRE(o,r) ((o)->op_pmregexp = (r)) +#define PM_SETRE(o,r) PM_SETRE_raw(o,r) #endif /* Currently these PMf flags occupy a single 32-bit word. Not all bits are From 7fb7120b659e167f9b3bcaf6b1c14963a0aa1cab Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Tue, 16 Sep 2025 06:31:20 -0600 Subject: [PATCH 09/14] op.h: Use PERL_UNIQUE_NAME to make code more readable This allows a variable name in a macro to be used that doesn't have much extra verbiage that otherwise would be required to make it distinct from other variables. --- op.h | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/op.h b/op.h index 4401567b3440..673493a999c3 100644 --- a/op.h +++ b/op.h @@ -318,10 +318,11 @@ struct pmop { more complex, and we'd have an AV with (SV*)NULL in it, which feels bad */ /* BEWARE - something that calls this macro passes (r) which has a side effect. */ +#define r1_ PERL_UNIQUE_NAME(r) #define PM_SETRE(o,r) STMT_START { \ - REGEXP *const pm_setre_ = (r); \ - assert(pm_setre_); \ - PM_SETRE_raw(o, pm_setre_); \ + REGEXP *const r1_ = (r); \ + assert(r1_); \ + PM_SETRE_raw(o, r1_); \ } STMT_END #else #define PM_GETRE_raw(o) ((o)->op_pmregexp) From d2b9472db6754f29ab5ee26a9a7442c415f54d0d Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Tue, 16 Sep 2025 06:58:32 -0600 Subject: [PATCH 10/14] pp_ctl.c: Use macro for when param known non-NULL There are two versions of this macro; the more general one which checks for sanity; and another, to be used when it's already known that things are sane. This commit converts to use the latter, as we do know it's sane here. --- pp_ctl.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pp_ctl.c b/pp_ctl.c index 90853e010029..891af5bc6827 100644 --- a/pp_ctl.c +++ b/pp_ctl.c @@ -172,7 +172,7 @@ PP(pp_regcomp) } /* handle the empty pattern */ - if (!RX_PRELEN(PM_GETRE(pm)) && PL_curpm) { + if (!RX_PRELEN(PM_GETRE_raw(pm)) && PL_curpm) { if (PL_curpm == PL_reg_curpm) { if (PL_curpm_under && PL_curpm_under == PL_reg_curpm) { croak("Infinite recursion via empty pattern"); From 1cf587cd0f560a4af076343ba6be21a169f786ea Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Tue, 16 Sep 2025 07:42:58 -0600 Subject: [PATCH 11/14] cflags.SH: Turn off attribute_nonnull warnings gcc emits a bunch of warnings under -Wall for functions that have declared that parameter 'n' is never going to be NULL, and then have the temerity to make sure that that is true. The problem is that we have many macros that are generalized enough to handle the case where the parameter is NULL. It just happens that sometimes they get called as well from code where it is known to be not NULL. We could write additional macros that are known to take a non-NULL parameter and don't do the test. The existing macros would be rewritten to just call the new ones after checking for non-NULL. But that would complicate our code, and a main point of compilers doing optimization is to figure out and remove impossible cases, without the programmers having to be concerned with that. Just turn off these warnings --- cflags.SH | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/cflags.SH b/cflags.SH index 01c0fbe6f3ac..084a281343dd 100755 --- a/cflags.SH +++ b/cflags.SH @@ -184,11 +184,20 @@ Intel*) ;; # # Is that you, Intel C++? # NOTE 3: the relative order of these options matters: # -Wextra before -Wno-long-long -Wno-declaration-after-statement # +# NOTE 4: If a function has __attribute__nonnull__(n), gcc generates many +# warnings for macros that have the generality to check for NULLness on +# parameter n. We could write versions of those macros that eliminate +# that check, but why?. It complicates our code and gains no +# perceptible performance except in very hot code that the compiler +# has chosen to not optimize away. So turn these off with +# -Wno-nonnull-compare + *) warns="$pedantic \ -Werror=pointer-arith \ -Werror=vla \ -Wextra \ -Wno-long-long -Wno-declaration-after-statement \ + -Wno-nonnull-compare \ -Wc++-compat -Wwrite-strings" case " $ccflags " in *" -std="*) ;; # Already have -std=... From 199d64096dd7a30c846fc512441061c1c3a670ae Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Wed, 10 Sep 2025 20:03:02 -0600 Subject: [PATCH 12/14] perl.h: Add some missing pTHX_n (n is a number) This makes sure these macros exist for every current usage. --- perl.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/perl.h b/perl.h index 877b0d61cc7b..f7e8e6c4c20b 100644 --- a/perl.h +++ b/perl.h @@ -238,6 +238,8 @@ Now a synonym for C>. # define pTHX_7 8 # define pTHX_8 9 # define pTHX_9 10 +# define pTHX_10 11 +# define pTHX_11 12 # define pTHX_12 13 # if defined(DEBUGGING) && !defined(PERL_TRACK_MEMPOOL) # define PERL_TRACK_MEMPOOL @@ -732,6 +734,8 @@ code. # define pTHX_7 7 # define pTHX_8 8 # define pTHX_9 9 +# define pTHX_10 10 +# define pTHX_11 11 # define pTHX_12 12 #endif From 9b11f41f91fda6cdd1120aa5aa68b216cab86103 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Sun, 24 Aug 2025 11:53:36 -0600 Subject: [PATCH 13/14] proto.h: Use __attribute__nonnull__ if available proto.h contains a generated PERL_ARGS_ASSERT macro for every function. It asserts that each parameter that isn't allowed to be NULL actually isn't. These asserts are disabled when not DEBUGGING. But many compilers allow a compile-time assertion to be made for this situation, so we can add an extra measure of protection for free. And this gives hints to the compiler for optimizations when the asserts() aren't there. --- proto.h | 4019 +++++++++++++++++++++++++++++++++++++----------- regen/embed.pl | 21 +- 2 files changed, 3129 insertions(+), 911 deletions(-) diff --git a/proto.h b/proto.h index 796a81d07c57..f1625f76c268 100644 --- a/proto.h +++ b/proto.h @@ -19,10 +19,17 @@ * Edit those files and run 'make regen_headers' to effect changes. */ +#ifdef DEBUGGING /* See GH #23641 */ +# define Perl_attribute_nonnull_(which) +#else +# define Perl_attribute_nonnull_(which) __attribute__nonnull__(which) +#endif + START_EXTERN_C PERL_CALLCONV int -Perl_Gv_AMupdate(pTHX_ HV *stash, bool destructing); +Perl_Gv_AMupdate(pTHX_ HV *stash, bool destructing) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_AMUPDATE \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) @@ -43,6 +50,7 @@ Perl_PerlLIO_dup_cloexec(pTHX_ int oldfd) PERL_CALLCONV int Perl_PerlLIO_open3_cloexec(pTHX_ const char *file, int flag, int perm) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PERLLIO_OPEN3_CLOEXEC \ @@ -50,6 +58,7 @@ Perl_PerlLIO_open3_cloexec(pTHX_ const char *file, int flag, int perm) PERL_CALLCONV int Perl_PerlLIO_open_cloexec(pTHX_ const char *file, int flag) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PERLLIO_OPEN_CLOEXEC \ @@ -63,7 +72,8 @@ Perl_langinfo(const nl_item item); #define PERL_ARGS_ASSERT_PERL_LANGINFO PERL_CALLCONV const char * -Perl_langinfo8(const nl_item item, utf8ness_t *utf8ness); +Perl_langinfo8(const nl_item item, utf8ness_t *utf8ness) + Perl_attribute_nonnull_(2); #define PERL_ARGS_ASSERT_PERL_LANGINFO8 \ assert(utf8ness) @@ -81,7 +91,8 @@ Perl_Slab_Alloc(pTHX_ size_t sz) #define PERL_ARGS_ASSERT_SLAB_ALLOC PERL_CALLCONV void -Perl_Slab_Free(pTHX_ void *op); +Perl_Slab_Free(pTHX_ void *op) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SLAB_FREE \ assert(op) @@ -90,6 +101,7 @@ Perl_SvREFCNT_dec_set_NULL(pTHX_ SV *sv); */ PERL_CALLCONV_NO_RET void Perl_abort_execution(pTHX_ SV *msg_sv, const char * const name) + Perl_attribute_nonnull_(pTHX_2) __attribute__noreturn__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_ABORT_EXECUTION \ @@ -102,22 +114,27 @@ Perl_alloc_LOGOP(pTHX_ I32 type, OP *first, OP *other) PERL_CALLCONV PADOFFSET Perl_allocmy(pTHX_ const char * const name, const STRLEN len, const U32 flags) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_ALLOCMY \ assert(name) PERL_CALLCONV bool -Perl_amagic_applies(pTHX_ SV *sv, int method, int flags); +Perl_amagic_applies(pTHX_ SV *sv, int method, int flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AMAGIC_APPLIES \ assert(sv) PERL_CALLCONV SV * -Perl_amagic_call(pTHX_ SV *left, SV *right, int method, int dir); +Perl_amagic_call(pTHX_ SV *left, SV *right, int method, int dir) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_AMAGIC_CALL \ assert(left); assert(right) PERL_CALLCONV SV * -Perl_amagic_deref_call(pTHX_ SV *ref, int method); +Perl_amagic_deref_call(pTHX_ SV *ref, int method) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL \ assert(ref) @@ -128,19 +145,25 @@ Perl_amagic_is_enabled(pTHX_ int method) PERL_CALLCONV SSize_t Perl_apply(pTHX_ I32 type, SV **mark, SV **sp) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_APPLY \ assert(mark); assert(sp) PERL_CALLCONV void -Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv, const char *attrstr, STRLEN len); +Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv, const char *attrstr, STRLEN len) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_APPLY_ATTRS_STRING \ assert(stashpv); assert(cv); \ assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ assert(attrstr) PERL_CALLCONV OP * -Perl_apply_builtin_cv_attributes(pTHX_ CV *cv, OP *attrlist); +Perl_apply_builtin_cv_attributes(pTHX_ CV *cv, OP *attrlist) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_APPLY_BUILTIN_CV_ATTRIBUTES \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) @@ -157,27 +180,34 @@ Perl_atfork_unlock(void); #define PERL_ARGS_ASSERT_ATFORK_UNLOCK PERL_CALLCONV SV ** -Perl_av_arylen_p(pTHX_ AV *av); +Perl_av_arylen_p(pTHX_ AV *av) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_ARYLEN_P \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void -Perl_av_clear(pTHX_ AV *av); +Perl_av_clear(pTHX_ AV *av) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_CLEAR \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void -Perl_av_create_and_push(pTHX_ AV ** const avp, SV * const val); +Perl_av_create_and_push(pTHX_ AV ** const avp, SV * const val) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH \ assert(avp); assert(val) PERL_CALLCONV SV ** -Perl_av_create_and_unshift_one(pTHX_ AV ** const avp, SV * const val); +Perl_av_create_and_unshift_one(pTHX_ AV ** const avp, SV * const val) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE \ assert(avp); assert(val) PERL_CALLCONV SV * -Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags); +Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_DELETE \ assert(av); assert(SvTYPE(av) == SVt_PVAV) @@ -188,17 +218,22 @@ Perl_av_dump(pTHX_ AV *av); PERL_CALLCONV bool Perl_av_exists(pTHX_ AV *av, SSize_t key) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_EXISTS \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void -Perl_av_extend(pTHX_ AV *av, SSize_t key); +Perl_av_extend(pTHX_ AV *av, SSize_t key) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_EXTEND \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_extend_guts(pTHX_ AV *av, SSize_t key, SSize_t *maxp, SV ***allocp, SV ***arrayp) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_AV_EXTEND_GUTS \ assert(!av || SvTYPE(av) == SVt_PVAV); assert(maxp); assert(allocp); \ @@ -206,45 +241,54 @@ Perl_av_extend_guts(pTHX_ AV *av, SSize_t key, SSize_t *maxp, SV ***allocp, SV * PERL_CALLCONV SV ** Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_FETCH \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void -Perl_av_fill(pTHX_ AV *av, SSize_t fill); +Perl_av_fill(pTHX_ AV *av, SSize_t fill) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_FILL \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV IV * -Perl_av_iter_p(pTHX_ AV *av); +Perl_av_iter_p(pTHX_ AV *av) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_ITER_P \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV SSize_t Perl_av_len(pTHX_ AV *av) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_LEN \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV AV * Perl_av_make(pTHX_ SSize_t size, SV **strp) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_MAKE \ assert(strp) PERL_CALLCONV SV * Perl_av_nonelem(pTHX_ AV *av, SSize_t ix) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_AV_NONELEM \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV SV * -Perl_av_pop(pTHX_ AV *av); +Perl_av_pop(pTHX_ AV *av) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_POP \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void -Perl_av_push(pTHX_ AV *av, SV *val); +Perl_av_push(pTHX_ AV *av, SV *val) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_AV_PUSH \ assert(av); assert(SvTYPE(av) == SVt_PVAV); assert(val) @@ -253,27 +297,33 @@ Perl_av_push(pTHX_ AV *av, SV *val); PERL_CALLCONV SV * Perl_av_shift(pTHX_ AV *av) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_SHIFT \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV SV ** -Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val); +Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_STORE \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void -Perl_av_undef(pTHX_ AV *av); +Perl_av_undef(pTHX_ AV *av) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_UNDEF \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void -Perl_av_unshift(pTHX_ AV *av, SSize_t num); +Perl_av_unshift(pTHX_ AV *av, SSize_t num) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_UNSHIFT \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV OP * Perl_bind_match(pTHX_ I32 type, OP *left, OP *right) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_BIND_MATCH \ @@ -295,7 +345,8 @@ Perl_block_start(pTHX_ int full) #define PERL_ARGS_ASSERT_BLOCK_START PERL_CALLCONV void -Perl_blockhook_register(pTHX_ BHK *hk); +Perl_blockhook_register(pTHX_ BHK *hk) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER \ assert(hk) @@ -321,6 +372,9 @@ Perl_boot_core_mro(pTHX) PERL_CALLCONV OP * Perl_build_infix_plugin(pTHX_ OP *lhs, OP *rhs, void *tokendata) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_BUILD_INFIX_PLUGIN \ assert(lhs); assert(rhs); assert(tokendata) @@ -328,17 +382,24 @@ Perl_build_infix_plugin(pTHX_ OP *lhs, OP *rhs, void *tokendata) #define PERL_ARGS_ASSERT_BYTE_DUMP_STRING_ PERL_CALLCONV int -Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen); +Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_BYTES_CMP_UTF8 \ assert(b); assert(u) PERL_CALLCONV U8 * -Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *lenp, bool *is_utf8p); +Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *lenp, bool *is_utf8p) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_BYTES_FROM_UTF8 \ assert(s); assert(lenp); assert(is_utf8p) PERL_CALLCONV U8 * -Perl_bytes_to_utf8_free_me(pTHX_ const U8 *s, STRLEN *lenp, void **free_me); +Perl_bytes_to_utf8_free_me(pTHX_ const U8 *s, STRLEN *lenp, void **free_me) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_BYTES_TO_UTF8_FREE_ME \ assert(s); assert(lenp) @@ -346,7 +407,9 @@ Perl_bytes_to_utf8_free_me(pTHX_ const U8 *s, STRLEN *lenp, void **free_me); Perl_c9strict_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p); */ PERL_CALLCONV SSize_t -Perl_call_argv(pTHX_ const char *sub_name, I32 flags, char **argv); +Perl_call_argv(pTHX_ const char *sub_name, I32 flags, char **argv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_CALL_ARGV \ assert(sub_name); assert(argv) @@ -355,22 +418,26 @@ 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); +Perl_call_list(pTHX_ I32 oldscope, AV *paramList) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_CALL_LIST \ assert(paramList); assert(SvTYPE(paramList) == SVt_PVAV) PERL_CALLCONV SSize_t -Perl_call_method(pTHX_ const char *methname, I32 flags); +Perl_call_method(pTHX_ const char *methname, I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CALL_METHOD \ assert(methname) PERL_CALLCONV SSize_t -Perl_call_pv(pTHX_ const char *sub_name, I32 flags); +Perl_call_pv(pTHX_ const char *sub_name, I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CALL_PV \ assert(sub_name) PERL_CALLCONV SSize_t -Perl_call_sv(pTHX_ SV *sv, I32 flags); +Perl_call_sv(pTHX_ SV *sv, I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CALL_SV \ assert(sv) @@ -386,6 +453,7 @@ Perl_calloc(MEM_SIZE elements, MEM_SIZE size) PERL_CALLCONV bool Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t *statbufp) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CANDO \ @@ -413,39 +481,52 @@ Perl_cast_uv(NV f) PERL_CALLCONV bool Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CHECK_UTF8_PRINT \ assert(s) PERL_CALLCONV OP * Perl_ck_entersub_args_core(pTHX_ OP *entersubop, GV *namegv, SV *protosv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_CORE \ assert(entersubop); assert(namegv); assert(protosv) PERL_CALLCONV OP * -Perl_ck_entersub_args_list(pTHX_ OP *entersubop); +Perl_ck_entersub_args_list(pTHX_ OP *entersubop) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_LIST \ assert(entersubop) PERL_CALLCONV OP * -Perl_ck_entersub_args_proto(pTHX_ OP *entersubop, GV *namegv, SV *protosv); +Perl_ck_entersub_args_proto(pTHX_ OP *entersubop, GV *namegv, SV *protosv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO \ assert(entersubop); assert(namegv); assert(protosv) PERL_CALLCONV OP * -Perl_ck_entersub_args_proto_or_list(pTHX_ OP *entersubop, GV *namegv, SV *protosv); +Perl_ck_entersub_args_proto_or_list(pTHX_ OP *entersubop, GV *namegv, SV *protosv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO_OR_LIST \ assert(entersubop); assert(namegv); assert(protosv) PERL_CALLCONV void Perl_ck_warner(pTHX_ U32 err, const char *pat, ...) + Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_CK_WARNER \ assert(pat) PERL_CALLCONV void Perl_ck_warner_d(pTHX_ U32 err, const char *pat, ...) + Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_CK_WARNER_D \ assert(pat) @@ -463,18 +544,21 @@ Perl_ckwarn_d(pTHX_ U32 w) #define PERL_ARGS_ASSERT_CKWARN_D PERL_CALLCONV void -Perl_clear_defarray(pTHX_ AV *av, bool abandon); +Perl_clear_defarray(pTHX_ AV *av, bool abandon) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CLEAR_DEFARRAY \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV const COP * Perl_closest_cop(pTHX_ const COP *cop, const OP *o, const OP *curop, bool opnext) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CLOSEST_COP \ assert(cop) PERL_CALLCONV OP * Perl_cmpchain_extend(pTHX_ I32 type, OP *ch, OP *right) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CMPCHAIN_EXTEND \ @@ -482,6 +566,7 @@ Perl_cmpchain_extend(pTHX_ I32 type, OP *ch, OP *right) PERL_CALLCONV OP * Perl_cmpchain_finish(pTHX_ OP *ch) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CMPCHAIN_FINISH \ @@ -496,44 +581,53 @@ Perl_cmpchain_start(pTHX_ I32 type, OP *left, OP *right) #define PERL_ARGS_ASSERT_CNTRL_TO_MNEMONIC PERL_CALLCONV void -Perl_cop_disable_warning(pTHX_ COP *cop, int warn_bit); +Perl_cop_disable_warning(pTHX_ COP *cop, int warn_bit) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_COP_DISABLE_WARNING \ assert(cop) PERL_CALLCONV void -Perl_cop_enable_warning(pTHX_ COP *cop, int warn_bit); +Perl_cop_enable_warning(pTHX_ COP *cop, int warn_bit) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_COP_ENABLE_WARNING \ assert(cop) PERL_CALLCONV const char * -Perl_cop_fetch_label(pTHX_ COP * const cop, STRLEN *len, U32 *flags); +Perl_cop_fetch_label(pTHX_ COP * const cop, STRLEN *len, U32 *flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_COP_FETCH_LABEL \ assert(cop) PERL_CALLCONV bool -Perl_cop_has_warning(pTHX_ const COP *cop, int warn_bit); +Perl_cop_has_warning(pTHX_ const COP *cop, int warn_bit) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_COP_HAS_WARNING \ assert(cop) PERL_CALLCONV void -Perl_cop_store_label(pTHX_ COP * const cop, const char *label, STRLEN len, U32 flags); +Perl_cop_store_label(pTHX_ COP * const cop, const char *label, STRLEN len, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_COP_STORE_LABEL \ assert(cop); assert(label) PERL_CALLCONV SV * Perl_core_prototype(pTHX_ SV *sv, const char *name, const int code, int * const opnum) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CORE_PROTOTYPE \ assert(name) PERL_CALLCONV OP * Perl_coresub_op(pTHX_ SV * const coreargssv, const int code, const int opnum) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CORESUB_OP \ assert(coreargssv) PERL_CALLCONV void Perl_create_eval_scope(pTHX_ OP *retop, SV **sp, U32 flags) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CREATE_EVAL_SCOPE \ assert(sp) @@ -564,6 +658,7 @@ Perl_croak_no_mem(void) PERL_CALLCONV_NO_RET void Perl_croak_no_mem_ext(const char *context, STRLEN len) + Perl_attribute_nonnull_(1) __attribute__noreturn__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CROAK_NO_MEM_EXT \ @@ -581,12 +676,15 @@ Perl_croak_popstack(void) PERL_CALLCONV_NO_RET void Perl_croak_sv(pTHX_ SV *baseex) + Perl_attribute_nonnull_(pTHX_1) __attribute__noreturn__; #define PERL_ARGS_ASSERT_CROAK_SV \ assert(baseex) PERL_CALLCONV_NO_RET void Perl_croak_xs_usage(const CV * const cv, const char * const params) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__noreturn__; #define PERL_ARGS_ASSERT_CROAK_XS_USAGE \ assert(cv); assert(params) @@ -603,12 +701,15 @@ Perl_csighandler3(int sig, Siginfo_t *info, void *uap); PERL_CALLCONV XOPRETANY Perl_custom_op_get_field(pTHX_ const OP *o, const xop_flags_enum field) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CUSTOM_OP_GET_FIELD \ assert(o) PERL_CALLCONV void -Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop); +Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER \ assert(ppaddr); assert(xop) @@ -616,13 +717,16 @@ Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop); assert(cv) PERL_CALLCONV CV * -Perl_cv_clone(pTHX_ CV *proto); +Perl_cv_clone(pTHX_ CV *proto) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CV_CLONE \ assert(proto); \ assert(SvTYPE(proto) == SVt_PVCV || SvTYPE(proto) == SVt_PVFM) PERL_CALLCONV CV * Perl_cv_clone_into(pTHX_ CV *proto, CV *target) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CV_CLONE_INTO \ assert(proto); \ @@ -648,63 +752,83 @@ Perl_cv_forget_slab(pTHX_ CV *cv) assert(!cv || SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void -Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p); +Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ assert(ckfun_p); assert(ckobj_p) PERL_CALLCONV void -Perl_cv_get_call_checker_flags(pTHX_ CV *cv, U32 gflags, Perl_call_checker *ckfun_p, SV **ckobj_p, U32 *ckflags_p); +Perl_cv_get_call_checker_flags(pTHX_ CV *cv, U32 gflags, Perl_call_checker *ckfun_p, SV **ckobj_p, U32 *ckflags_p) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5); #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER_FLAGS \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ assert(ckfun_p); assert(ckobj_p); assert(ckflags_p) PERL_CALLCONV SV * -Perl_cv_name(pTHX_ CV *cv, SV *sv, U32 flags); +Perl_cv_name(pTHX_ CV *cv, SV *sv, U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CV_NAME \ assert(cv) PERL_CALLCONV void -Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj); +Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ assert(ckfun); assert(ckobj) PERL_CALLCONV void -Perl_cv_set_call_checker_flags(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj, U32 ckflags); +Perl_cv_set_call_checker_flags(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj, U32 ckflags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER_FLAGS \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ assert(ckfun); assert(ckobj) PERL_CALLCONV void -Perl_cv_undef(pTHX_ CV *cv); +Perl_cv_undef(pTHX_ CV *cv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CV_UNDEF \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_cv_undef_flags(pTHX_ CV *cv, U32 flags) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CV_UNDEF_FLAGS \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV GV * -Perl_cvgv_from_hek(pTHX_ CV *cv); +Perl_cvgv_from_hek(pTHX_ CV *cv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CVGV_FROM_HEK \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void -Perl_cvgv_set(pTHX_ CV *cv, GV *gv); +Perl_cvgv_set(pTHX_ CV *cv, GV *gv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CVGV_SET \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void -Perl_cvstash_set(pTHX_ CV *cv, HV *stash); +Perl_cvstash_set(pTHX_ CV *cv, HV *stash) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CVSTASH_SET \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ assert(!stash || SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void -Perl_cx_dump(pTHX_ PERL_CONTEXT *cx); +Perl_cx_dump(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CX_DUMP \ assert(cx) @@ -715,6 +839,7 @@ Perl_cxinc(pTHX) PERL_CALLCONV void Perl_deb(pTHX_ const char *pat, ...) + Perl_attribute_nonnull_(pTHX_1) __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_DEB \ assert(pat) @@ -725,7 +850,8 @@ Perl_deb_stack_all(pTHX) #define PERL_ARGS_ASSERT_DEB_STACK_ALL PERL_CALLCONV I32 -Perl_debop(pTHX_ const OP *o); +Perl_debop(pTHX_ const OP *o) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_DEBOP \ assert(o) @@ -748,6 +874,7 @@ Perl_debug_hash_seed(pTHX_ bool via_debug_h) PERL_CALLCONV SV * Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DEFELEM_TARGET \ @@ -759,7 +886,12 @@ Perl_delete_eval_scope(pTHX) #define PERL_ARGS_ASSERT_DELETE_EVAL_SCOPE PERL_CALLCONV char * -Perl_delimcpy(char *to, const char *to_end, const char *from, const char *from_end, const int delim, I32 *retlen); +Perl_delimcpy(char *to, const char *to_end, const char *from, const char *from_end, const int delim, I32 *retlen) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(3) + Perl_attribute_nonnull_(4) + Perl_attribute_nonnull_(6); #define PERL_ARGS_ASSERT_DELIMCPY \ assert(to); assert(to_end); assert(from); assert(from_end); \ assert(retlen) @@ -780,12 +912,14 @@ Perl_die(pTHX_ const char *pat, ...) PERL_CALLCONV_NO_RET OP * Perl_die_sv(pTHX_ SV *baseex) + Perl_attribute_nonnull_(pTHX_1) __attribute__noreturn__; #define PERL_ARGS_ASSERT_DIE_SV \ assert(baseex) PERL_CALLCONV_NO_RET void Perl_die_unwind(pTHX_ SV *msv) + Perl_attribute_nonnull_(pTHX_1) __attribute__noreturn__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DIE_UNWIND \ @@ -796,6 +930,8 @@ Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp); */ PERL_CALLCONV bool Perl_do_aexec5(pTHX_ SV *really, SV **mark, SV **sp, int fd, int do_report) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_AEXEC5 \ assert(mark); assert(sp) @@ -806,50 +942,66 @@ Perl_do_close(pTHX_ GV *gv, bool is_explicit); PERL_CALLCONV void Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_DUMP_PAD \ assert(file) PERL_CALLCONV bool Perl_do_eof(pTHX_ GV *gv) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_EOF \ assert(gv) PERL_CALLCONV void -Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv); +Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_DO_GV_DUMP \ assert(file); assert(name) PERL_CALLCONV void -Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv); +Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_DO_GVGV_DUMP \ assert(file); assert(name) PERL_CALLCONV void -Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv); +Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_DO_HV_DUMP \ assert(file); assert(name); assert(!sv || SvTYPE(sv) == SVt_PVHV) PERL_CALLCONV void -Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp); +Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4); #define PERL_ARGS_ASSERT_DO_JOIN \ assert(sv); assert(delim); assert(mark); assert(sp) PERL_CALLCONV void -Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim); +Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_DO_MAGIC_DUMP \ assert(file) PERL_CALLCONV I32 Perl_do_ncmp(pTHX_ SV * const left, SV * const right) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_NCMP \ assert(left); assert(right) PERL_CALLCONV void -Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o); +Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_DO_OP_DUMP \ assert(file) @@ -858,28 +1010,36 @@ Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, i PERL_CALLCONV bool Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_OPEN6 \ assert(gv); assert(oname) PERL_CALLCONV bool Perl_do_open_raw(pTHX_ GV *gv, const char *oname, STRLEN len, int rawmode, int rawperm, Stat_t *statbufp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_OPEN_RAW \ assert(gv); assert(oname) PERL_CALLCONV bool -Perl_do_openn(pTHX_ GV *gv, const char *oname, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV **svp, I32 num); +Perl_do_openn(pTHX_ GV *gv, const char *oname, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV **svp, I32 num) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_DO_OPENN \ assert(gv); assert(oname) PERL_CALLCONV void -Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm); +Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_DO_PMOP_DUMP \ assert(file) PERL_CALLCONV bool Perl_do_print(pTHX_ SV *sv, PerlIO *fp) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_PRINT \ assert(fp) @@ -896,23 +1056,28 @@ 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); +Perl_do_sprintf(pTHX_ SV *sv, SSize_t len, SV **sarg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_DO_SPRINTF \ assert(sv); assert(sarg) PERL_CALLCONV void -Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim); +Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_DO_SV_DUMP \ assert(file) PERL_CALLCONV Off_t Perl_do_sysseek(pTHX_ GV *gv, Off_t pos, int whence) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_SYSSEEK \ assert(gv) PERL_CALLCONV Off_t Perl_do_tell(pTHX_ GV *gv) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_TELL \ @@ -920,6 +1085,7 @@ Perl_do_tell(pTHX_ GV *gv) PERL_CALLCONV Size_t Perl_do_trans(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_TRANS \ assert(sv) @@ -929,24 +1095,30 @@ Perl_do_trans(pTHX_ SV *sv) PERL_CALLCONV UV Perl_do_vecget(pTHX_ SV *sv, STRLEN offset, int size) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_VECGET \ assert(sv) PERL_CALLCONV void Perl_do_vecset(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_VECSET \ assert(sv) PERL_CALLCONV void Perl_do_vop(pTHX_ I32 optype, SV *sv, SV *left, SV *right) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_VOP \ assert(sv); assert(left); assert(right) PERL_CALLCONV OP * Perl_dofile(pTHX_ OP *term, I32 force_builtin) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DOFILE \ assert(term) @@ -957,7 +1129,8 @@ Perl_doing_taint(int argc, char **argv, char **env) #define PERL_ARGS_ASSERT_DOING_TAINT PERL_CALLCONV OP * -Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref); +Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_DOREF \ assert(o) @@ -972,12 +1145,14 @@ Perl_dowantarray(pTHX) #define PERL_ARGS_ASSERT_DOWANTARRAY PERL_CALLCONV void -Perl_drand48_init_r(perl_drand48_t *random_state, U32 seed); +Perl_drand48_init_r(perl_drand48_t *random_state, U32 seed) + Perl_attribute_nonnull_(1); #define PERL_ARGS_ASSERT_DRAND48_INIT_R \ assert(random_state) PERL_CALLCONV double -Perl_drand48_r(perl_drand48_t *random_state); +Perl_drand48_r(perl_drand48_t *random_state) + Perl_attribute_nonnull_(1); #define PERL_ARGS_ASSERT_DRAND48_R \ assert(random_state) @@ -995,40 +1170,49 @@ Perl_dump_eval(pTHX); #define PERL_ARGS_ASSERT_DUMP_EVAL PERL_CALLCONV void -Perl_dump_form(pTHX_ const GV *gv); +Perl_dump_form(pTHX_ const GV *gv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_DUMP_FORM \ assert(gv) PERL_CALLCONV void Perl_dump_indent(pTHX_ I32 level, PerlIO *file, const char *pat, ...) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__format__(__printf__,pTHX_3,pTHX_4); #define PERL_ARGS_ASSERT_DUMP_INDENT \ assert(file); assert(pat) PERL_CALLCONV void -Perl_dump_packsubs(pTHX_ const HV *stash); +Perl_dump_packsubs(pTHX_ const HV *stash) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_DUMP_PACKSUBS \ assert(stash) PERL_CALLCONV void Perl_dump_packsubs_perl(pTHX_ const HV *stash, bool justperl) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DUMP_PACKSUBS_PERL \ assert(stash) PERL_CALLCONV void -Perl_dump_sub(pTHX_ const GV *gv); +Perl_dump_sub(pTHX_ const GV *gv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_DUMP_SUB \ assert(gv) PERL_CALLCONV void Perl_dump_sub_perl(pTHX_ const GV *gv, bool justperl) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DUMP_SUB_PERL \ assert(gv) PERL_CALLCONV void -Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char *pat, va_list *args); +Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char *pat, va_list *args) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_DUMP_VINDENT \ assert(file); assert(pat) @@ -1038,12 +1222,14 @@ Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char *pat, va_list *args) assert(c); assert(sv) PERL_CALLCONV SV * -Perl_eval_pv(pTHX_ const char *p, I32 croak_on_error); +Perl_eval_pv(pTHX_ const char *p, I32 croak_on_error) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_EVAL_PV \ assert(p) PERL_CALLCONV SSize_t -Perl_eval_sv(pTHX_ SV *sv, I32 flags); +Perl_eval_sv(pTHX_ SV *sv, I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_EVAL_SV \ assert(sv) @@ -1054,17 +1240,22 @@ Perl_extended_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_ PERL_CALLCONV void Perl_fatal_warner(pTHX_ U32 err, const char *pat, ...) + Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_FATAL_WARNER \ assert(pat) PERL_CALLCONV void -Perl_fbm_compile(pTHX_ SV *sv, U32 flags); +Perl_fbm_compile(pTHX_ SV *sv, U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_FBM_COMPILE \ assert(sv) PERL_CALLCONV char * Perl_fbm_instr(pTHX_ unsigned char *big, unsigned char *bigend, SV *littlestr, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_FBM_INSTR \ assert(big); assert(bigend); assert(littlestr) @@ -1074,12 +1265,14 @@ 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); +Perl_filter_del(pTHX_ filter_t funcp) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_FILTER_DEL \ assert(funcp) PERL_CALLCONV I32 Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_FILTER_READ \ assert(buf_sv) @@ -1106,6 +1299,7 @@ Perl_find_rundefsv(pTHX); PERL_CALLCONV char * Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char * const * const search_ext, I32 flags) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_FIND_SCRIPT \ assert(scriptname) @@ -1114,12 +1308,16 @@ Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char * const Perl_foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ 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); +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) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_5); #define PERL_ARGS_ASSERT_FOLDEQ_UTF8_FLAGS \ assert(s1); assert(s2) PERL_CALLCONV void -Perl_forbid_outofblock_ops(pTHX_ OP *o, const char *blockname); +Perl_forbid_outofblock_ops(pTHX_ OP *o, const char *blockname) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_FORBID_OUTOFBLOCK_OPS \ assert(o); assert(blockname) @@ -1129,12 +1327,15 @@ Perl_force_locale_unlock(pTHX) #define PERL_ARGS_ASSERT_FORCE_LOCALE_UNLOCK PERL_CALLCONV void -Perl_force_out_malformed_utf8_message_(pTHX_ const U8 * const p, const U8 * const e, U32 flags, const bool die_here); +Perl_force_out_malformed_utf8_message_(pTHX_ const U8 * const p, const U8 * const e, U32 flags, const bool die_here) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_FORCE_OUT_MALFORMED_UTF8_MESSAGE_ \ assert(p); assert(e) PERL_CALLCONV char * Perl_form(pTHX_ const char *pat, ...) + Perl_attribute_nonnull_(pTHX_1) __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_FORM \ assert(pat) @@ -1152,22 +1353,26 @@ Perl_free_tmps(pTHX); assert(s); assert(e); assert(error_msg) PERL_CALLCONV AV * -Perl_get_av(pTHX_ const char *name, I32 flags); +Perl_get_av(pTHX_ const char *name, I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GET_AV \ assert(name) PERL_CALLCONV CV * -Perl_get_cv(pTHX_ const char *name, I32 flags); +Perl_get_cv(pTHX_ const char *name, I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GET_CV \ assert(name) PERL_CALLCONV CV * -Perl_get_cvn_flags(pTHX_ const char *name, STRLEN len, I32 flags); +Perl_get_cvn_flags(pTHX_ const char *name, STRLEN len, I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GET_CVN_FLAGS \ assert(name) PERL_CALLCONV void -Perl_get_db_sub(pTHX_ SV **svp, CV *cv); +Perl_get_db_sub(pTHX_ SV **svp, CV *cv) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GET_DB_SUB \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) @@ -1180,12 +1385,14 @@ Perl_get_extended_os_errno(void) PERL_CALLCONV void Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_GET_HASH_SEED \ assert(seed_buffer) PERL_CALLCONV HV * -Perl_get_hv(pTHX_ const char *name, I32 flags); +Perl_get_hv(pTHX_ const char *name, I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GET_HV \ assert(name) @@ -1235,12 +1442,14 @@ 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); +Perl_get_sv(pTHX_ const char *name, I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GET_SV \ assert(name) PERL_CALLCONV int -Perl_getcwd_sv(pTHX_ SV *sv); +Perl_getcwd_sv(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GETCWD_SV \ assert(sv) @@ -1253,48 +1462,68 @@ 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); +Perl_grok_atoUV(const char *pv, UV *valptr, const char **endptr) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2); #define PERL_ARGS_ASSERT_GROK_ATOUV \ assert(pv); assert(valptr) PERL_CALLCONV UV -Perl_grok_bin(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result); +Perl_grok_bin(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_GROK_BIN \ assert(start); assert(len_p); assert(flags) PERL_CALLCONV UV -Perl_grok_bin_oct_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result, const unsigned shift, const U8 lookup_bit, const char prefix); +Perl_grok_bin_oct_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result, const unsigned shift, const U8 lookup_bit, const char prefix) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_GROK_BIN_OCT_HEX \ assert(start); assert(len_p); assert(flags) PERL_CALLCONV UV -Perl_grok_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result); +Perl_grok_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_GROK_HEX \ assert(start); assert(len_p); assert(flags) PERL_CALLCONV int -Perl_grok_infnan(pTHX_ const char **sp, const char *send); +Perl_grok_infnan(pTHX_ const char **sp, const char *send) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GROK_INFNAN \ assert(sp); assert(send) PERL_CALLCONV int -Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep); +Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GROK_NUMBER \ assert(pv) PERL_CALLCONV int -Perl_grok_number_flags(pTHX_ const char *pv, STRLEN len, UV *valuep, U32 flags); +Perl_grok_number_flags(pTHX_ const char *pv, STRLEN len, UV *valuep, U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GROK_NUMBER_FLAGS \ assert(pv) PERL_CALLCONV bool Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GROK_NUMERIC_RADIX \ assert(sp); assert(send) PERL_CALLCONV UV -Perl_grok_oct(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result); +Perl_grok_oct(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_GROK_OCT \ assert(start); assert(len_p); assert(flags) @@ -1313,29 +1542,34 @@ Perl_gv_add_by_type(pTHX_ GV *gv, svtype type); PERL_CALLCONV GV * Perl_gv_autoload_pv(pTHX_ HV *stash, const char *namepv, U32 flags) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PV \ assert(namepv) PERL_CALLCONV GV * Perl_gv_autoload_pvn(pTHX_ HV *stash, const char *name, STRLEN len, U32 flags) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PVN \ assert(name) PERL_CALLCONV GV * Perl_gv_autoload_sv(pTHX_ HV *stash, SV *namesv, U32 flags) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_AUTOLOAD_SV \ assert(namesv) PERL_CALLCONV void -Perl_gv_check(pTHX_ HV *stash); +Perl_gv_check(pTHX_ HV *stash) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_CHECK \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV SV * Perl_gv_const_sv(pTHX_ GV *gv) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_CONST_SV \ assert(gv) @@ -1348,17 +1582,21 @@ Perl_gv_dump(pTHX_ GV *gv); Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); */ PERL_CALLCONV void -Perl_gv_efullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain); +Perl_gv_efullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_EFULLNAME4 \ assert(sv); assert(gv) PERL_CALLCONV GV * -Perl_gv_fetchfile(pTHX_ const char *name); +Perl_gv_fetchfile(pTHX_ const char *name) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_FETCHFILE \ assert(name) PERL_CALLCONV GV * -Perl_gv_fetchfile_flags(pTHX_ const char * const name, const STRLEN len, const U32 flags); +Perl_gv_fetchfile_flags(pTHX_ const char * const name, const STRLEN len, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS \ assert(name) @@ -1369,32 +1607,38 @@ Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level); */ Perl_gv_fetchmeth_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level); */ PERL_CALLCONV GV * -Perl_gv_fetchmeth_pv(pTHX_ HV *stash, const char *name, I32 level, U32 flags); +Perl_gv_fetchmeth_pv(pTHX_ HV *stash, const char *name, I32 level, U32 flags) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV \ assert(name) PERL_CALLCONV GV * -Perl_gv_fetchmeth_pv_autoload(pTHX_ HV *stash, const char *name, I32 level, U32 flags); +Perl_gv_fetchmeth_pv_autoload(pTHX_ HV *stash, const char *name, I32 level, U32 flags) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV_AUTOLOAD \ assert(name) PERL_CALLCONV GV * -Perl_gv_fetchmeth_pvn(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags); +Perl_gv_fetchmeth_pvn(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN \ assert(name) PERL_CALLCONV GV * -Perl_gv_fetchmeth_pvn_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags); +Perl_gv_fetchmeth_pvn_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN_AUTOLOAD \ assert(name) PERL_CALLCONV GV * -Perl_gv_fetchmeth_sv(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags); +Perl_gv_fetchmeth_sv(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV \ assert(namesv) PERL_CALLCONV GV * -Perl_gv_fetchmeth_sv_autoload(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags); +Perl_gv_fetchmeth_sv_autoload(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV_AUTOLOAD \ assert(namesv) @@ -1402,37 +1646,48 @@ Perl_gv_fetchmeth_sv_autoload(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags) Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name); */ PERL_CALLCONV GV * -Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload); +Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD \ assert(stash); assert(name) PERL_CALLCONV GV * -Perl_gv_fetchmethod_pv_flags(pTHX_ HV *stash, const char *name, U32 flags); +Perl_gv_fetchmethod_pv_flags(pTHX_ HV *stash, const char *name, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PV_FLAGS \ assert(stash); assert(name) PERL_CALLCONV GV * -Perl_gv_fetchmethod_pvn_flags(pTHX_ HV *stash, const char *name, const STRLEN len, U32 flags); +Perl_gv_fetchmethod_pvn_flags(pTHX_ HV *stash, const char *name, const STRLEN len, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PVN_FLAGS \ assert(stash); assert(name) PERL_CALLCONV GV * -Perl_gv_fetchmethod_sv_flags(pTHX_ HV *stash, SV *namesv, U32 flags); +Perl_gv_fetchmethod_sv_flags(pTHX_ HV *stash, SV *namesv, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_SV_FLAGS \ assert(stash); assert(namesv) PERL_CALLCONV GV * -Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 flags, const svtype sv_type); +Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 flags, const svtype sv_type) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_FETCHPV \ assert(nambeg) PERL_CALLCONV GV * -Perl_gv_fetchpvn_flags(pTHX_ const char *name, STRLEN len, I32 flags, const svtype sv_type); +Perl_gv_fetchpvn_flags(pTHX_ const char *name, STRLEN len, I32 flags, const svtype sv_type) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_FETCHPVN_FLAGS \ assert(name) PERL_CALLCONV GV * -Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type); +Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_FETCHSV \ assert(name) @@ -1440,7 +1695,9 @@ Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type); Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); */ PERL_CALLCONV void -Perl_gv_fullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain); +Perl_gv_fullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FULLNAME4 \ assert(sv); assert(gv) @@ -1454,70 +1711,88 @@ Perl_gv_handler(pTHX_ HV *stash, I32 id) Perl_gv_init(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, int multi); */ PERL_CALLCONV void -Perl_gv_init_pv(pTHX_ GV *gv, HV *stash, const char *name, U32 flags); +Perl_gv_init_pv(pTHX_ GV *gv, HV *stash, const char *name, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_GV_INIT_PV \ assert(gv); assert(!stash || SvTYPE(stash) == SVt_PVHV); assert(name) PERL_CALLCONV void -Perl_gv_init_pvn(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, U32 flags); +Perl_gv_init_pvn(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_GV_INIT_PVN \ assert(gv); assert(!stash || SvTYPE(stash) == SVt_PVHV); assert(name) PERL_CALLCONV void -Perl_gv_init_sv(pTHX_ GV *gv, HV *stash, SV *namesv, U32 flags); +Perl_gv_init_sv(pTHX_ GV *gv, HV *stash, SV *namesv, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_GV_INIT_SV \ assert(gv); assert(!stash || SvTYPE(stash) == SVt_PVHV); assert(namesv) PERL_CALLCONV void -Perl_gv_name_set(pTHX_ GV *gv, const char *name, U32 len, U32 flags); +Perl_gv_name_set(pTHX_ GV *gv, const char *name, U32 len, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_NAME_SET \ assert(gv); assert(name) PERL_CALLCONV GV * -Perl_gv_override(pTHX_ const char * const name, const STRLEN len); +Perl_gv_override(pTHX_ const char * const name, const STRLEN len) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_OVERRIDE \ assert(name) PERL_CALLCONV void Perl_gv_setref(pTHX_ SV * const dsv, SV * const ssv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_GV_SETREF \ assert(dsv); assert(ssv) PERL_CALLCONV HV * -Perl_gv_stashpv(pTHX_ const char *name, I32 flags); +Perl_gv_stashpv(pTHX_ const char *name, I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_STASHPV \ assert(name) PERL_CALLCONV HV * -Perl_gv_stashpvn(pTHX_ const char *name, U32 namelen, I32 flags); +Perl_gv_stashpvn(pTHX_ const char *name, U32 namelen, I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_STASHPVN \ assert(name) PERL_CALLCONV HV * -Perl_gv_stashsv(pTHX_ SV *sv, I32 flags); +Perl_gv_stashsv(pTHX_ SV *sv, I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_STASHSV \ assert(sv) PERL_CALLCONV void -Perl_gv_try_downgrade(pTHX_ GV *gv); +Perl_gv_try_downgrade(pTHX_ GV *gv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_TRY_DOWNGRADE \ assert(gv) PERL_CALLCONV struct xpvhv_aux * Perl_hv_auxalloc(pTHX_ HV *hv) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_HV_AUXALLOC \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV AV ** Perl_hv_backreferences_p(pTHX_ HV *hv) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_HV_BACKREFERENCES_P \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV SV * Perl_hv_bucket_ratio(pTHX_ HV *hv) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_BUCKET_RATIO \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) @@ -1528,7 +1803,8 @@ Perl_hv_clear(pTHX_ HV *hv); assert(!hv || SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void -Perl_hv_clear_placeholders(pTHX_ HV *hv); +Perl_hv_clear_placeholders(pTHX_ HV *hv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_CLEAR_PLACEHOLDERS \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) @@ -1537,7 +1813,8 @@ Perl_hv_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int flags, #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); +Perl_hv_common_key_len(pTHX_ HV *hv, const char *key, I32 klen_i32, const int action, SV *val, const U32 hash) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_HV_COMMON_KEY_LEN \ assert(!hv || SvTYPE(hv) == SVt_PVHV); assert(key) @@ -1565,23 +1842,29 @@ Perl_hv_dump(pTHX_ HV *hv); PERL_CALLCONV HE ** Perl_hv_eiter_p(pTHX_ HV *hv) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_EITER_P \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void -Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter); +Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_EITER_SET \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_ename_add(pTHX_ HV *hv, const char *name, U32 len, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_HV_ENAME_ADD \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(name) PERL_CALLCONV void Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_HV_ENAME_DELETE \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(name) @@ -1601,7 +1884,8 @@ Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval); */ Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash); */ PERL_CALLCONV STRLEN -Perl_hv_fill(pTHX_ HV * const hv); +Perl_hv_fill(pTHX_ HV * const hv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_FILL \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) @@ -1611,18 +1895,22 @@ Perl_hv_free_ent(pTHX_ HV *notused, HE *entry); assert(!notused || SvTYPE(notused) == SVt_PVHV) PERL_CALLCONV I32 -Perl_hv_iterinit(pTHX_ HV *hv); +Perl_hv_iterinit(pTHX_ HV *hv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_ITERINIT \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV char * Perl_hv_iterkey(pTHX_ HE *entry, I32 *retlen) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERKEY \ assert(entry); assert(retlen) PERL_CALLCONV SV * Perl_hv_iterkeysv(pTHX_ HE *entry) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERKEYSV \ assert(entry) @@ -1633,24 +1921,31 @@ Perl_hv_iternext(pTHX_ HV *hv) PERL_CALLCONV HE * Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERNEXT_FLAGS \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV SV * Perl_hv_iternextsv(pTHX_ HV *hv, char **key, I32 *retlen) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERNEXTSV \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(key); assert(retlen) PERL_CALLCONV SV * Perl_hv_iterval(pTHX_ HV *hv, HE *entry) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERVAL \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(entry) PERL_CALLCONV void -Perl_hv_ksplit(pTHX_ HV *hv, IV newmax); +Perl_hv_ksplit(pTHX_ HV *hv, IV newmax) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_KSPLIT \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) @@ -1658,51 +1953,60 @@ Perl_hv_ksplit(pTHX_ HV *hv, IV newmax); Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how); */ PERL_CALLCONV void -Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags); +Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_NAME_SET \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV I32 Perl_hv_placeholders_get(pTHX_ const HV *hv) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_GET \ assert(hv) PERL_CALLCONV SSize_t * Perl_hv_placeholders_p(pTHX_ HV *hv) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_P \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void -Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph); +Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_SET \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_pushkv(pTHX_ HV *hv, U32 flags) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_HV_PUSHKV \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void -Perl_hv_rand_set(pTHX_ HV *hv, U32 new_xhv_rand); +Perl_hv_rand_set(pTHX_ HV *hv, U32 new_xhv_rand) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_RAND_SET \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV I32 * Perl_hv_riter_p(pTHX_ HV *hv) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_RITER_P \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void -Perl_hv_riter_set(pTHX_ HV *hv, I32 riter); +Perl_hv_riter_set(pTHX_ HV *hv, I32 riter) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_RITER_SET \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV SV * Perl_hv_scalar(pTHX_ HV *hv) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_SCALAR \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) @@ -1741,12 +2045,15 @@ Perl_ibcmp_locale(pTHX_ const char *a, const char *b, I32 len) Perl_ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ PERL_CALLCONV STRLEN -Perl_infix_plugin_standard(pTHX_ char *operator_ptr, STRLEN operator_len, struct Perl_custom_infix **def); +Perl_infix_plugin_standard(pTHX_ char *operator_ptr, STRLEN operator_len, struct Perl_custom_infix **def) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_INFIX_PLUGIN_STANDARD \ assert(operator_ptr); assert(def) PERL_CALLCONV void Perl_init_argv_symbols(pTHX_ int argc, char **argv) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS \ assert(argv) @@ -1771,7 +2078,9 @@ Perl_init_i18nl10n(pTHX_ int printwarn); #define PERL_ARGS_ASSERT_INIT_I18NL10N PERL_CALLCONV void -Perl_init_named_cv(pTHX_ CV *cv, OP *nameop); +Perl_init_named_cv(pTHX_ CV *cv, OP *nameop) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_INIT_NAMED_CV \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ assert(nameop) @@ -1781,7 +2090,8 @@ Perl_init_stacks(pTHX); #define PERL_ARGS_ASSERT_INIT_STACKS PERL_CALLCONV void -Perl_init_tm(pTHX_ struct tm *ptm); +Perl_init_tm(pTHX_ struct tm *ptm) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_INIT_TM \ assert(ptm) @@ -1810,12 +2120,15 @@ Perl_invert(pTHX_ OP *cmd) PERL_CALLCONV void Perl_invmap_dump(pTHX_ SV *invlist, UV *map) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_INVMAP_DUMP \ assert(invlist); assert(map) PERL_CALLCONV bool Perl_io_close(pTHX_ IO *io, GV *gv, bool is_explicit, bool warn_on_fail) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_IO_CLOSE \ assert(io) @@ -1860,6 +2173,8 @@ Perl_is_uni_perl_idstart_(pTHX_ UV c) PERL_CALLCONV Size_t Perl_is_utf8_FF_helper_(const U8 * const s0, const U8 * const e, const bool require_partial) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__ __attribute__pure__; #define PERL_ARGS_ASSERT_IS_UTF8_FF_HELPER_ \ @@ -1867,6 +2182,8 @@ Perl_is_utf8_FF_helper_(const U8 * const s0, const U8 * const e, const bool requ PERL_CALLCONV Size_t Perl_is_utf8_FOO_(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_FOO_ \ assert(p); assert(e) @@ -1876,6 +2193,8 @@ Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end); */ PERL_CALLCONV STRLEN Perl_is_utf8_char_helper_(const U8 * const s, const U8 *e, const U32 flags) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__ __attribute__pure__; #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_HELPER_ \ @@ -1889,12 +2208,16 @@ Perl_is_utf8_fixed_width_buf_loc_flags(const U8 * const s, STRLEN len, const U8 PERL_CALLCONV Size_t Perl_is_utf8_perl_idcont_(pTHX_ const U8 *p, const U8 * const e) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_PERL_IDCONT_ \ assert(p); assert(e) PERL_CALLCONV Size_t Perl_is_utf8_perl_idstart_(pTHX_ const U8 *p, const U8 * const e) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_PERL_IDSTART_ \ assert(p); assert(e) @@ -1922,18 +2245,21 @@ Perl_isinfnan(NV nv) PERL_CALLCONV bool Perl_isinfnansv(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_ISINFNANSV \ assert(sv) PERL_CALLCONV OP * Perl_jmaybe(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_JMAYBE \ assert(o) PERL_CALLCONV I32 Perl_keyword(pTHX_ const char *name, I32 len, bool all_keywords) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__pure__ __attribute__visibility__("hidden"); @@ -1941,12 +2267,16 @@ Perl_keyword(pTHX_ const char *name, I32 len, bool all_keywords) assert(name) PERL_CALLCONV int -Perl_keyword_plugin_standard(pTHX_ char *keyword_ptr, STRLEN keyword_len, OP **op_ptr); +Perl_keyword_plugin_standard(pTHX_ char *keyword_ptr, STRLEN keyword_len, OP **op_ptr) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_KEYWORD_PLUGIN_STANDARD \ assert(keyword_ptr); assert(op_ptr) PERL_CALLCONV void -Perl_leave_adjust_stacks(pTHX_ SV **from_sp, SV **to_sp, U8 gimme, int filter); +Perl_leave_adjust_stacks(pTHX_ SV **from_sp, SV **to_sp, U8 gimme, int filter) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_LEAVE_ADJUST_STACKS \ assert(from_sp); assert(to_sp) @@ -1959,7 +2289,8 @@ Perl_lex_bufutf8(pTHX); #define PERL_ARGS_ASSERT_LEX_BUFUTF8 PERL_CALLCONV void -Perl_lex_discard_to(pTHX_ char *ptr); +Perl_lex_discard_to(pTHX_ char *ptr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_LEX_DISCARD_TO \ assert(ptr) @@ -1980,7 +2311,8 @@ Perl_lex_read_space(pTHX_ U32 flags); #define PERL_ARGS_ASSERT_LEX_READ_SPACE PERL_CALLCONV void -Perl_lex_read_to(pTHX_ char *ptr); +Perl_lex_read_to(pTHX_ char *ptr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_LEX_READ_TO \ assert(ptr) @@ -1993,22 +2325,26 @@ 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); +Perl_lex_stuff_pv(pTHX_ const char *pv, U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_LEX_STUFF_PV \ assert(pv) PERL_CALLCONV void -Perl_lex_stuff_pvn(pTHX_ const char *pv, STRLEN len, U32 flags); +Perl_lex_stuff_pvn(pTHX_ const char *pv, STRLEN len, U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_LEX_STUFF_PVN \ assert(pv) PERL_CALLCONV void -Perl_lex_stuff_sv(pTHX_ SV *sv, U32 flags); +Perl_lex_stuff_sv(pTHX_ SV *sv, U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_LEX_STUFF_SV \ assert(sv) PERL_CALLCONV void -Perl_lex_unstuff(pTHX_ char *ptr); +Perl_lex_unstuff(pTHX_ char *ptr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_LEX_UNSTUFF \ assert(ptr) @@ -2021,95 +2357,122 @@ Perl_list(pTHX_ OP *o) assert(char_name); assert(context); assert(error_msg) PERL_CALLCONV void -Perl_load_module(pTHX_ U32 flags, SV *name, SV *ver, ...); +Perl_load_module(pTHX_ U32 flags, SV *name, SV *ver, ...) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_LOAD_MODULE \ assert(name) PERL_CALLCONV_NO_RET void Perl_locale_panic(const char *msg, const line_t immediate_caller_line, const char * const higher_caller_file, const line_t higher_caller_line) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(3) __attribute__noreturn__; #define PERL_ARGS_ASSERT_LOCALE_PANIC \ assert(msg); assert(higher_caller_file) PERL_CALLCONV OP * Perl_localize(pTHX_ OP *o, I32 lex) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_LOCALIZE \ assert(o) PERL_CALLCONV UV -Perl_long_valid_utf8_to_uv(const U8 * const s, const U8 * const e); +Perl_long_valid_utf8_to_uv(const U8 * const s, const U8 * const e) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2); #define PERL_ARGS_ASSERT_LONG_VALID_UTF8_TO_UV \ assert(s); assert(e) PERL_CALLCONV I32 Perl_looks_like_number(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_LOOKS_LIKE_NUMBER \ assert(sv) PERL_CALLCONV int Perl_magic_clear_all_env(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_cleararylen_p(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARARYLEN_P \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_clearenv(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARENV \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_clearhint(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARHINT \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_clearhints(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARHINTS \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_clearhook(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARHOOK \ assert(mg) PERL_CALLCONV int Perl_magic_clearhookall(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARHOOKALL \ assert(mg) PERL_CALLCONV int Perl_magic_clearisa(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARISA \ assert(mg) PERL_CALLCONV int Perl_magic_clearpack(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARPACK \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_clearsig(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARSIG \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_copycallchecker(pTHX_ SV *sv, MAGIC *mg, SV *nsv, const char *name, I32 namlen) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER \ assert(sv); assert(mg); assert(nsv) @@ -2120,306 +2483,408 @@ Perl_magic_dump(pTHX_ const MAGIC *mg); PERL_CALLCONV int Perl_magic_existspack(pTHX_ SV *sv, const MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_EXISTSPACK \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_freearylen_p(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_freedestruct(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_FREEDESTRUCT \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_freemglob(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_FREEMGLOB \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_freeovrld(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_FREEOVRLD \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_freeutf8(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_FREEUTF8 \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_get(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GET \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getarylen(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETARYLEN \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getdebugvar(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETDEBUGVAR \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETDEFELEM \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getnkeys(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETNKEYS \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getpack(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETPACK \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getpos(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETPOS \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getsig(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETSIG \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getsubstr(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETSUBSTR \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_gettaint(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETTAINT \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getuvar(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETUVAR \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getvec(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETVEC \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS \ assert(sv); assert(mg) PERL_CALLCONV SV * Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, U32 argc, ...) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_METHCALL \ assert(sv); assert(mg); assert(meth) PERL_CALLCONV int Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_NEXTPACK \ assert(sv); assert(mg); assert(key) PERL_CALLCONV U32 Perl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_REGDATA_CNT \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET \ assert(sv); assert(mg) PERL_CALLCONV SV * Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SCALARPACK \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(mg) PERL_CALLCONV int Perl_magic_set(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SET \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_set_all_env(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SET_ALL_ENV \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setarylen(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETARYLEN \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setdbline(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETDBLINE \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setdebugvar(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETDEBUGVAR \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setdefelem(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETDEFELEM \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setenv(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETENV \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_sethint(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETHINT \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_sethook(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETHOOK \ assert(mg) PERL_CALLCONV int Perl_magic_sethookall(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETHOOKALL \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setisa(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETISA \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setlvref(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETLVREF \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setmglob(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETMGLOB \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setnkeys(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETNKEYS \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setnonelem(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETNONELEM \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setpack(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETPACK \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setpos(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETPOS \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setregexp(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETREGEXP \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setsig(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETSIG \ assert(mg) PERL_CALLCONV int Perl_magic_setsigall(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETSIGALL \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setsubstr(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETSUBSTR \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_settaint(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETTAINT \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setutf8(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETUTF8 \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setuvar(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETUVAR \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setvec(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETVEC \ assert(sv); assert(mg) PERL_CALLCONV U32 Perl_magic_sizepack(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SIZEPACK \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_wipepack(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_WIPEPACK \ assert(sv); assert(mg) @@ -2438,12 +2903,14 @@ Perl_markstack_grow(pTHX); PERL_CALLCONV SV * Perl_mess(pTHX_ const char *pat, ...) + Perl_attribute_nonnull_(pTHX_1) __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_MESS \ assert(pat) PERL_CALLCONV SV * -Perl_mess_sv(pTHX_ SV *basemsg, bool consume); +Perl_mess_sv(pTHX_ SV *basemsg, bool consume) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MESS_SV \ assert(basemsg) @@ -2452,12 +2919,15 @@ Perl_mfree(Malloc_t where); #define PERL_ARGS_ASSERT_MFREE PERL_CALLCONV int -Perl_mg_clear(pTHX_ SV *sv); +Perl_mg_clear(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MG_CLEAR \ assert(sv) PERL_CALLCONV int -Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen); +Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_MG_COPY \ assert(sv); assert(nsv) @@ -2475,48 +2945,58 @@ Perl_mg_findext(const SV *sv, int type, const MGVTBL *vtbl) #define PERL_ARGS_ASSERT_MG_FINDEXT PERL_CALLCONV int -Perl_mg_free(pTHX_ SV *sv); +Perl_mg_free(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MG_FREE \ assert(sv) PERL_CALLCONV void -Perl_mg_free_type(pTHX_ SV *sv, int how); +Perl_mg_free_type(pTHX_ SV *sv, int how) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MG_FREE_TYPE \ assert(sv) PERL_CALLCONV void -Perl_mg_freeext(pTHX_ SV *sv, int how, const MGVTBL *vtbl); +Perl_mg_freeext(pTHX_ SV *sv, int how, const MGVTBL *vtbl) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MG_FREEEXT \ assert(sv) PERL_CALLCONV int -Perl_mg_get(pTHX_ SV *sv); +Perl_mg_get(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MG_GET \ assert(sv) PERL_CALLCONV void Perl_mg_localize(pTHX_ SV *sv, SV *nsv, bool setmagic) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MG_LOCALIZE \ assert(sv); assert(nsv) PERL_CALLCONV void -Perl_mg_magical(SV *sv); +Perl_mg_magical(SV *sv) + Perl_attribute_nonnull_(1); #define PERL_ARGS_ASSERT_MG_MAGICAL \ assert(sv) PERL_CALLCONV int -Perl_mg_set(pTHX_ SV *sv); +Perl_mg_set(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MG_SET \ assert(sv) PERL_CALLCONV I32 -Perl_mg_size(pTHX_ SV *sv); +Perl_mg_size(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MG_SIZE \ assert(sv) PERL_CALLCONV void -Perl_mini_mktime(struct tm *ptm); +Perl_mini_mktime(struct tm *ptm) + Perl_attribute_nonnull_(1); #define PERL_ARGS_ASSERT_MINI_MKTIME \ assert(ptm) @@ -2530,12 +3010,14 @@ Perl_more_bodies(pTHX_ const svtype sv_type); #define PERL_ARGS_ASSERT_MORE_BODIES PERL_CALLCONV const char * -Perl_moreswitches(pTHX_ const char *s); +Perl_moreswitches(pTHX_ const char *s) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MORESWITCHES \ assert(s) PERL_CALLCONV void -Perl_mortal_destructor_sv(pTHX_ SV *coderef, SV *args); +Perl_mortal_destructor_sv(pTHX_ SV *coderef, SV *args) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MORTAL_DESTRUCTOR_SV \ assert(coderef) @@ -2544,54 +3026,68 @@ Perl_mortal_svfunc_x(pTHX_ SVFUNC_t f, SV *p); #define PERL_ARGS_ASSERT_MORTAL_SVFUNC_X PERL_CALLCONV const struct mro_alg * -Perl_mro_get_from_name(pTHX_ SV *name); +Perl_mro_get_from_name(pTHX_ SV *name) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MRO_GET_FROM_NAME \ assert(name) PERL_CALLCONV AV * -Perl_mro_get_linear_isa(pTHX_ HV *stash); +Perl_mro_get_linear_isa(pTHX_ HV *stash) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV SV * -Perl_mro_get_private_data(pTHX_ struct mro_meta * const smeta, const struct mro_alg * const which); +Perl_mro_get_private_data(pTHX_ struct mro_meta * const smeta, const struct mro_alg * const which) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_MRO_GET_PRIVATE_DATA \ assert(smeta); assert(which) PERL_CALLCONV void Perl_mro_isa_changed_in(pTHX_ HV *stash) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV struct mro_meta * -Perl_mro_meta_init(pTHX_ HV *stash); +Perl_mro_meta_init(pTHX_ HV *stash) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MRO_META_INIT \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void -Perl_mro_method_changed_in(pTHX_ HV *stash); +Perl_mro_method_changed_in(pTHX_ HV *stash) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void -Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash, const GV * const gv, U32 flags); +Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash, const GV * const gv, U32 flags) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_MRO_PACKAGE_MOVED \ assert(!stash || SvTYPE(stash) == SVt_PVHV); \ assert(!oldstash || SvTYPE(oldstash) == SVt_PVHV); assert(gv) PERL_CALLCONV void -Perl_mro_register(pTHX_ const struct mro_alg *mro); +Perl_mro_register(pTHX_ const struct mro_alg *mro) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MRO_REGISTER \ assert(mro) PERL_CALLCONV void -Perl_mro_set_mro(pTHX_ struct mro_meta * const meta, SV * const name); +Perl_mro_set_mro(pTHX_ struct mro_meta * const meta, SV * const name) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_MRO_SET_MRO \ assert(meta); assert(name) PERL_CALLCONV SV * -Perl_mro_set_private_data(pTHX_ struct mro_meta * const smeta, const struct mro_alg * const which, SV * const data); +Perl_mro_set_private_data(pTHX_ struct mro_meta * const smeta, const struct mro_alg * const which, SV * const data) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA \ assert(smeta); assert(which); assert(data) @@ -2603,22 +3099,28 @@ Perl_mro_set_private_data(pTHX_ struct mro_meta * const smeta, const struct mro_ assert(!cv || SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV NV -Perl_my_atof(pTHX_ const char *s); +Perl_my_atof(pTHX_ const char *s) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MY_ATOF \ assert(s) PERL_CALLCONV char * -Perl_my_atof2(pTHX_ const char *orig, NV *value); +Perl_my_atof2(pTHX_ const char *orig, NV *value) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_MY_ATOF2 \ assert(orig); assert(value) PERL_CALLCONV char * -Perl_my_atof3(pTHX_ const char *orig, NV *value, const STRLEN len); +Perl_my_atof3(pTHX_ const char *orig, NV *value, const STRLEN len) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_MY_ATOF3 \ assert(orig); assert(value) PERL_CALLCONV OP * Perl_my_attrs(pTHX_ OP *o, OP *attrs) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MY_ATTRS \ assert(o) @@ -2658,6 +3160,7 @@ Perl_my_lstat_flags(pTHX_ const U32 flags); PERL_CALLCONV int Perl_my_mkostemp_cloexec(char *templte, int flags) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MY_MKOSTEMP_CLOEXEC \ @@ -2665,13 +3168,16 @@ Perl_my_mkostemp_cloexec(char *templte, int flags) PERL_CALLCONV int Perl_my_mkstemp_cloexec(char *templte) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MY_MKSTEMP_CLOEXEC \ assert(templte) PERL_CALLCONV PerlIO * -Perl_my_popen_list(pTHX_ const char *mode, int n, SV **args); +Perl_my_popen_list(pTHX_ const char *mode, int n, SV **args) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_MY_POPEN_LIST \ assert(mode); assert(args) @@ -2681,6 +3187,8 @@ Perl_my_setenv(pTHX_ const char *nam, const char *val); PERL_CALLCONV int Perl_my_snprintf(char *buffer, const Size_t len, const char *format, ...) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(3) __attribute__format__(__printf__,3,4); #define PERL_ARGS_ASSERT_MY_SNPRINTF \ assert(buffer); assert(format) @@ -2698,18 +3206,21 @@ Perl_my_stat_flags(pTHX_ const U32 flags); PERL_CALLCONV const char * Perl_my_strerror(pTHX_ const int errnum, utf8ness_t *utf8ness) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MY_STRERROR \ assert(utf8ness) 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) + Perl_attribute_nonnull_(pTHX_1) __attribute__format__(__strftime__,pTHX_1,0); #define PERL_ARGS_ASSERT_MY_STRFTIME \ assert(fmt) PERL_CALLCONV NV Perl_my_strtod(const char * const s, char **e) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_MY_STRTOD \ assert(s) @@ -2720,7 +3231,9 @@ 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); +Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(3); #define PERL_ARGS_ASSERT_MY_VSNPRINTF \ assert(buffer); assert(format) @@ -2744,6 +3257,7 @@ Perl_newANONSUB(pTHX_ I32 floor, OP *proto, OP *block); PERL_CALLCONV OP * Perl_newARGDEFELEMOP(pTHX_ I32 flags, OP *expr, I32 argindex) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWARGDEFELEMOP \ assert(expr) @@ -2766,6 +3280,7 @@ Perl_newAV(pTHX) PERL_CALLCONV OP * Perl_newAVREF(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWAVREF \ assert(o) @@ -2801,6 +3316,7 @@ Perl_newBINOP(pTHX_ I32 type, I32 flags, OP *first, OP *last) PERL_CALLCONV OP * Perl_newCONDOP(pTHX_ I32 flags, OP *first, OP *trueop, OP *falseop) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWCONDOP \ assert(first) @@ -2822,6 +3338,7 @@ Perl_newCVREF(pTHX_ I32 flags, OP *o) PERL_CALLCONV OP * Perl_newDEFEROP(pTHX_ I32 flags, OP *block) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWDEFEROP \ assert(block) @@ -2837,23 +3354,28 @@ Perl_newFORM(pTHX_ I32 floor, OP *o, OP *block); PERL_CALLCONV OP * Perl_newFOROP(pTHX_ I32 flags, OP *sv, OP *expr, OP *block, OP *cont) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWFOROP \ assert(expr) PERL_CALLCONV OP * Perl_newGIVENOP(pTHX_ OP *cond, OP *block, PADOFFSET defsv_off) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWGIVENOP \ assert(cond); assert(block) PERL_CALLCONV GP * -Perl_newGP(pTHX_ GV * const gv); +Perl_newGP(pTHX_ GV * const gv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_NEWGP \ assert(gv) PERL_CALLCONV OP * Perl_newGVOP(pTHX_ I32 type, I32 flags, GV *gv) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWGVOP \ assert(gv) @@ -2868,6 +3390,7 @@ Perl_newGVgen(pTHX_ const char *pack); */ PERL_CALLCONV GV * Perl_newGVgen_flags(pTHX_ const char *pack, U32 flags) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWGVGEN_FLAGS \ assert(pack) @@ -2878,6 +3401,7 @@ Perl_newHV(pTHX) PERL_CALLCONV OP * Perl_newHVREF(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWHVREF \ assert(o) @@ -2904,36 +3428,43 @@ Perl_newLISTOPn(pTHX_ I32 type, I32 flags, ...) PERL_CALLCONV OP * Perl_newLOGOP(pTHX_ I32 optype, I32 flags, OP *first, OP *other) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWLOGOP \ assert(first); assert(other) PERL_CALLCONV OP * Perl_newLOOPEX(pTHX_ I32 type, OP *label) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWLOOPEX \ assert(label) PERL_CALLCONV OP * Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP *expr, OP *block) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWLOOPOP \ assert(expr) PERL_CALLCONV OP * Perl_newMETHOP(pTHX_ I32 type, I32 flags, OP *dynamic_meth) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWMETHOP \ assert(dynamic_meth) PERL_CALLCONV OP * Perl_newMETHOP_named(pTHX_ I32 type, I32 flags, SV * const_meth) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWMETHOP_NAMED \ assert(const_meth) PERL_CALLCONV CV * -Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); +Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_NEWMYSUB \ assert(o) @@ -2954,12 +3485,14 @@ Perl_newPADNAMELIST(size_t max) PERL_CALLCONV PADNAME * Perl_newPADNAMEouter(PADNAME *outer) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWPADNAMEOUTER \ assert(outer) PERL_CALLCONV PADNAME * Perl_newPADNAMEpvn(const char *s, STRLEN len) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWPADNAMEPVN \ assert(s) @@ -2970,7 +3503,8 @@ Perl_newPMOP(pTHX_ I32 type, I32 flags) #define PERL_ARGS_ASSERT_NEWPMOP PERL_CALLCONV void -Perl_newPROG(pTHX_ OP *o); +Perl_newPROG(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_NEWPROG \ assert(o) @@ -2981,12 +3515,15 @@ Perl_newPVOP(pTHX_ I32 type, I32 flags, char *pv) PERL_CALLCONV OP * Perl_newRANGE(pTHX_ I32 flags, OP *left, OP *right) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWRANGE \ assert(left); assert(right) PERL_CALLCONV SV * Perl_newRV(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWRV \ assert(sv) @@ -3003,6 +3540,7 @@ Perl_newSTATEOP(pTHX_ I32 flags, char *label, OP *o) PERL_CALLCONV CV * Perl_newSTUB(pTHX_ GV *gv, bool fake) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_NEWSTUB \ assert(gv) @@ -3017,12 +3555,14 @@ Perl_newSV(pTHX_ const STRLEN len) PERL_CALLCONV OP * Perl_newSVOP(pTHX_ I32 type, I32 flags, SV *sv) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVOP \ assert(sv) PERL_CALLCONV OP * Perl_newSVREF(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVREF \ assert(o) @@ -3039,6 +3579,7 @@ Perl_newSV_true(pTHX) PERL_CALLCONV SV * Perl_newSVavdefelem(pTHX_ AV *av, SSize_t ix, bool extendible) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_NEWSVAVDEFELEM \ @@ -3081,6 +3622,7 @@ Perl_newSVpv_share(pTHX_ const char *s, U32 hash) PERL_CALLCONV SV * Perl_newSVpvf(pTHX_ const char * const pat, ...) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_NEWSVPVF \ @@ -3107,7 +3649,8 @@ Perl_newSVpvz(pTHX_ const STRLEN len) #define PERL_ARGS_ASSERT_NEWSVPVZ PERL_CALLCONV SV * -Perl_newSVrv(pTHX_ SV * const rv, const char * const classname); +Perl_newSVrv(pTHX_ SV * const rv, const char * const classname) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_NEWSVRV \ assert(rv) @@ -3117,6 +3660,7 @@ Perl_newSVsv(pTHX_ SV * const old) PERL_CALLCONV SV * Perl_newSVsv_flags_NN(pTHX_ SV * const old, I32 flags) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVSV_FLAGS_NN \ assert(old) @@ -3132,6 +3676,9 @@ Perl_newSVuv(pTHX_ const UV u) PERL_CALLCONV OP * Perl_newTRYCATCHOP(pTHX_ I32 flags, OP *tryblock, OP *catchvar, OP *catchblock) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWTRYCATCHOP \ assert(tryblock); assert(catchvar); assert(catchblock) @@ -3148,6 +3695,7 @@ Perl_newUNOP_AUX(pTHX_ I32 type, I32 flags, OP *first, UNOP_AUX_item *aux) PERL_CALLCONV OP * Perl_newWHENOP(pTHX_ OP *cond, OP *block) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWWHENOP \ assert(block) @@ -3158,22 +3706,29 @@ Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP *loop, OP *expr, OP *block #define PERL_ARGS_ASSERT_NEWWHILEOP PERL_CALLCONV CV * -Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename); +Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_NEWXS \ assert(subaddr); assert(filename) PERL_CALLCONV CV * -Perl_newXS_deffile(pTHX_ const char *name, XSUBADDR_t subaddr); +Perl_newXS_deffile(pTHX_ const char *name, XSUBADDR_t subaddr) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_NEWXS_DEFFILE \ assert(name); assert(subaddr) PERL_CALLCONV CV * -Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr, const char * const filename, const char * const proto, U32 flags); +Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr, const char * const filename, const char * const proto, U32 flags) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_NEWXS_FLAGS \ assert(subaddr); assert(filename) PERL_CALLCONV CV * Perl_newXS_len_flags(pTHX_ const char *name, STRLEN len, XSUBADDR_t subaddr, const char * const filename, const char * const proto, SV ** const_svp, U32 flags) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_NEWXS_LEN_FLAGS \ assert(subaddr) @@ -3189,7 +3744,8 @@ Perl_new_stackinfo_flags(pTHX_ I32 stitems, I32 cxitems, UV flags) #define PERL_ARGS_ASSERT_NEW_STACKINFO_FLAGS PERL_CALLCONV SV * -Perl_new_version(pTHX_ SV *ver); +Perl_new_version(pTHX_ SV *ver) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_NEW_VERSION \ assert(ver) @@ -3198,12 +3754,17 @@ Perl_new_version(pTHX_ SV *ver); PERL_CALLCONV PerlIO * Perl_nextargv(pTHX_ GV *gv, bool nomagicopen) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_NEXTARGV \ assert(gv) PERL_CALLCONV char * Perl_ninstr(const char *big, const char *bigend, const char *little, const char *lend) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(3) + Perl_attribute_nonnull_(4) __attribute__warn_unused_result__ __attribute__pure__; #define PERL_ARGS_ASSERT_NINSTR \ @@ -3211,12 +3772,14 @@ Perl_ninstr(const char *big, const char *bigend, const char *little, const char PERL_CALLCONV void Perl_no_bareword_filehandle(pTHX_ const char *fhname) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_NO_BAREWORD_FILEHANDLE \ assert(fhname) PERL_CALLCONV_NO_RET void Perl_noperl_die(const char *pat, ...) + Perl_attribute_nonnull_(1) __attribute__noreturn__ __attribute__format__(__printf__,1,2); #define PERL_ARGS_ASSERT_NOPERL_DIE \ @@ -3237,6 +3800,7 @@ Perl_notify_parser_that_encoding_changed(pTHX) PERL_CALLCONV OP * Perl_oopsAV(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_OOPSAV \ @@ -3244,6 +3808,7 @@ Perl_oopsAV(pTHX_ OP *o) PERL_CALLCONV OP * Perl_oopsHV(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_OOPSHV \ @@ -3265,7 +3830,8 @@ Perl_op_class(pTHX_ const OP *o); assert(o) PERL_CALLCONV OP * -Perl_op_contextualize(pTHX_ OP *o, I32 context); +Perl_op_contextualize(pTHX_ OP *o, I32 context) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_OP_CONTEXTUALIZE \ assert(o) @@ -3275,7 +3841,8 @@ Perl_op_convert_list(pTHX_ I32 optype, I32 flags, OP *o) #define PERL_ARGS_ASSERT_OP_CONVERT_LIST PERL_CALLCONV void -Perl_op_dump(pTHX_ const OP *o); +Perl_op_dump(pTHX_ const OP *o) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_OP_DUMP \ assert(o) @@ -3288,7 +3855,8 @@ Perl_op_free(pTHX_ OP *arg); #define PERL_ARGS_ASSERT_OP_FREE PERL_CALLCONV OP * -Perl_op_linklist(pTHX_ OP *o); +Perl_op_linklist(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_OP_LINKLIST \ assert(o) @@ -3300,12 +3868,14 @@ 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); +Perl_op_null(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_OP_NULL \ assert(o) PERL_CALLCONV OP * -Perl_op_parent(OP *o); +Perl_op_parent(OP *o) + Perl_attribute_nonnull_(1); #define PERL_ARGS_ASSERT_OP_PARENT \ assert(o) @@ -3336,60 +3906,76 @@ Perl_op_unscope(pTHX_ OP *o) PERL_CALLCONV OP * Perl_op_wrap_finally(pTHX_ OP *block, OP *finally) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_OP_WRAP_FINALLY \ assert(block); assert(finally) PERL_CALLCONV void Perl_opdump_printf(pTHX_ struct Perl_OpDumpContext *ctx, const char *pat, ...) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_OPDUMP_PRINTF \ assert(ctx); assert(pat) PERL_CALLCONV void Perl_package(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PACKAGE \ assert(o) PERL_CALLCONV void Perl_package_version(pTHX_ OP *v) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PACKAGE_VERSION \ assert(v) PERL_CALLCONV void -Perl_packlist(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist); +Perl_packlist(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5); #define PERL_ARGS_ASSERT_PACKLIST \ assert(cat); assert(pat); assert(patend); assert(beglist); \ assert(endlist) PERL_CALLCONV PADOFFSET -Perl_pad_add_anon(pTHX_ CV *func, I32 optype); +Perl_pad_add_anon(pTHX_ CV *func, I32 optype) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_ADD_ANON \ assert(func); \ assert(SvTYPE(func) == SVt_PVCV || SvTYPE(func) == SVt_PVFM) PERL_CALLCONV PADOFFSET -Perl_pad_add_name_pv(pTHX_ const char *name, const U32 flags, HV *typestash, HV *ourstash); +Perl_pad_add_name_pv(pTHX_ const char *name, const U32 flags, HV *typestash, HV *ourstash) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PV \ assert(name); assert(!typestash || SvTYPE(typestash) == SVt_PVHV); \ assert(!ourstash || SvTYPE(ourstash) == SVt_PVHV) PERL_CALLCONV PADOFFSET -Perl_pad_add_name_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags, HV *typestash, HV *ourstash); +Perl_pad_add_name_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags, HV *typestash, HV *ourstash) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PVN \ assert(namepv); assert(!typestash || SvTYPE(typestash) == SVt_PVHV); \ assert(!ourstash || SvTYPE(ourstash) == SVt_PVHV) PERL_CALLCONV PADOFFSET -Perl_pad_add_name_sv(pTHX_ SV *name, U32 flags, HV *typestash, HV *ourstash); +Perl_pad_add_name_sv(pTHX_ SV *name, U32 flags, HV *typestash, HV *ourstash) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_ADD_NAME_SV \ assert(name); assert(!typestash || SvTYPE(typestash) == SVt_PVHV); \ assert(!ourstash || SvTYPE(ourstash) == SVt_PVHV) PERL_CALLCONV void Perl_pad_add_weakref(pTHX_ CV *func) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PAD_ADD_WEAKREF \ assert(func); \ @@ -3405,22 +3991,28 @@ Perl_pad_block_start(pTHX_ int full) #define PERL_ARGS_ASSERT_PAD_BLOCK_START PERL_CALLCONV PADOFFSET -Perl_pad_findmy_pv(pTHX_ const char *name, U32 flags); +Perl_pad_findmy_pv(pTHX_ const char *name, U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_FINDMY_PV \ assert(name) PERL_CALLCONV PADOFFSET -Perl_pad_findmy_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags); +Perl_pad_findmy_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_FINDMY_PVN \ assert(namepv) PERL_CALLCONV PADOFFSET -Perl_pad_findmy_sv(pTHX_ SV *name, U32 flags); +Perl_pad_findmy_sv(pTHX_ SV *name, U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_FINDMY_SV \ assert(name) PERL_CALLCONV void Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PAD_FIXUP_INNER_ANONS \ assert(padlist); assert(old_cv); \ @@ -3444,7 +4036,8 @@ Perl_pad_new(pTHX_ int flags) #define PERL_ARGS_ASSERT_PAD_NEW PERL_CALLCONV void -Perl_pad_push(pTHX_ PADLIST *padlist, int depth); +Perl_pad_push(pTHX_ PADLIST *padlist, int depth) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_PUSH \ assert(padlist) @@ -3459,28 +4052,33 @@ Perl_pad_tidy(pTHX_ padtidy_type type); PERL_CALLCONV PAD ** Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PADLIST_STORE \ assert(padlist) PERL_CALLCONV void -Perl_padname_free(pTHX_ PADNAME *pn); +Perl_padname_free(pTHX_ PADNAME *pn) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PADNAME_FREE \ assert(pn) PERL_CALLCONV PADNAME * Perl_padnamelist_fetch(PADNAMELIST *pnl, SSize_t key) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_PADNAMELIST_FETCH \ assert(pnl) PERL_CALLCONV void -Perl_padnamelist_free(pTHX_ PADNAMELIST *pnl); +Perl_padnamelist_free(pTHX_ PADNAMELIST *pnl) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PADNAMELIST_FREE \ assert(pnl) PERL_CALLCONV PADNAME ** -Perl_padnamelist_store(pTHX_ PADNAMELIST *pnl, SSize_t key, PADNAME *val); +Perl_padnamelist_store(pTHX_ PADNAMELIST *pnl, SSize_t key, PADNAME *val) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PADNAMELIST_STORE \ assert(pnl) @@ -3526,12 +4124,14 @@ Perl_parse_termexpr(pTHX_ U32 flags); PERL_CALLCONV U32 Perl_parse_unicode_opts(pTHX_ const char **popt) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PARSE_UNICODE_OPTS \ assert(popt) PERL_CALLCONV void Perl_parser_free(pTHX_ const yy_parser *parser) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PARSER_FREE \ assert(parser) @@ -3546,27 +4146,32 @@ perl_alloc(void); #define PERL_ARGS_ASSERT_PERL_ALLOC PERL_CALLCONV void -perl_construct(PerlInterpreter *my_perl); +perl_construct(PerlInterpreter *my_perl) + Perl_attribute_nonnull_(1); #define PERL_ARGS_ASSERT_PERL_CONSTRUCT \ assert(my_perl) PERL_CALLCONV int -perl_destruct(PerlInterpreter *my_perl); +perl_destruct(PerlInterpreter *my_perl) + Perl_attribute_nonnull_(1); #define PERL_ARGS_ASSERT_PERL_DESTRUCT \ assert(my_perl) PERL_CALLCONV void -perl_free(PerlInterpreter *my_perl); +perl_free(PerlInterpreter *my_perl) + Perl_attribute_nonnull_(1); #define PERL_ARGS_ASSERT_PERL_FREE \ assert(my_perl) PERL_CALLCONV int -perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char **argv, char **env); +perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char **argv, char **env) + Perl_attribute_nonnull_(1); #define PERL_ARGS_ASSERT_PERL_PARSE \ assert(my_perl) PERL_CALLCONV int -perl_run(PerlInterpreter *my_perl); +perl_run(PerlInterpreter *my_perl) + Perl_attribute_nonnull_(1); #define PERL_ARGS_ASSERT_PERL_RUN \ assert(my_perl) @@ -3583,6 +4188,8 @@ Perl_pmop_dump(pTHX_ PMOP *pm); PERL_CALLCONV OP * Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl, UV flags, I32 floor) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PMRUNTIME \ assert(o); assert(expr) @@ -3593,17 +4200,24 @@ Perl_pop_scope(pTHX); PERL_CALLCONV void Perl_populate_isa(pTHX_ const char *name, STRLEN len, ...) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_POPULATE_ISA \ assert(name) PERL_CALLCONV REGEXP * -Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags); +Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PREGCOMP \ assert(pattern) PERL_CALLCONV I32 -Perl_pregexec(pTHX_ REGEXP * const prog, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *screamer, U32 nosave); +Perl_pregexec(pTHX_ REGEXP * const prog, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *screamer, U32 nosave) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_6); #define PERL_ARGS_ASSERT_PREGEXEC \ assert(prog); assert(stringarg); assert(strend); assert(strbeg); \ assert(screamer) @@ -3613,17 +4227,20 @@ Perl_pregfree(pTHX_ REGEXP *r); #define PERL_ARGS_ASSERT_PREGFREE PERL_CALLCONV void -Perl_pregfree2(pTHX_ REGEXP *rx); +Perl_pregfree2(pTHX_ REGEXP *rx) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PREGFREE2 \ assert(rx) PERL_CALLCONV const char * -Perl_prescan_version(pTHX_ const char *s, bool strict, const char **errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha); +Perl_prescan_version(pTHX_ const char *s, bool strict, const char **errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PRESCAN_VERSION \ assert(s) PERL_CALLCONV void * Perl_ptr_table_fetch(pTHX_ PTR_TBL_t * const tbl, const void * const sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_PTR_TABLE_FETCH \ assert(tbl) @@ -3638,12 +4255,15 @@ Perl_ptr_table_new(pTHX) #define PERL_ARGS_ASSERT_PTR_TABLE_NEW PERL_CALLCONV void -Perl_ptr_table_split(pTHX_ PTR_TBL_t * const tbl); +Perl_ptr_table_split(pTHX_ PTR_TBL_t * const tbl) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PTR_TABLE_SPLIT \ assert(tbl) PERL_CALLCONV void -Perl_ptr_table_store(pTHX_ PTR_TBL_t * const tbl, const void * const oldsv, void * const newsv); +Perl_ptr_table_store(pTHX_ PTR_TBL_t * const tbl, const void * const oldsv, void * const newsv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_PTR_TABLE_STORE \ assert(tbl); assert(newsv) @@ -3652,22 +4272,29 @@ 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); +Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_PV_DISPLAY \ assert(dsv); assert(pv) PERL_CALLCONV char * -Perl_pv_escape(pTHX_ SV *dsv, char const * const str, const STRLEN count, STRLEN max, STRLEN * const escaped, U32 flags); +Perl_pv_escape(pTHX_ SV *dsv, char const * const str, const STRLEN count, STRLEN max, STRLEN * const escaped, U32 flags) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_PV_ESCAPE \ assert(str) PERL_CALLCONV char * -Perl_pv_pretty(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags); +Perl_pv_pretty(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_PV_PRETTY \ assert(dsv); assert(str) PERL_CALLCONV char * -Perl_pv_uni_display(pTHX_ SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV flags); +Perl_pv_uni_display(pTHX_ SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_PV_UNI_DISPLAY \ assert(dsv); assert(spv) @@ -3688,22 +4315,29 @@ Perl_rcpv_new(pTHX_ const char * const pv, STRLEN len, U32 flags) #define PERL_ARGS_ASSERT_RCPV_NEW PERL_CALLCONV REGEXP * -Perl_re_compile(pTHX_ SV * const pattern, U32 orig_rx_flags); +Perl_re_compile(pTHX_ SV * const pattern, U32 orig_rx_flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_RE_COMPILE \ assert(pattern) PERL_CALLCONV char * -Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV *sv, const char * const strbeg, char *strpos, char *strend, const U32 flags, re_scream_pos_data *data); +Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV *sv, const char * const strbeg, char *strpos, char *strend, const U32 flags, re_scream_pos_data *data) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5); #define PERL_ARGS_ASSERT_RE_INTUIT_START \ assert(rx); assert(strbeg); assert(strpos); assert(strend) PERL_CALLCONV SV * -Perl_re_intuit_string(pTHX_ REGEXP * const r); +Perl_re_intuit_string(pTHX_ REGEXP * const r) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_RE_INTUIT_STRING \ assert(r) PERL_CALLCONV REGEXP * -Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, OP *expr, const regexp_engine *eng, REGEXP *old_re, bool *is_bare_re, const U32 rx_flags, const U32 pm_flags); +Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, OP *expr, const regexp_engine *eng, REGEXP *old_re, bool *is_bare_re, const U32 rx_flags, const U32 pm_flags) + Perl_attribute_nonnull_(pTHX_4); #define PERL_ARGS_ASSERT_RE_OP_COMPILE \ assert(eng) @@ -3721,7 +4355,8 @@ Perl_reentrant_init(pTHX); #define PERL_ARGS_ASSERT_REENTRANT_INIT PERL_CALLCONV void * -Perl_reentrant_retry(const char *f, ...); +Perl_reentrant_retry(const char *f, ...) + Perl_attribute_nonnull_(1); #define PERL_ARGS_ASSERT_REENTRANT_RETRY \ assert(f) @@ -3734,17 +4369,20 @@ 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); +Perl_refcounted_he_fetch_pv(pTHX_ const struct refcounted_he *chain, const char *key, U32 hash, U32 flags) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PV \ assert(key) PERL_CALLCONV SV * -Perl_refcounted_he_fetch_pvn(pTHX_ const struct refcounted_he *chain, const char *keypv, STRLEN keylen, U32 hash, U32 flags); +Perl_refcounted_he_fetch_pvn(pTHX_ const struct refcounted_he *chain, const char *keypv, STRLEN keylen, U32 hash, U32 flags) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PVN \ assert(keypv) PERL_CALLCONV SV * -Perl_refcounted_he_fetch_sv(pTHX_ const struct refcounted_he *chain, SV *key, U32 hash, U32 flags); +Perl_refcounted_he_fetch_sv(pTHX_ const struct refcounted_he *chain, SV *key, U32 hash, U32 flags) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_SV \ assert(key) @@ -3757,17 +4395,20 @@ 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); +Perl_refcounted_he_new_pv(pTHX_ struct refcounted_he *parent, const char *key, U32 hash, SV *value, U32 flags) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PV \ assert(key) PERL_CALLCONV struct refcounted_he * -Perl_refcounted_he_new_pvn(pTHX_ struct refcounted_he *parent, const char *keypv, STRLEN keylen, U32 hash, SV *value, U32 flags); +Perl_refcounted_he_new_pvn(pTHX_ struct refcounted_he *parent, const char *keypv, STRLEN keylen, U32 hash, SV *value, U32 flags) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PVN \ assert(keypv) PERL_CALLCONV struct refcounted_he * -Perl_refcounted_he_new_sv(pTHX_ struct refcounted_he *parent, SV *key, U32 hash, SV *value, U32 flags); +Perl_refcounted_he_new_sv(pTHX_ struct refcounted_he *parent, SV *key, U32 hash, SV *value, U32 flags) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_SV \ assert(key) @@ -3775,22 +4416,28 @@ Perl_refcounted_he_new_sv(pTHX_ struct refcounted_he *parent, SV *key, U32 hash, assert(rx) PERL_CALLCONV SV * -Perl_reg_named_buff_all(pTHX_ REGEXP * const rx, const U32 flags); +Perl_reg_named_buff_all(pTHX_ REGEXP * const rx, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ALL \ assert(rx) PERL_CALLCONV bool -Perl_reg_named_buff_exists(pTHX_ REGEXP * const rx, SV * const key, const U32 flags); +Perl_reg_named_buff_exists(pTHX_ REGEXP * const rx, SV * const key, const U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_EXISTS \ assert(rx); assert(key) PERL_CALLCONV SV * -Perl_reg_named_buff_fetch(pTHX_ REGEXP * const rx, SV * const namesv, const U32 flags); +Perl_reg_named_buff_fetch(pTHX_ REGEXP * const rx, SV * const namesv, const U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FETCH \ assert(rx); assert(namesv) PERL_CALLCONV SV * -Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const rx, const U32 flags); +Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const rx, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FIRSTKEY \ assert(rx) @@ -3798,12 +4445,14 @@ Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const rx, const U32 flags); assert(rx) PERL_CALLCONV SV * -Perl_reg_named_buff_nextkey(pTHX_ REGEXP * const rx, const U32 flags); +Perl_reg_named_buff_nextkey(pTHX_ REGEXP * const rx, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_NEXTKEY \ assert(rx) PERL_CALLCONV SV * -Perl_reg_named_buff_scalar(pTHX_ REGEXP * const rx, const U32 flags); +Perl_reg_named_buff_scalar(pTHX_ REGEXP * const rx, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_SCALAR \ assert(rx) @@ -3826,18 +4475,25 @@ Perl_reg_named_buff_scalar(pTHX_ REGEXP * const rx, const U32 flags); assert(ssv) PERL_CALLCONV void -Perl_regdump(pTHX_ const regexp *r); +Perl_regdump(pTHX_ const regexp *r) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_REGDUMP \ assert(r) PERL_CALLCONV I32 -Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *sv, void *data, U32 flags); +Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *sv, void *data, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_6); #define PERL_ARGS_ASSERT_REGEXEC_FLAGS \ assert(rx); assert(stringarg); assert(strend); assert(strbeg); \ assert(sv) PERL_CALLCONV void -Perl_regfree_internal(pTHX_ REGEXP * const rx); +Perl_regfree_internal(pTHX_ REGEXP * const rx) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_REGFREE_INTERNAL \ assert(rx) @@ -3847,12 +4503,15 @@ Perl_reginitcolors(pTHX); PERL_CALLCONV void Perl_release_RExC_state(pTHX_ void *vstate) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_RELEASE_REXC_STATE \ assert(vstate) PERL_CALLCONV void -Perl_repeatcpy(char *to, const char *from, SSize_t len, IV count); +Perl_repeatcpy(char *to, const char *from, SSize_t len, IV count) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2); #define PERL_ARGS_ASSERT_REPEATCPY \ assert(to); assert(from) @@ -3869,12 +4528,14 @@ 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); +Perl_require_pv(pTHX_ const char *pv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_REQUIRE_PV \ assert(pv) PERL_CALLCONV void -Perl_resume_compcv(pTHX_ struct suspended_compcv *buffer, bool save); +Perl_resume_compcv(pTHX_ struct suspended_compcv *buffer, bool save) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_RESUME_COMPCV \ assert(buffer) @@ -3886,6 +4547,10 @@ Perl_resume_compcv_final(pTHX_ struct suspended_compcv *buffer); */ PERL_CALLCONV char * Perl_rninstr(const char *big, const char *bigend, const char *little, const char *lend) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(3) + Perl_attribute_nonnull_(4) __attribute__warn_unused_result__ __attribute__pure__; #define PERL_ARGS_ASSERT_RNINSTR \ @@ -3897,7 +4562,9 @@ Perl_rpeep(pTHX_ OP *o) #define PERL_ARGS_ASSERT_RPEEP PERL_CALLCONV void -Perl_rpp_free_2_(pTHX_ SV * const sv1, SV * const sv2, const U32 rc1, const U32 rc2); +Perl_rpp_free_2_(pTHX_ SV * const sv1, SV * const sv2, const U32 rc1, const U32 rc2) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_RPP_FREE_2_ \ assert(sv1); assert(sv2) @@ -3916,6 +4583,7 @@ Perl_rsignal_restore(pTHX_ int i, Sigsave_t *t) PERL_CALLCONV int Perl_rsignal_save(pTHX_ int i, Sighandler_t t1, Sigsave_t *save) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_RSIGNAL_SAVE \ assert(save) @@ -3933,12 +4601,15 @@ Perl_runops_standard(pTHX); #define PERL_ARGS_ASSERT_RUNOPS_STANDARD PERL_CALLCONV CV * -Perl_rv2cv_op_cv(pTHX_ OP *cvop, U32 flags); +Perl_rv2cv_op_cv(pTHX_ OP *cvop, U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_RV2CV_OP_CV \ assert(cvop) PERL_CALLCONV void Perl_rxres_save(pTHX_ void **rsp, REGEXP *rx) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_RXRES_SAVE \ assert(rsp); assert(rx) @@ -3965,22 +4636,26 @@ Perl_safesysrealloc(Malloc_t where, MEM_SIZE nbytes) #define PERL_ARGS_ASSERT_SAFESYSREALLOC PERL_CALLCONV void -Perl_save_I16(pTHX_ I16 *intp); +Perl_save_I16(pTHX_ I16 *intp) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_I16 \ assert(intp) PERL_CALLCONV void -Perl_save_I32(pTHX_ I32 *intp); +Perl_save_I32(pTHX_ I32 *intp) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_I32 \ assert(intp) PERL_CALLCONV void -Perl_save_I8(pTHX_ I8 *bytep); +Perl_save_I8(pTHX_ I8 *bytep) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_I8 \ assert(bytep) PERL_CALLCONV void -Perl_save_adelete(pTHX_ AV *av, SSize_t key); +Perl_save_adelete(pTHX_ AV *av, SSize_t key) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_ADELETE \ assert(av); assert(SvTYPE(av) == SVt_PVAV) @@ -3988,7 +4663,9 @@ Perl_save_adelete(pTHX_ AV *av, SSize_t key); Perl_save_aelem(pTHX_ AV *av, SSize_t idx, SV **sptr); */ PERL_CALLCONV void -Perl_save_aelem_flags(pTHX_ AV *av, SSize_t idx, SV **sptr, const U32 flags); +Perl_save_aelem_flags(pTHX_ AV *av, SSize_t idx, SV **sptr, const U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS \ assert(av); assert(SvTYPE(av) == SVt_PVAV); assert(sptr) @@ -3997,32 +4674,39 @@ Perl_save_alloc(pTHX_ SSize_t size, I32 pad); #define PERL_ARGS_ASSERT_SAVE_ALLOC PERL_CALLCONV void -Perl_save_aptr(pTHX_ AV **aptr); +Perl_save_aptr(pTHX_ AV **aptr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_APTR \ assert(aptr) PERL_CALLCONV AV * -Perl_save_ary(pTHX_ GV *gv); +Perl_save_ary(pTHX_ GV *gv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_ARY \ assert(gv) PERL_CALLCONV void -Perl_save_bool(pTHX_ bool *boolp); +Perl_save_bool(pTHX_ bool *boolp) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_BOOL \ assert(boolp) PERL_CALLCONV void -Perl_save_clearsv(pTHX_ SV **svp); +Perl_save_clearsv(pTHX_ SV **svp) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_CLEARSV \ assert(svp) PERL_CALLCONV void -Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen); +Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SAVE_DELETE \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(key) PERL_CALLCONV void -Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void *p); +Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void *p) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR \ assert(p) @@ -4037,7 +4721,8 @@ Perl_save_freeop(pTHX_ OP *o); */ Perl_save_freepv(pTHX_ char *pv); */ PERL_CALLCONV void -Perl_save_freercpv(pTHX_ char *rcpv); +Perl_save_freercpv(pTHX_ char *rcpv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_FREERCPV \ assert(rcpv) @@ -4045,27 +4730,33 @@ Perl_save_freercpv(pTHX_ char *rcpv); Perl_save_freesv(pTHX_ SV *sv); */ PERL_CALLCONV void -Perl_save_generic_pvref(pTHX_ char **str); +Perl_save_generic_pvref(pTHX_ char **str) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF \ assert(str) PERL_CALLCONV void -Perl_save_generic_svref(pTHX_ SV **sptr); +Perl_save_generic_svref(pTHX_ SV **sptr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_GENERIC_SVREF \ assert(sptr) PERL_CALLCONV void -Perl_save_gp(pTHX_ GV *gv, I32 empty); +Perl_save_gp(pTHX_ GV *gv, I32 empty) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_GP \ assert(gv) PERL_CALLCONV HV * -Perl_save_hash(pTHX_ GV *gv); +Perl_save_hash(pTHX_ GV *gv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_HASH \ assert(gv) PERL_CALLCONV void -Perl_save_hdelete(pTHX_ HV *hv, SV *keysv); +Perl_save_hdelete(pTHX_ HV *hv, SV *keysv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SAVE_HDELETE \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(keysv) @@ -4073,7 +4764,10 @@ Perl_save_hdelete(pTHX_ HV *hv, SV *keysv); Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr); */ PERL_CALLCONV void -Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags); +Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SAVE_HELEM_FLAGS \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(key); assert(sptr) @@ -4082,22 +4776,26 @@ Perl_save_hints(pTHX); #define PERL_ARGS_ASSERT_SAVE_HINTS PERL_CALLCONV void -Perl_save_hptr(pTHX_ HV **hptr); +Perl_save_hptr(pTHX_ HV **hptr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_HPTR \ assert(hptr) PERL_CALLCONV void -Perl_save_int(pTHX_ int *intp); +Perl_save_int(pTHX_ int *intp) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_INT \ assert(intp) PERL_CALLCONV void -Perl_save_item(pTHX_ SV *item); +Perl_save_item(pTHX_ SV *item) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_ITEM \ assert(item) PERL_CALLCONV void -Perl_save_iv(pTHX_ IV *ivp); +Perl_save_iv(pTHX_ IV *ivp) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_IV \ assert(ivp) @@ -4112,7 +4810,8 @@ 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); +Perl_save_pptr(pTHX_ char **pptr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_PPTR \ assert(pptr) @@ -4129,7 +4828,8 @@ Perl_save_pushptrptr(pTHX_ void * const ptr1, void * const ptr2, const int type) #define PERL_ARGS_ASSERT_SAVE_PUSHPTRPTR PERL_CALLCONV void -Perl_save_rcpv(pTHX_ char **prcpv); +Perl_save_rcpv(pTHX_ char **prcpv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_RCPV \ assert(prcpv) @@ -4138,37 +4838,44 @@ Perl_save_re_context(pTHX); #define PERL_ARGS_ASSERT_SAVE_RE_CONTEXT PERL_CALLCONV SV * -Perl_save_scalar(pTHX_ GV *gv); +Perl_save_scalar(pTHX_ GV *gv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SCALAR \ assert(gv) PERL_CALLCONV void -Perl_save_set_svflags(pTHX_ SV *sv, U32 mask, U32 val); +Perl_save_set_svflags(pTHX_ SV *sv, U32 mask, U32 val) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SET_SVFLAGS \ assert(sv) PERL_CALLCONV void -Perl_save_shared_pvref(pTHX_ char **str); +Perl_save_shared_pvref(pTHX_ char **str) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SHARED_PVREF \ assert(str) PERL_CALLCONV void -Perl_save_sptr(pTHX_ SV **sptr); +Perl_save_sptr(pTHX_ SV **sptr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SPTR \ assert(sptr) PERL_CALLCONV void -Perl_save_strlen(pTHX_ STRLEN *ptr); +Perl_save_strlen(pTHX_ STRLEN *ptr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_STRLEN \ assert(ptr) PERL_CALLCONV SV * -Perl_save_svref(pTHX_ SV **sptr); +Perl_save_svref(pTHX_ SV **sptr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SVREF \ assert(sptr) PERL_CALLCONV void -Perl_save_vptr(pTHX_ void *ptr); +Perl_save_vptr(pTHX_ void *ptr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_VPTR \ assert(ptr) @@ -4180,6 +4887,7 @@ Perl_savesharedpv(pTHX_ const char *pv) PERL_CALLCONV char * Perl_savesharedpvn(pTHX_ const char * const pv, const STRLEN len) + Perl_attribute_nonnull_(pTHX_1) __attribute__malloc__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SAVESHAREDPVN \ @@ -4209,27 +4917,36 @@ Perl_scalar(pTHX_ OP *o) PERL_CALLCONV OP * Perl_scalarvoid(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SCALARVOID \ assert(o) PERL_CALLCONV NV -Perl_scan_bin(pTHX_ const char *start, STRLEN len, STRLEN *retlen); +Perl_scan_bin(pTHX_ const char *start, STRLEN len, STRLEN *retlen) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SCAN_BIN \ assert(start); assert(retlen) PERL_CALLCONV NV -Perl_scan_hex(pTHX_ const char *start, STRLEN len, STRLEN *retlen); +Perl_scan_hex(pTHX_ const char *start, STRLEN len, STRLEN *retlen) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SCAN_HEX \ assert(start); assert(retlen) PERL_CALLCONV char * -Perl_scan_num(pTHX_ const char *s, YYSTYPE *lvalp); +Perl_scan_num(pTHX_ const char *s, YYSTYPE *lvalp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SCAN_NUM \ assert(s); assert(lvalp) PERL_CALLCONV NV -Perl_scan_oct(pTHX_ const char *start, STRLEN len, STRLEN *retlen); +Perl_scan_oct(pTHX_ const char *start, STRLEN len, STRLEN *retlen) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SCAN_OCT \ assert(start); assert(retlen) @@ -4237,12 +4954,17 @@ Perl_scan_oct(pTHX_ const char *start, STRLEN len, STRLEN *retlen); assert(start) PERL_CALLCONV const char * -Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv); +Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SCAN_VERSION \ assert(s); assert(rv) PERL_CALLCONV char * -Perl_scan_vstring(pTHX_ const char *s, const char * const e, SV *sv); +Perl_scan_vstring(pTHX_ const char *s, const char * const e, SV *sv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SCAN_VSTRING \ assert(s); assert(e); assert(sv) @@ -4258,22 +4980,26 @@ Perl_set_caret_X(pTHX); #define PERL_ARGS_ASSERT_SET_CARET_X PERL_CALLCONV void -Perl_set_context(void *t); +Perl_set_context(void *t) + Perl_attribute_nonnull_(1); #define PERL_ARGS_ASSERT_SET_CONTEXT \ assert(t) PERL_CALLCONV void -Perl_set_numeric_standard(pTHX_ const char *file, const line_t caller_line); +Perl_set_numeric_standard(pTHX_ const char *file, const line_t caller_line) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SET_NUMERIC_STANDARD \ assert(file) PERL_CALLCONV void -Perl_set_numeric_underlying(pTHX_ const char *file, const line_t caller_line); +Perl_set_numeric_underlying(pTHX_ const char *file, const line_t caller_line) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SET_NUMERIC_UNDERLYING \ assert(file) PERL_CALLCONV void -Perl_setdefout(pTHX_ GV *gv); +Perl_setdefout(pTHX_ GV *gv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SETDEFOUT \ assert(gv) @@ -4303,7 +5029,8 @@ 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); +Perl_share_hek(pTHX_ const char *str, SSize_t len, U32 hash) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SHARE_HEK \ assert(str) @@ -4321,22 +5048,28 @@ Perl_sighandler3(int sig, Siginfo_t *info, void *uap) assert(s) PERL_CALLCONV void -Perl_sortsv(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp); +Perl_sortsv(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SORTSV \ assert(cmp) PERL_CALLCONV void -Perl_sortsv_flags(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp, U32 flags); +Perl_sortsv_flags(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp, U32 flags) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SORTSV_FLAGS \ assert(cmp) PERL_CALLCONV SV ** -Perl_stack_grow(pTHX_ SV **sp, SV **p, SSize_t n); +Perl_stack_grow(pTHX_ SV **sp, SV **p, SSize_t n) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_STACK_GROW \ assert(sp); assert(p) PERL_CALLCONV PerlIO * Perl_start_glob(pTHX_ SV *tmpglob, IO *io) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_START_GLOB \ assert(tmpglob); assert(io) @@ -4347,6 +5080,7 @@ Perl_start_subparse(pTHX_ I32 is_format, U32 flags); PERL_CALLCONV NV Perl_str_to_version(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_STR_TO_VERSION \ assert(sv) @@ -4356,12 +5090,14 @@ Perl_strict_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t PERL_CALLCONV void Perl_sub_crush_depth(pTHX_ CV *cv) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SUB_CRUSH_DEPTH \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_subsignature_append_fence_op(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SUBSIGNATURE_APPEND_FENCE_OP \ assert(o) @@ -4387,7 +5123,8 @@ Perl_subsignature_start(pTHX) #define PERL_ARGS_ASSERT_SUBSIGNATURE_START PERL_CALLCONV void -Perl_suspend_compcv(pTHX_ struct suspended_compcv *buffer); +Perl_suspend_compcv(pTHX_ struct suspended_compcv *buffer) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SUSPEND_COMPCV \ assert(buffer) @@ -4395,17 +5132,21 @@ Perl_suspend_compcv(pTHX_ struct suspended_compcv *buffer); Perl_sv_2bool(pTHX_ SV * const sv); */ PERL_CALLCONV bool -Perl_sv_2bool_flags(pTHX_ SV *sv, I32 flags); +Perl_sv_2bool_flags(pTHX_ SV *sv, I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2BOOL_FLAGS \ assert(sv) PERL_CALLCONV CV * -Perl_sv_2cv(pTHX_ SV *sv, HV ** const st, GV ** const gvp, const I32 lref); +Perl_sv_2cv(pTHX_ SV *sv, HV ** const st, GV ** const gvp, const I32 lref) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SV_2CV \ assert(st); assert(gvp) PERL_CALLCONV IO * -Perl_sv_2io(pTHX_ SV * const sv); +Perl_sv_2io(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2IO \ assert(sv) @@ -4413,7 +5154,8 @@ Perl_sv_2io(pTHX_ SV * const sv); Perl_sv_2iv(pTHX_ SV *sv); */ PERL_CALLCONV IV -Perl_sv_2iv_flags(pTHX_ SV * const sv, const I32 flags); +Perl_sv_2iv_flags(pTHX_ SV * const sv, const I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2IV_FLAGS \ assert(sv) @@ -4423,12 +5165,14 @@ Perl_sv_2mortal(pTHX_ SV * const sv); PERL_CALLCONV SV * Perl_sv_2num(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SV_2NUM \ assert(sv) PERL_CALLCONV NV -Perl_sv_2nv_flags(pTHX_ SV * const sv, const I32 flags); +Perl_sv_2nv_flags(pTHX_ SV * const sv, const I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2NV_FLAGS \ assert(sv) @@ -4436,7 +5180,8 @@ Perl_sv_2nv_flags(pTHX_ SV * const sv, const I32 flags); Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp); */ PERL_CALLCONV char * -Perl_sv_2pv_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags); +Perl_sv_2pv_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2PV_FLAGS \ assert(sv) @@ -4448,7 +5193,8 @@ Perl_sv_2pv_nolen(pTHX_ SV *sv) Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN * const lp); */ PERL_CALLCONV char * -Perl_sv_2pvbyte_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags); +Perl_sv_2pvbyte_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2PVBYTE_FLAGS \ assert(sv) @@ -4460,7 +5206,8 @@ Perl_sv_2pvbyte_nolen(pTHX_ SV *sv) Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN * const lp); */ PERL_CALLCONV char * -Perl_sv_2pvutf8_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags); +Perl_sv_2pvutf8_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2PVUTF8_FLAGS \ assert(sv) @@ -4472,53 +5219,71 @@ Perl_sv_2pvutf8_nolen(pTHX_ SV *sv) Perl_sv_2uv(pTHX_ SV *sv); */ PERL_CALLCONV UV -Perl_sv_2uv_flags(pTHX_ SV * const sv, const I32 flags); +Perl_sv_2uv_flags(pTHX_ SV * const sv, const I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2UV_FLAGS \ assert(sv) PERL_CALLCONV void -Perl_sv_backoff(SV * const sv); +Perl_sv_backoff(SV * const sv) + Perl_attribute_nonnull_(1); #define PERL_ARGS_ASSERT_SV_BACKOFF \ assert(sv) PERL_CALLCONV SV * -Perl_sv_bless(pTHX_ SV * const sv, HV * const stash); +Perl_sv_bless(pTHX_ SV * const sv, HV * const stash) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_BLESS \ assert(sv); assert(stash) PERL_CALLCONV bool -Perl_sv_can_swipe_pv_buf(pTHX_ SV *sv); +Perl_sv_can_swipe_pv_buf(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_CAN_SWIPE_PV_BUF \ assert(sv) PERL_CALLCONV bool -Perl_sv_cat_decode(pTHX_ SV *dsv, SV *encoding, SV *ssv, int *offset, char *tstr, int tlen); +Perl_sv_cat_decode(pTHX_ SV *dsv, SV *encoding, SV *ssv, int *offset, char *tstr, int tlen) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5); #define PERL_ARGS_ASSERT_SV_CAT_DECODE \ assert(dsv); assert(encoding); assert(ssv); assert(offset); assert(tstr) PERL_CALLCONV void -Perl_sv_catpv(pTHX_ SV * const dsv, const char *sstr); +Perl_sv_catpv(pTHX_ SV * const dsv, const char *sstr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_CATPV \ assert(dsv) PERL_CALLCONV void -Perl_sv_catpv_flags(pTHX_ SV * const dsv, const char *sstr, const I32 flags); +Perl_sv_catpv_flags(pTHX_ SV * const dsv, const char *sstr, const I32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_CATPV_FLAGS \ assert(dsv); assert(sstr) PERL_CALLCONV void -Perl_sv_catpv_mg(pTHX_ SV * const dsv, const char * const sstr); +Perl_sv_catpv_mg(pTHX_ SV * const dsv, const char * const sstr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_CATPV_MG \ assert(dsv) PERL_CALLCONV void Perl_sv_catpvf(pTHX_ SV * const sv, const char * const pat, ...) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_SV_CATPVF \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_catpvf_mg(pTHX_ SV * const sv, const char * const pat, ...) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_SV_CATPVF_MG \ assert(sv); assert(pat) @@ -4527,7 +5292,9 @@ Perl_sv_catpvf_mg(pTHX_ SV * const sv, const char * const pat, ...) Perl_sv_catpvn(pTHX_ SV * const dsv, const char *sstr, STRLEN len); */ PERL_CALLCONV void -Perl_sv_catpvn_flags(pTHX_ SV * const dsv, const char *sstr, const STRLEN len, const I32 flags); +Perl_sv_catpvn_flags(pTHX_ SV * const dsv, const char *sstr, const STRLEN len, const I32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_CATPVN_FLAGS \ assert(dsv); assert(sstr) @@ -4538,7 +5305,8 @@ Perl_sv_catpvn_mg(pTHX_ SV * const dsv, const char *sstr, STRLEN len); */ Perl_sv_catsv(pTHX_ SV * const dsv, SV * const sstr); */ PERL_CALLCONV void -Perl_sv_catsv_flags(pTHX_ SV * const dsv, SV * const sstr, const I32 flags); +Perl_sv_catsv_flags(pTHX_ SV * const dsv, SV * const sstr, const I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_CATSV_FLAGS \ assert(dsv) @@ -4546,7 +5314,8 @@ Perl_sv_catsv_flags(pTHX_ SV * const dsv, SV * const sstr, const I32 flags); Perl_sv_catsv_mg(pTHX_ SV * const dsv, SV * const sstr); */ PERL_CALLCONV void -Perl_sv_chop(pTHX_ SV * const sv, const char * const ptr); +Perl_sv_chop(pTHX_ SV * const sv, const char * const ptr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_CHOP \ assert(sv) @@ -4561,7 +5330,8 @@ Perl_sv_clean_objs(pTHX) #define PERL_ARGS_ASSERT_SV_CLEAN_OBJS PERL_CALLCONV void -Perl_sv_clear(pTHX_ SV * const orig_sv); +Perl_sv_clear(pTHX_ SV * const orig_sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_CLEAR \ assert(orig_sv) @@ -4585,7 +5355,9 @@ Perl_sv_cmp_locale_flags(pTHX_ SV * const sv1, SV * const sv2, const U32 flags); 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); +Perl_sv_copypv_flags(pTHX_ SV * const dsv, SV * const ssv, const I32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_COPYPV_FLAGS \ assert(dsv); assert(ssv) @@ -4601,36 +5373,48 @@ 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); +Perl_sv_del_backref(pTHX_ SV * const tsv, SV * const sv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_DEL_BACKREF \ assert(tsv); assert(sv) PERL_CALLCONV bool Perl_sv_derived_from(pTHX_ SV *sv, const char * const name) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DERIVED_FROM \ assert(sv); assert(name) PERL_CALLCONV bool Perl_sv_derived_from_hv(pTHX_ SV *sv, HV *hv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_HV \ assert(sv); assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV bool Perl_sv_derived_from_pv(pTHX_ SV *sv, const char * const name, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PV \ assert(sv); assert(name) PERL_CALLCONV bool Perl_sv_derived_from_pvn(pTHX_ SV *sv, const char * const name, const STRLEN len, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PVN \ assert(sv); assert(name) PERL_CALLCONV bool Perl_sv_derived_from_sv(pTHX_ SV *sv, SV *namesv, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_SV \ assert(sv); assert(namesv) @@ -4641,24 +5425,32 @@ Perl_sv_destroyable(pTHX_ SV *sv); PERL_CALLCONV bool Perl_sv_does(pTHX_ SV *sv, const char * const name) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DOES \ assert(sv); assert(name) PERL_CALLCONV bool Perl_sv_does_pv(pTHX_ SV *sv, const char * const name, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DOES_PV \ assert(sv); assert(name) PERL_CALLCONV bool Perl_sv_does_pvn(pTHX_ SV *sv, const char * const name, const STRLEN len, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DOES_PVN \ assert(sv); assert(name) PERL_CALLCONV bool Perl_sv_does_sv(pTHX_ SV *sv, SV *namesv, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DOES_SV \ assert(sv); assert(namesv) @@ -4682,7 +5474,8 @@ Perl_sv_eq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags); Perl_sv_force_normal(pTHX_ SV *sv); */ PERL_CALLCONV void -Perl_sv_force_normal_flags(pTHX_ SV * const sv, const U32 flags); +Perl_sv_force_normal_flags(pTHX_ SV * const sv, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS \ assert(sv) @@ -4691,7 +5484,8 @@ 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); +Perl_sv_free2(pTHX_ SV * const sv, const U32 refcnt) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_FREE2 \ assert(sv) @@ -4701,22 +5495,27 @@ Perl_sv_free_arenas(pTHX) #define PERL_ARGS_ASSERT_SV_FREE_ARENAS PERL_CALLCONV SV * -Perl_sv_get_backrefs(SV * const sv); +Perl_sv_get_backrefs(SV * const sv) + Perl_attribute_nonnull_(1); #define PERL_ARGS_ASSERT_SV_GET_BACKREFS \ assert(sv) PERL_CALLCONV char * -Perl_sv_gets(pTHX_ SV * const sv, PerlIO * const fp, SSize_t append); +Perl_sv_gets(pTHX_ SV * const sv, PerlIO * const fp, SSize_t append) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_GETS \ assert(sv); assert(fp) PERL_CALLCONV char * -Perl_sv_grow(pTHX_ SV * const sv, STRLEN newlen); +Perl_sv_grow(pTHX_ SV * const sv, STRLEN newlen) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_GROW \ assert(sv) PERL_CALLCONV char * -Perl_sv_grow_fresh(pTHX_ SV * const sv, STRLEN newlen); +Perl_sv_grow_fresh(pTHX_ SV * const sv, STRLEN newlen) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_GROW_FRESH \ assert(sv) @@ -4732,17 +5531,22 @@ Perl_sv_inc_nomg(pTHX_ SV * const sv); Perl_sv_insert(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char * const little, const STRLEN littlelen); */ PERL_CALLCONV void -Perl_sv_insert_flags(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char *little, const STRLEN littlelen, const U32 flags); +Perl_sv_insert_flags(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char *little, const STRLEN littlelen, const U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_4); #define PERL_ARGS_ASSERT_SV_INSERT_FLAGS \ assert(bigstr); assert(little) PERL_CALLCONV int -Perl_sv_isa(pTHX_ SV *sv, const char * const name); +Perl_sv_isa(pTHX_ SV *sv, const char * const name) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_ISA \ assert(name) PERL_CALLCONV bool Perl_sv_isa_sv(pTHX_ SV *sv, SV *namesv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_ISA_SV \ assert(sv); assert(namesv) @@ -4764,17 +5568,20 @@ 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); +Perl_sv_len_utf8_nomg(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_LEN_UTF8_NOMG \ assert(sv) PERL_CALLCONV void -Perl_sv_magic(pTHX_ SV * const sv, SV * const obj, const int how, const char * const name, const I32 namlen); +Perl_sv_magic(pTHX_ SV * const sv, SV * const obj, const int how, const char * const name, const I32 namlen) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_MAGIC \ assert(sv) PERL_CALLCONV MAGIC * -Perl_sv_magicext(pTHX_ SV * const sv, SV * const obj, const int how, const MGVTBL * const vtbl, const char * const name, const I32 namlen); +Perl_sv_magicext(pTHX_ SV * const sv, SV * const obj, const int how, const MGVTBL * const vtbl, const char * const name, const I32 namlen) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_MAGICEXT \ assert(sv) @@ -4815,22 +5622,26 @@ 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); +Perl_sv_pos_b2u(pTHX_ SV * const sv, I32 * const offsetp) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_POS_B2U \ assert(offsetp) PERL_CALLCONV STRLEN -Perl_sv_pos_b2u_flags(pTHX_ SV * const sv, STRLEN const offset, U32 flags); +Perl_sv_pos_b2u_flags(pTHX_ SV * const sv, STRLEN const offset, U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_POS_B2U_FLAGS \ assert(sv) PERL_CALLCONV void -Perl_sv_pos_u2b(pTHX_ SV * const sv, I32 * const offsetp, I32 * const lenp); +Perl_sv_pos_u2b(pTHX_ SV * const sv, I32 * const offsetp, I32 * const lenp) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_POS_U2B \ assert(offsetp) PERL_CALLCONV STRLEN -Perl_sv_pos_u2b_flags(pTHX_ SV * const sv, STRLEN uoffset, STRLEN * const lenp, U32 flags); +Perl_sv_pos_u2b_flags(pTHX_ SV * const sv, STRLEN uoffset, STRLEN * const lenp, U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_POS_U2B_FLAGS \ assert(sv) @@ -4843,7 +5654,8 @@ Perl_sv_pvbyte(pTHX_ SV *sv) __attribute__warn_unused_result__; */ PERL_CALLCONV char * -Perl_sv_pvbyten_force(pTHX_ SV * const sv, STRLEN * const lp); +Perl_sv_pvbyten_force(pTHX_ SV * const sv, STRLEN * const lp) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE \ assert(sv) @@ -4851,7 +5663,8 @@ Perl_sv_pvbyten_force(pTHX_ SV * const sv, STRLEN * const lp); Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp); */ PERL_CALLCONV char * -Perl_sv_pvn_force_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags); +Perl_sv_pvn_force_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS \ assert(sv) @@ -4860,44 +5673,55 @@ Perl_sv_pvutf8(pTHX_ SV *sv) __attribute__warn_unused_result__; */ PERL_CALLCONV char * -Perl_sv_pvutf8n_force(pTHX_ SV * const sv, STRLEN * const lp); +Perl_sv_pvutf8n_force(pTHX_ SV * const sv, STRLEN * const lp) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE \ assert(sv) PERL_CALLCONV char * -Perl_sv_recode_to_utf8(pTHX_ SV *sv, SV *encoding); +Perl_sv_recode_to_utf8(pTHX_ SV *sv, SV *encoding) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_RECODE_TO_UTF8 \ assert(sv); assert(encoding) PERL_CALLCONV SV * -Perl_sv_ref(pTHX_ SV *dst, const SV * const sv, const int ob); +Perl_sv_ref(pTHX_ SV *dst, const SV * const sv, const int ob) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_REF \ assert(sv) PERL_CALLCONV const char * Perl_sv_reftype(pTHX_ const SV * const sv, const int ob) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_REFTYPE \ assert(sv) PERL_CALLCONV void -Perl_sv_regex_global_pos_clear(pTHX_ SV *sv); +Perl_sv_regex_global_pos_clear(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_REGEX_GLOBAL_POS_CLEAR \ assert(sv) PERL_CALLCONV bool Perl_sv_regex_global_pos_get(pTHX_ SV *sv, STRLEN *posp, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_REGEX_GLOBAL_POS_GET \ assert(sv); assert(posp) PERL_CALLCONV void -Perl_sv_regex_global_pos_set(pTHX_ SV *sv, STRLEN pos, U32 flags); +Perl_sv_regex_global_pos_set(pTHX_ SV *sv, STRLEN pos, U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_REGEX_GLOBAL_POS_SET \ assert(sv) PERL_CALLCONV void -Perl_sv_replace(pTHX_ SV * const sv, SV * const nsv); +Perl_sv_replace(pTHX_ SV * const sv, SV * const nsv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_REPLACE \ assert(sv); assert(nsv) @@ -4906,7 +5730,8 @@ 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); +Perl_sv_reset(pTHX_ const char *s, HV * const stash) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_RESET \ assert(s); assert(!stash || SvTYPE(stash) == SVt_PVHV) @@ -4916,144 +5741,180 @@ 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); +Perl_sv_rvunweaken(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_RVUNWEAKEN \ assert(sv) PERL_CALLCONV SV * -Perl_sv_rvweaken(pTHX_ SV * const sv); +Perl_sv_rvweaken(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_RVWEAKEN \ assert(sv) PERL_CALLCONV void -Perl_sv_set_bool(pTHX_ SV *sv, const bool bool_val); +Perl_sv_set_bool(pTHX_ SV *sv, const bool bool_val) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SET_BOOL \ assert(sv) PERL_CALLCONV void -Perl_sv_set_false(pTHX_ SV *sv); +Perl_sv_set_false(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SET_FALSE \ assert(sv) PERL_CALLCONV void -Perl_sv_set_true(pTHX_ SV *sv); +Perl_sv_set_true(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SET_TRUE \ assert(sv) PERL_CALLCONV void -Perl_sv_set_undef(pTHX_ SV *sv); +Perl_sv_set_undef(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SET_UNDEF \ assert(sv) PERL_CALLCONV void -Perl_sv_sethek(pTHX_ SV * const sv, const HEK * const hek); +Perl_sv_sethek(pTHX_ SV * const sv, const HEK * const hek) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETHEK \ assert(sv) PERL_CALLCONV void -Perl_sv_setiv(pTHX_ SV * const sv, const IV num); +Perl_sv_setiv(pTHX_ SV * const sv, const IV num) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETIV \ assert(sv) PERL_CALLCONV void -Perl_sv_setiv_mg(pTHX_ SV * const sv, const IV i); +Perl_sv_setiv_mg(pTHX_ SV * const sv, const IV i) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETIV_MG \ assert(sv) PERL_CALLCONV void -Perl_sv_setnv(pTHX_ SV * const sv, const NV num); +Perl_sv_setnv(pTHX_ SV * const sv, const NV num) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETNV \ assert(sv) PERL_CALLCONV void -Perl_sv_setnv_mg(pTHX_ SV * const sv, const NV num); +Perl_sv_setnv_mg(pTHX_ SV * const sv, const NV num) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETNV_MG \ assert(sv) PERL_CALLCONV void -Perl_sv_setpv(pTHX_ SV * const sv, const char * const ptr); +Perl_sv_setpv(pTHX_ SV * const sv, const char * const ptr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETPV \ assert(sv) PERL_CALLCONV char * -Perl_sv_setpv_bufsize(pTHX_ SV * const sv, const STRLEN cur, const STRLEN len); +Perl_sv_setpv_bufsize(pTHX_ SV * const sv, const STRLEN cur, const STRLEN len) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETPV_BUFSIZE \ assert(sv) PERL_CALLCONV void -Perl_sv_setpv_mg(pTHX_ SV * const sv, const char * const ptr); +Perl_sv_setpv_mg(pTHX_ SV * const sv, const char * const ptr) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETPV_MG \ assert(sv) PERL_CALLCONV void Perl_sv_setpvf(pTHX_ SV * const sv, const char * const pat, ...) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_SV_SETPVF \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_setpvf_mg(pTHX_ SV * const sv, const char * const pat, ...) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_SV_SETPVF_MG \ assert(sv); assert(pat) PERL_CALLCONV void -Perl_sv_setpvn(pTHX_ SV * const sv, const char * const ptr, const STRLEN len); +Perl_sv_setpvn(pTHX_ SV * const sv, const char * const ptr, const STRLEN len) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETPVN \ assert(sv) PERL_CALLCONV void -Perl_sv_setpvn_fresh(pTHX_ SV * const sv, const char * const ptr, const STRLEN len); +Perl_sv_setpvn_fresh(pTHX_ SV * const sv, const char * const ptr, const STRLEN len) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETPVN_FRESH \ assert(sv) PERL_CALLCONV void -Perl_sv_setpvn_mg(pTHX_ SV * const sv, const char * const ptr, const STRLEN len); +Perl_sv_setpvn_mg(pTHX_ SV * const sv, const char * const ptr, const STRLEN len) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_SETPVN_MG \ assert(sv); assert(ptr) PERL_CALLCONV SV * -Perl_sv_setref_iv(pTHX_ SV * const rv, const char * const classname, const IV iv); +Perl_sv_setref_iv(pTHX_ SV * const rv, const char * const classname, const IV iv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETREF_IV \ assert(rv) PERL_CALLCONV SV * -Perl_sv_setref_nv(pTHX_ SV * const rv, const char * const classname, const NV nv); +Perl_sv_setref_nv(pTHX_ SV * const rv, const char * const classname, const NV nv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETREF_NV \ assert(rv) PERL_CALLCONV SV * -Perl_sv_setref_pv(pTHX_ SV * const rv, const char * const classname, void * const pv); +Perl_sv_setref_pv(pTHX_ SV * const rv, const char * const classname, void * const pv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETREF_PV \ assert(rv) PERL_CALLCONV SV * -Perl_sv_setref_pvn(pTHX_ SV * const rv, const char * const classname, const char * const pv, const STRLEN n); +Perl_sv_setref_pvn(pTHX_ SV * const rv, const char * const classname, const char * const pv, const STRLEN n) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SV_SETREF_PVN \ assert(rv); assert(pv) PERL_CALLCONV SV * -Perl_sv_setref_uv(pTHX_ SV * const rv, const char * const classname, const UV uv); +Perl_sv_setref_uv(pTHX_ SV * const rv, const char * const classname, const UV uv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETREF_UV \ assert(rv) PERL_CALLCONV void -Perl_sv_setrv_inc(pTHX_ SV * const sv, SV * const ref); +Perl_sv_setrv_inc(pTHX_ SV * const sv, SV * const ref) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_SETRV_INC \ assert(sv); assert(ref) PERL_CALLCONV void -Perl_sv_setrv_inc_mg(pTHX_ SV * const sv, SV * const ref); +Perl_sv_setrv_inc_mg(pTHX_ SV * const sv, SV * const ref) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_SETRV_INC_MG \ assert(sv); assert(ref) PERL_CALLCONV void -Perl_sv_setrv_noinc(pTHX_ SV * const sv, SV * const ref); +Perl_sv_setrv_noinc(pTHX_ SV * const sv, SV * const ref) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_SETRV_NOINC \ assert(sv); assert(ref) PERL_CALLCONV void -Perl_sv_setrv_noinc_mg(pTHX_ SV * const sv, SV * const ref); +Perl_sv_setrv_noinc_mg(pTHX_ SV * const sv, SV * const ref) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_SETRV_NOINC_MG \ assert(sv); assert(ref) @@ -5061,22 +5922,26 @@ Perl_sv_setrv_noinc_mg(pTHX_ SV * const sv, SV * const ref); Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv); */ PERL_CALLCONV void -Perl_sv_setsv_flags(pTHX_ SV *dsv, SV *ssv, const I32 flags); +Perl_sv_setsv_flags(pTHX_ SV *dsv, SV *ssv, const I32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETSV_FLAGS \ assert(dsv) PERL_CALLCONV void -Perl_sv_setsv_mg(pTHX_ SV * const dsv, SV * const ssv); +Perl_sv_setsv_mg(pTHX_ SV * const dsv, SV * const ssv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETSV_MG \ assert(dsv) PERL_CALLCONV void -Perl_sv_setuv(pTHX_ SV * const sv, const UV num); +Perl_sv_setuv(pTHX_ SV * const sv, const UV num) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETUV \ assert(sv) PERL_CALLCONV void -Perl_sv_setuv_mg(pTHX_ SV * const sv, const UV u); +Perl_sv_setuv_mg(pTHX_ SV * const sv, const UV u) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETUV_MG \ assert(sv) @@ -5088,12 +5953,15 @@ Perl_sv_streq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags); #define PERL_ARGS_ASSERT_SV_STREQ_FLAGS PERL_CALLCONV SV * -Perl_sv_strftime_ints(pTHX_ SV *fmt, int sec, int min, int hour, int mday, int mon, int year, int isdst); +Perl_sv_strftime_ints(pTHX_ SV *fmt, int sec, int min, int hour, int mday, int mon, int year, int isdst) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_STRFTIME_INTS \ assert(fmt) PERL_CALLCONV SV * -Perl_sv_strftime_tm(pTHX_ SV *fmt, const struct tm *mytm); +Perl_sv_strftime_tm(pTHX_ SV *fmt, const struct tm *mytm) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_STRFTIME_TM \ assert(fmt); assert(mytm) @@ -5106,6 +5974,7 @@ Perl_sv_taint(pTHX_ SV *sv); */ PERL_CALLCONV bool Perl_sv_tainted(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_TAINTED \ assert(sv) @@ -5116,17 +5985,21 @@ Perl_sv_true(pTHX_ SV * const sv); PERL_CALLCONV char * Perl_sv_uni_display(pTHX_ SV *dsv, SV *ssv, STRLEN pvlim, UV flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_UNI_DISPLAY \ assert(dsv); assert(ssv) PERL_CALLCONV int -Perl_sv_unmagic(pTHX_ SV * const sv, const int type); +Perl_sv_unmagic(pTHX_ SV * const sv, const int type) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UNMAGIC \ assert(sv) PERL_CALLCONV int -Perl_sv_unmagicext(pTHX_ SV * const sv, const int type, const MGVTBL *vtbl); +Perl_sv_unmagicext(pTHX_ SV * const sv, const int type, const MGVTBL *vtbl) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UNMAGICEXT \ assert(sv) @@ -5134,17 +6007,20 @@ Perl_sv_unmagicext(pTHX_ SV * const sv, const int type, const MGVTBL *vtbl); Perl_sv_unref(pTHX_ SV *sv); */ PERL_CALLCONV void -Perl_sv_unref_flags(pTHX_ SV * const ref, const U32 flags); +Perl_sv_unref_flags(pTHX_ SV * const ref, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UNREF_FLAGS \ assert(ref) PERL_CALLCONV void -Perl_sv_untaint(pTHX_ SV * const sv); +Perl_sv_untaint(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UNTAINT \ assert(sv) PERL_CALLCONV void -Perl_sv_upgrade(pTHX_ SV * const sv, svtype new_type); +Perl_sv_upgrade(pTHX_ SV * const sv, svtype new_type) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UPGRADE \ assert(sv) @@ -5152,7 +6028,8 @@ Perl_sv_upgrade(pTHX_ SV * const sv, svtype new_type); Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len); */ PERL_CALLCONV void -Perl_sv_usepvn_flags(pTHX_ SV * const sv, char *ptr, const STRLEN len, const U32 flags); +Perl_sv_usepvn_flags(pTHX_ SV * const sv, char *ptr, const STRLEN len, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_USEPVN_FLAGS \ assert(sv) @@ -5160,7 +6037,8 @@ Perl_sv_usepvn_flags(pTHX_ SV * const sv, char *ptr, const STRLEN len, const U32 Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len); */ PERL_CALLCONV bool -Perl_sv_utf8_decode(pTHX_ SV * const sv); +Perl_sv_utf8_decode(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UTF8_DECODE \ assert(sv) @@ -5168,7 +6046,8 @@ Perl_sv_utf8_decode(pTHX_ SV * const sv); Perl_sv_utf8_downgrade(pTHX_ SV * const sv, const bool fail_ok); */ PERL_CALLCONV bool -Perl_sv_utf8_downgrade_flags(pTHX_ SV * const sv, const bool fail_ok, const U32 flags); +Perl_sv_utf8_downgrade_flags(pTHX_ SV * const sv, const bool fail_ok, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_FLAGS \ assert(sv) @@ -5176,7 +6055,8 @@ Perl_sv_utf8_downgrade_flags(pTHX_ SV * const sv, const bool fail_ok, const U32 Perl_sv_utf8_downgrade_nomg(pTHX_ SV * const sv, const bool fail_ok); */ PERL_CALLCONV void -Perl_sv_utf8_encode(pTHX_ SV * const sv); +Perl_sv_utf8_encode(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UTF8_ENCODE \ assert(sv) @@ -5187,7 +6067,8 @@ Perl_sv_utf8_upgrade(pTHX_ SV *sv); */ Perl_sv_utf8_upgrade_flags(pTHX_ SV * const sv, const I32 flags); */ PERL_CALLCONV STRLEN -Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV * const sv, const I32 flags, STRLEN extra); +Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV * const sv, const I32 flags, STRLEN extra) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW \ assert(sv) @@ -5195,42 +6076,57 @@ Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV * const sv, const I32 flags, STRLEN ext Perl_sv_utf8_upgrade_nomg(pTHX_ SV *sv); */ PERL_CALLCONV void -Perl_sv_vcatpvf(pTHX_ SV * const sv, const char * const pat, va_list * const args); +Perl_sv_vcatpvf(pTHX_ SV * const sv, const char * const pat, va_list * const args) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_VCATPVF \ assert(sv); assert(pat) PERL_CALLCONV void -Perl_sv_vcatpvf_mg(pTHX_ SV * const sv, const char * const pat, va_list * const args); +Perl_sv_vcatpvf_mg(pTHX_ SV * const sv, const char * const pat, va_list * const args) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_VCATPVF_MG \ assert(sv); assert(pat) PERL_CALLCONV void -Perl_sv_vcatpvfn(pTHX_ SV * const sv, const char * const pat, const STRLEN patlen, va_list * const args, SV ** const svargs, const Size_t sv_count, bool * const maybe_tainted); +Perl_sv_vcatpvfn(pTHX_ SV * const sv, const char * const pat, const STRLEN patlen, va_list * const args, SV ** const svargs, const Size_t sv_count, bool * const maybe_tainted) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_VCATPVFN \ assert(sv); assert(pat) PERL_CALLCONV void -Perl_sv_vcatpvfn_flags(pTHX_ SV * const sv, const char * const pat, const STRLEN patlen, va_list * const args, SV ** const svargs, const Size_t sv_count, bool * const maybe_tainted, const U32 flags); +Perl_sv_vcatpvfn_flags(pTHX_ SV * const sv, const char * const pat, const STRLEN patlen, va_list * const args, SV ** const svargs, const Size_t sv_count, bool * const maybe_tainted, const U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_VCATPVFN_FLAGS \ assert(sv); assert(pat) PERL_CALLCONV void -Perl_sv_vsetpvf(pTHX_ SV * const sv, const char * const pat, va_list * const args); +Perl_sv_vsetpvf(pTHX_ SV * const sv, const char * const pat, va_list * const args) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_VSETPVF \ assert(sv); assert(pat) PERL_CALLCONV void -Perl_sv_vsetpvf_mg(pTHX_ SV * const sv, const char * const pat, va_list * const args); +Perl_sv_vsetpvf_mg(pTHX_ SV * const sv, const char * const pat, va_list * const args) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_VSETPVF_MG \ assert(sv); assert(pat) PERL_CALLCONV void -Perl_sv_vsetpvfn(pTHX_ SV * const sv, const char * const pat, const STRLEN patlen, va_list * const args, SV ** const svargs, const Size_t sv_count, bool * const maybe_tainted); +Perl_sv_vsetpvfn(pTHX_ SV * const sv, const char * const pat, const STRLEN patlen, va_list * const args, SV ** const svargs, const Size_t sv_count, bool * const maybe_tainted) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_VSETPVFN \ assert(sv); assert(pat) PERL_CALLCONV const char * -Perl_sv_vstring_get(pTHX_ SV * const sv, STRLEN *lenp); +Perl_sv_vstring_get(pTHX_ SV * const sv, STRLEN *lenp) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_VSTRING_GET \ assert(sv) @@ -5243,12 +6139,17 @@ Perl_sync_locale(pTHX); #define PERL_ARGS_ASSERT_SYNC_LOCALE PERL_CALLCONV void -Perl_sys_init(int *argc, char ***argv); +Perl_sys_init(int *argc, char ***argv) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2); #define PERL_ARGS_ASSERT_SYS_INIT \ assert(argc); assert(argv) PERL_CALLCONV void -Perl_sys_init3(int *argc, char ***argv, char ***env); +Perl_sys_init3(int *argc, char ***argv, char ***env) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(3); #define PERL_ARGS_ASSERT_SYS_INIT3 \ assert(argc); assert(argv); assert(env) @@ -5261,12 +6162,17 @@ Perl_taint_env(pTHX); #define PERL_ARGS_ASSERT_TAINT_ENV PERL_CALLCONV void -Perl_taint_proper(pTHX_ const char *f, const char * const s); +Perl_taint_proper(pTHX_ const char *f, const char * const s) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_TAINT_PROPER \ assert(s) PERL_CALLCONV OP * Perl_tied_method(pTHX_ SV *methname, SV **mark, SV * const sv, const MAGIC * const mg, const U32 flags, U32 argc, ...) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_TIED_METHOD \ assert(methname); assert(mark); assert(sv); assert(mg) @@ -5279,42 +6185,58 @@ Perl_tmps_grow_p(pTHX_ SSize_t ix); Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp); */ PERL_CALLCONV UV -Perl_to_uni_fold_flags_(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags); +Perl_to_uni_fold_flags_(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UNI_FOLD_FLAGS_ \ assert(p); assert(lenp) PERL_CALLCONV UV -Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp); +Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UNI_LOWER \ assert(p); assert(lenp) PERL_CALLCONV UV -Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp); +Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UNI_TITLE \ assert(p); assert(lenp) PERL_CALLCONV UV -Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp); +Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UNI_UPPER \ assert(p); assert(lenp) PERL_CALLCONV UV -Perl_to_utf8_fold_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, U8 flags); +Perl_to_utf8_fold_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, U8 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UTF8_FOLD_FLAGS_ \ assert(p); assert(ustrp) PERL_CALLCONV UV -Perl_to_utf8_lower_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); +Perl_to_utf8_lower_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UTF8_LOWER_FLAGS_ \ assert(p); assert(ustrp) PERL_CALLCONV UV -Perl_to_utf8_title_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); +Perl_to_utf8_title_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UTF8_TITLE_FLAGS_ \ assert(p); assert(ustrp) PERL_CALLCONV UV -Perl_to_utf8_upper_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); +Perl_to_utf8_upper_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UTF8_UPPER_FLAGS_ \ assert(p); assert(ustrp) @@ -5328,12 +6250,18 @@ Perl_try_amagic_un(pTHX_ int method, int flags); PERL_CALLCONV char * Perl_uiv_2buf(char * const buf, const IV iv, UV uv, const int is_uv, char ** const peob) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(5) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_UIV_2BUF \ assert(buf); assert(peob) PERL_CALLCONV SSize_t -Perl_unpackstring(pTHX_ const char *pat, const char *patend, const char *s, const char *strend, U32 flags); +Perl_unpackstring(pTHX_ const char *pat, const char *patend, const char *s, const char *strend, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4); #define PERL_ARGS_ASSERT_UNPACKSTRING \ assert(pat); assert(patend); assert(s); assert(strend) @@ -5346,7 +6274,8 @@ 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); +Perl_upg_version(pTHX_ SV *ver, bool qv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_UPG_VERSION \ assert(ver) @@ -5373,17 +6302,24 @@ Perl_utf8_hop_safe(const U8 *s, SSize_t off, const U8 * const start, const U8 * PERL_CALLCONV STRLEN Perl_utf8_length(pTHX_ const U8 *s0, const U8 *e) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_UTF8_LENGTH \ assert(s0); assert(e) PERL_CALLCONV U8 * -Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *lenp); +Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *lenp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_UTF8_TO_BYTES \ assert(s); assert(lenp) PERL_CALLCONV bool -Perl_utf8_to_bytes_(pTHX_ U8 **s_ptr, STRLEN *lenp, void **free_me, Perl_utf8_to_bytes_arg result_as); +Perl_utf8_to_bytes_(pTHX_ U8 **s_ptr, STRLEN *lenp, void **free_me, Perl_utf8_to_bytes_arg result_as) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_UTF8_TO_BYTES_ \ assert(s_ptr); assert(lenp); assert(free_me) @@ -5400,7 +6336,10 @@ Perl_utf8_to_uv_errors(const U8 * const s, const U8 * const e, UV *cp_p, Size_t Perl_utf8_to_uv_flags(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p, U32 flags); */ PERL_CALLCONV bool -Perl_utf8_to_uv_msgs_helper_(const U8 * const s0, const U8 * const e, UV *cp_p, Size_t *advance_p, U32 flags, U32 *errors, AV **msgs); +Perl_utf8_to_uv_msgs_helper_(const U8 * const s0, const U8 * const e, UV *cp_p, Size_t *advance_p, U32 flags, U32 *errors, AV **msgs) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(3); #define PERL_ARGS_ASSERT_UTF8_TO_UV_MSGS_HELPER_ \ assert(s0); assert(e); assert(cp_p) @@ -5412,6 +6351,7 @@ Perl_utf8n_to_uvchr_error(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg) + Perl_attribute_nonnull_(pTHX_4) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_UTILIZE \ assert(idop) @@ -5432,17 +6372,21 @@ Perl_uvchr_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs); */ Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); */ PERL_CALLCONV U8 * -Perl_uvoffuni_to_utf8_flags_msgs(pTHX_ U8 *d, UV input_uv, const UV flags, HV **msgs); +Perl_uvoffuni_to_utf8_flags_msgs(pTHX_ U8 *d, UV input_uv, const UV flags, HV **msgs) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS_MSGS \ assert(d) PERL_CALLCONV bool -Perl_valid_identifier_pve(pTHX_ const char *s, const char *end, U32 flags); +Perl_valid_identifier_pve(pTHX_ const char *s, const char *end, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_VALID_IDENTIFIER_PVE \ assert(s); assert(end) PERL_CALLCONV bool -Perl_valid_identifier_pvn(pTHX_ const char *s, STRLEN len, U32 flags); +Perl_valid_identifier_pvn(pTHX_ const char *s, STRLEN len, U32 flags) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VALID_IDENTIFIER_PVN \ assert(s) @@ -5458,7 +6402,9 @@ Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen) assert(name) PERL_CALLCONV int -Perl_vcmp(pTHX_ SV *lhv, SV *rhv); +Perl_vcmp(pTHX_ SV *lhv, SV *rhv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_VCMP \ assert(lhv); assert(rhv) @@ -5468,17 +6414,20 @@ Perl_vcroak(pTHX_ const char *pat, va_list *args) #define PERL_ARGS_ASSERT_VCROAK PERL_CALLCONV void -Perl_vdeb(pTHX_ const char *pat, va_list *args); +Perl_vdeb(pTHX_ const char *pat, va_list *args) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VDEB \ assert(pat) PERL_CALLCONV void -Perl_vfatal_warner(pTHX_ U32 err, const char *pat, va_list *args); +Perl_vfatal_warner(pTHX_ U32 err, const char *pat, va_list *args) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_VFATAL_WARNER \ assert(pat) PERL_CALLCONV char * -Perl_vform(pTHX_ const char *pat, va_list *args); +Perl_vform(pTHX_ const char *pat, va_list *args) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VFORM \ assert(pat) @@ -5487,76 +6436,90 @@ Perl_vform(pTHX_ const char *pat, va_list *args); PERL_CALLCONV SV * Perl_vivify_ref(pTHX_ SV *sv, U32 to_what) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_VIVIFY_REF \ assert(sv) PERL_CALLCONV void -Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args); +Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_VLOAD_MODULE \ assert(name) PERL_CALLCONV SV * -Perl_vmess(pTHX_ const char *pat, va_list *args); +Perl_vmess(pTHX_ const char *pat, va_list *args) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VMESS \ assert(pat) PERL_CALLCONV SV * Perl_vnewSVpvf(pTHX_ const char * const pat, va_list * const args) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_VNEWSVPVF \ assert(pat) PERL_CALLCONV SV * -Perl_vnormal(pTHX_ SV *vs); +Perl_vnormal(pTHX_ SV *vs) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VNORMAL \ assert(vs) PERL_CALLCONV SV * -Perl_vnumify(pTHX_ SV *vs); +Perl_vnumify(pTHX_ SV *vs) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VNUMIFY \ assert(vs) PERL_CALLCONV SV * -Perl_vstringify(pTHX_ SV *vs); +Perl_vstringify(pTHX_ SV *vs) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VSTRINGIFY \ assert(vs) PERL_CALLCONV SV * -Perl_vverify(pTHX_ SV *vs); +Perl_vverify(pTHX_ SV *vs) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VVERIFY \ assert(vs) PERL_CALLCONV void -Perl_vwarn(pTHX_ const char *pat, va_list *args); +Perl_vwarn(pTHX_ const char *pat, va_list *args) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VWARN \ assert(pat) PERL_CALLCONV void -Perl_vwarner(pTHX_ U32 err, const char *pat, va_list *args); +Perl_vwarner(pTHX_ U32 err, const char *pat, va_list *args) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_VWARNER \ assert(pat) PERL_CALLCONV I32 Perl_wait4pid(pTHX_ Pid_t pid, int *statusp, int flags) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_WAIT4PID \ assert(statusp) PERL_CALLCONV void Perl_warn(pTHX_ const char *pat, ...) + Perl_attribute_nonnull_(pTHX_1) __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_WARN \ assert(pat) PERL_CALLCONV void -Perl_warn_sv(pTHX_ SV *baseex); +Perl_warn_sv(pTHX_ SV *baseex) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_WARN_SV \ assert(baseex) PERL_CALLCONV void Perl_warner(pTHX_ U32 err, const char *pat, ...) + Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_WARNER \ assert(pat) @@ -5568,6 +6531,7 @@ Perl_was_lvalue_sub(pTHX) PERL_CALLCONV void Perl_watch(pTHX_ char **addr) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_WATCH \ assert(addr) @@ -5576,37 +6540,47 @@ Perl_watch(pTHX_ char **addr) Perl_whichsig(pTHX_ const char *sig); */ PERL_CALLCONV I32 -Perl_whichsig_pv(pTHX_ const char *sig); +Perl_whichsig_pv(pTHX_ const char *sig) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_WHICHSIG_PV \ assert(sig) PERL_CALLCONV I32 -Perl_whichsig_pvn(pTHX_ const char *sig, STRLEN len); +Perl_whichsig_pvn(pTHX_ const char *sig, STRLEN len) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_WHICHSIG_PVN \ assert(sig) PERL_CALLCONV I32 -Perl_whichsig_sv(pTHX_ SV *sigsv); +Perl_whichsig_sv(pTHX_ SV *sigsv) + Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_WHICHSIG_SV \ assert(sigsv) PERL_CALLCONV void -Perl_wrap_infix_plugin(pTHX_ Perl_infix_plugin_t new_plugin, Perl_infix_plugin_t *old_plugin_p); +Perl_wrap_infix_plugin(pTHX_ Perl_infix_plugin_t new_plugin, Perl_infix_plugin_t *old_plugin_p) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_WRAP_INFIX_PLUGIN \ assert(new_plugin); assert(old_plugin_p) PERL_CALLCONV void -Perl_wrap_keyword_plugin(pTHX_ Perl_keyword_plugin_t new_plugin, Perl_keyword_plugin_t *old_plugin_p); +Perl_wrap_keyword_plugin(pTHX_ Perl_keyword_plugin_t new_plugin, Perl_keyword_plugin_t *old_plugin_p) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_WRAP_KEYWORD_PLUGIN \ assert(new_plugin); assert(old_plugin_p) PERL_CALLCONV void -Perl_wrap_op_checker(pTHX_ Optype opcode, Perl_check_t new_checker, Perl_check_t *old_checker_p); +Perl_wrap_op_checker(pTHX_ Optype opcode, Perl_check_t new_checker, Perl_check_t *old_checker_p) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_WRAP_OP_CHECKER \ assert(new_checker); assert(old_checker_p) PERL_CALLCONV void Perl_write_to_stderr(pTHX_ SV *msv) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_WRITE_TO_STDERR \ assert(msv) @@ -5616,18 +6590,22 @@ Perl_xs_boot_epilog(pTHX_ const SSize_t ax); #define PERL_ARGS_ASSERT_XS_BOOT_EPILOG PERL_CALLCONV Stack_off_t -Perl_xs_handshake(const U32 key, void *v_my_perl, const char *file, ...); +Perl_xs_handshake(const U32 key, void *v_my_perl, const char *file, ...) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(3); #define PERL_ARGS_ASSERT_XS_HANDSHAKE \ assert(v_my_perl); assert(file) PERL_CALLCONV int Perl_yyerror(pTHX_ const char * const s) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_YYERROR \ assert(s) PERL_CALLCONV int Perl_yyerror_pv(pTHX_ const char * const s, U32 flags) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_YYERROR_PV \ assert(s) @@ -5657,18 +6635,21 @@ Perl_yyunlex(pTHX) #if defined(DEBUGGING) PERL_CALLCONV int Perl_get_debug_opts(pTHX_ const char **s, bool givehelp) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_GET_DEBUG_OPTS \ assert(s) PERL_CALLCONV void -Perl_hv_assert(pTHX_ HV *hv); +Perl_hv_assert(pTHX_ HV *hv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_HV_ASSERT \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void -Perl_pad_setsv(pTHX_ PADOFFSET po, SV *sv); +Perl_pad_setsv(pTHX_ PADOFFSET po, SV *sv) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PAD_SETSV \ assert(sv) @@ -5677,7 +6658,8 @@ Perl_pad_sv(pTHX_ PADOFFSET po); # define PERL_ARGS_ASSERT_PAD_SV PERL_CALLCONV void -Perl_set_padlist(CV *cv, PADLIST *padlist); +Perl_set_padlist(CV *cv, PADLIST *padlist) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_SET_PADLIST \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) @@ -5685,6 +6667,7 @@ Perl_set_padlist(CV *cv, PADLIST *padlist); #if defined(DEBUG_LEAKING_SCALARS_FORK_DUMP) PERL_CALLCONV void Perl_dump_sv_child(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DUMP_SV_CHILD \ assert(sv) @@ -5710,14 +6693,17 @@ Perl_my_chsize(pTHX_ int fd, Off_t length) #if !defined(HAS_GETENV_LEN) PERL_CALLCONV char * Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_GETENV_LEN \ assert(env_elem); assert(len) -#endif +#endif /* !defined(HAS_GETENV_LEN) */ #if !defined(HAS_MKOSTEMP) PERL_CALLCONV int Perl_my_mkostemp(char *templte, int flags) + Perl_attribute_nonnull_(1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MY_MKOSTEMP \ assert(templte) @@ -5726,6 +6712,7 @@ Perl_my_mkostemp(char *templte, int flags) #if !defined(HAS_MKSTEMP) PERL_CALLCONV int Perl_my_mkstemp(char *templte) + Perl_attribute_nonnull_(1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MY_MKSTEMP \ assert(templte) @@ -5734,36 +6721,48 @@ Perl_my_mkstemp(char *templte) #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) PERL_CALLCONV I32 Perl_do_ipcctl(pTHX_ I32 optype, SV **mark, SV **sp) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_IPCCTL \ assert(mark); assert(sp) PERL_CALLCONV I32 Perl_do_ipcget(pTHX_ I32 optype, SV **mark, SV **sp) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_IPCGET \ assert(mark); assert(sp) PERL_CALLCONV SSize_t Perl_do_msgrcv(pTHX_ SV **mark, SV **sp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_MSGRCV \ assert(mark); assert(sp) PERL_CALLCONV I32 Perl_do_msgsnd(pTHX_ SV **mark, SV **sp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_MSGSND \ assert(mark); assert(sp) PERL_CALLCONV I32 Perl_do_semop(pTHX_ SV **mark, SV **sp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_SEMOP \ assert(mark); assert(sp) PERL_CALLCONV I32 Perl_do_shmio(pTHX_ I32 optype, SV **mark, SV **sp) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_SHMIO \ assert(mark); assert(sp) @@ -5772,20 +6771,23 @@ Perl_do_shmio(pTHX_ I32 optype, SV **mark, SV **sp) #if defined(HAS_PIPE) PERL_CALLCONV int Perl_PerlProc_pipe_cloexec(pTHX_ int *pipefd) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_PERLPROC_PIPE_CLOEXEC \ assert(pipefd) -#endif +#endif /* defined(HAS_PIPE) */ #if !defined(HAS_RENAME) PERL_CALLCONV I32 Perl_same_dirent(pTHX_ const char *a, const char *b) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_SAME_DIRENT \ assert(a); assert(b) -#endif +#endif /* !defined(HAS_RENAME) */ #if !defined(HAS_SIGNBIT) PERL_CALLCONV int Perl_signbit(NV f) @@ -5813,18 +6815,32 @@ Perl_PerlSock_socket_cloexec(pTHX_ int domain, int type, int protocol) defined(SOCK_DGRAM) ) PERL_CALLCONV int Perl_PerlSock_socketpair_cloexec(pTHX_ int domain, int type, int protocol, int *pairfd) + Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_PERLSOCK_SOCKETPAIR_CLOEXEC \ assert(pairfd) -#endif +#endif /* defined(HAS_SOCKETPAIR) || + ( defined(AF_INET) && defined(HAS_SOCKET) && defined(PF_INET) && + defined(SOCK_DGRAM) ) */ #if !defined(HAS_STRLCPY) STATIC Size_t Perl_my_strlcpy(char *dst, const char *src, Size_t size); # define PERL_ARGS_ASSERT_MY_STRLCPY #endif +#if !defined(HAS_STRNLEN) + +# if !defined(PERL_NO_INLINE_FUNCTIONS) +PERL_STATIC_INLINE Size_t +Perl_my_strnlen(const char *str, Size_t maxlen) + Perl_attribute_nonnull_(1); +# define PERL_ARGS_ASSERT_MY_STRNLEN \ + assert(str) + +# endif +#endif /* !defined(HAS_STRNLEN) */ #if defined(HAVE_INTERP_INTERN) PERL_CALLCONV void Perl_sys_intern_clear(pTHX); @@ -5836,7 +6852,9 @@ Perl_sys_intern_init(pTHX); # if defined(USE_ITHREADS) PERL_CALLCONV void -Perl_sys_intern_dup(pTHX_ struct interp_intern *src, struct interp_intern *dst); +Perl_sys_intern_dup(pTHX_ struct interp_intern *src, struct interp_intern *dst) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SYS_INTERN_DUP \ assert(src); assert(dst) @@ -5845,19 +6863,23 @@ Perl_sys_intern_dup(pTHX_ struct interp_intern *src, struct interp_intern *dst); #if defined(_MSC_VER) PERL_CALLCONV int Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ assert(sv); assert(mg) -#else +#else /* if !defined(_MSC_VER) */ PERL_CALLCONV_NO_RET int Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__noreturn__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ assert(sv); assert(mg) -#endif +#endif /* !defined(_MSC_VER) */ #if defined(MULTIPLICITY) PERL_CALLCONV_NO_RET void Perl_croak_nocontext(const char *pat, ...) @@ -5867,6 +6889,7 @@ Perl_croak_nocontext(const char *pat, ...) PERL_CALLCONV void Perl_deb_nocontext(const char *pat, ...) + Perl_attribute_nonnull_(1) __attribute__format__(__printf__,1,2); # define PERL_ARGS_ASSERT_DEB_NOCONTEXT \ assert(pat) @@ -5879,64 +6902,79 @@ Perl_die_nocontext(const char *pat, ...) PERL_CALLCONV char * Perl_form_nocontext(const char *pat, ...) + Perl_attribute_nonnull_(1) __attribute__format__(__printf__,1,2); # define PERL_ARGS_ASSERT_FORM_NOCONTEXT \ assert(pat) PERL_CALLCONV void -Perl_load_module_nocontext(U32 flags, SV *name, SV *ver, ...); +Perl_load_module_nocontext(U32 flags, SV *name, SV *ver, ...) + Perl_attribute_nonnull_(2); # define PERL_ARGS_ASSERT_LOAD_MODULE_NOCONTEXT \ assert(name) PERL_CALLCONV SV * Perl_mess_nocontext(const char *pat, ...) + Perl_attribute_nonnull_(1) __attribute__format__(__printf__,1,2); # define PERL_ARGS_ASSERT_MESS_NOCONTEXT \ assert(pat) PERL_CALLCONV void * -Perl_my_cxt_init(pTHX_ int *indexp, size_t size); +Perl_my_cxt_init(pTHX_ int *indexp, size_t size) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_MY_CXT_INIT \ assert(indexp) PERL_CALLCONV SV * Perl_newSVpvf_nocontext(const char * const pat, ...) + Perl_attribute_nonnull_(1) __attribute__format__(__printf__,1,2); # define PERL_ARGS_ASSERT_NEWSVPVF_NOCONTEXT \ assert(pat) PERL_CALLCONV void Perl_sv_catpvf_mg_nocontext(SV * const sv, const char * const pat, ...) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__format__(__printf__,2,3); # define PERL_ARGS_ASSERT_SV_CATPVF_MG_NOCONTEXT \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_catpvf_nocontext(SV * const sv, const char * const pat, ...) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__format__(__printf__,2,3); # define PERL_ARGS_ASSERT_SV_CATPVF_NOCONTEXT \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_setpvf_mg_nocontext(SV * const sv, const char * const pat, ...) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__format__(__printf__,2,3); # define PERL_ARGS_ASSERT_SV_SETPVF_MG_NOCONTEXT \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_setpvf_nocontext(SV * const sv, const char * const pat, ...) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__format__(__printf__,2,3); # define PERL_ARGS_ASSERT_SV_SETPVF_NOCONTEXT \ assert(sv); assert(pat) PERL_CALLCONV void Perl_warn_nocontext(const char *pat, ...) + Perl_attribute_nonnull_(1) __attribute__format__(__printf__,1,2); # define PERL_ARGS_ASSERT_WARN_NOCONTEXT \ assert(pat) PERL_CALLCONV void Perl_warner_nocontext(U32 err, const char *pat, ...) + Perl_attribute_nonnull_(2) __attribute__format__(__printf__,2,3); # define PERL_ARGS_ASSERT_WARNER_NOCONTEXT \ assert(pat) @@ -5944,12 +6982,14 @@ Perl_warner_nocontext(U32 err, const char *pat, ...) #endif /* defined(MULTIPLICITY) */ #if defined(MYMALLOC) PERL_CALLCONV void -Perl_dump_mstats(pTHX_ const char *s); +Perl_dump_mstats(pTHX_ const char *s) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DUMP_MSTATS \ assert(s) PERL_CALLCONV int -Perl_get_mstats(pTHX_ perl_mstats_t *buf, int buflen, int level); +Perl_get_mstats(pTHX_ perl_mstats_t *buf, int buflen, int level) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GET_MSTATS \ assert(buf) @@ -5961,6 +7001,7 @@ Perl_malloc_good_size(size_t nbytes) PERL_CALLCONV MEM_SIZE Perl_malloced_size(void *p) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MALLOCED_SIZE \ @@ -5974,24 +7015,28 @@ Perl_load_mathoms(void); PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) + Perl_attribute_nonnull_(pTHX_1) __attribute__deprecated__; # define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \ assert(s) PERL_CALLCONV UV Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) + Perl_attribute_nonnull_(pTHX_1) __attribute__deprecated__; # define PERL_ARGS_ASSERT_UTF8_TO_UVUNI \ assert(s) PERL_CALLCONV UV Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) + Perl_attribute_nonnull_(pTHX_1) __attribute__deprecated__; # define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI \ assert(s) PERL_CALLCONV U8 * Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv) + Perl_attribute_nonnull_(pTHX_1) __attribute__deprecated__; # define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \ assert(d) @@ -6010,42 +7055,50 @@ Perl_ref(pTHX_ OP *o, I32 type); # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV SV * -Perl_sv_setsv_cow(pTHX_ SV *dsv, SV *ssv); +Perl_sv_setsv_cow(pTHX_ SV *dsv, SV *ssv) + Perl_attribute_nonnull_(pTHX_2); # endif -#endif +#endif /* defined(PERL_ANY_COW) */ #if defined(PERL_CORE) PERL_CALLCONV void Perl_opslab_force_free(pTHX_ OPSLAB *slab) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OPSLAB_FORCE_FREE \ assert(slab) PERL_CALLCONV void Perl_opslab_free(pTHX_ OPSLAB *slab) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OPSLAB_FREE \ assert(slab) PERL_CALLCONV void Perl_opslab_free_nopad(pTHX_ OPSLAB *slab) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OPSLAB_FREE_NOPAD \ assert(slab) PERL_CALLCONV void Perl_parser_free_nexttoke_ops(pTHX_ yy_parser *parser, OPSLAB *slab) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_PARSER_FREE_NEXTTOKE_OPS \ assert(parser); assert(slab) # if defined(PERL_DEBUG_READONLY_OPS) PERL_CALLCONV void -Perl_Slab_to_ro(pTHX_ OPSLAB *slab); +Perl_Slab_to_ro(pTHX_ OPSLAB *slab) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SLAB_TO_RO \ assert(slab) PERL_CALLCONV void -Perl_Slab_to_rw(pTHX_ OPSLAB * const slab); +Perl_Slab_to_rw(pTHX_ OPSLAB * const slab) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SLAB_TO_RW \ assert(slab) @@ -6053,6 +7106,7 @@ Perl_Slab_to_rw(pTHX_ OPSLAB * const slab); # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE bool S_should_warn_nl(const char *pv) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SHOULD_WARN_NL \ assert(pv) @@ -6061,7 +7115,8 @@ S_should_warn_nl(const char *pv) #endif /* defined(PERL_CORE) */ #if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV void -Perl_av_reify(pTHX_ AV *av); +Perl_av_reify(pTHX_ AV *av) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV const char * Perl_byte_dump_string_(pTHX_ const U8 * const start, const STRLEN len, const bool format); PERL_CALLCONV const char * @@ -6070,21 +7125,33 @@ Perl_cntrl_to_mnemonic(const U8 c) PERL_CALLCONV regexp_engine const * Perl_current_re_engine(pTHX); PERL_CALLCONV void -Perl_cv_ckproto_len_flags(pTHX_ const CV *cv, const GV *gv, const char *p, const STRLEN len, const U32 flags); +Perl_cv_ckproto_len_flags(pTHX_ const CV *cv, const GV *gv, const char *p, const STRLEN len, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV char * -Perl_delimcpy_no_escape(char *to, const char *to_end, const char *from, const char *from_end, const int delim, I32 *retlen); +Perl_delimcpy_no_escape(char *to, const char *to_end, const char *from, const char *from_end, const int delim, I32 *retlen) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(3) + Perl_attribute_nonnull_(4) + Perl_attribute_nonnull_(6); PERL_CALLCONV I16 Perl_do_uniprop_match(const char * const key, const U16 key_len) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; PERL_CALLCONV char * Perl_dup_warnings(pTHX_ char *warnings); PERL_CALLCONV void -Perl_emulate_cop_io(pTHX_ const COP * const c, SV * const sv); +Perl_emulate_cop_io(pTHX_ const COP * const c, SV * const sv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); PERL_CALLCONV Size_t Perl_expected_size(UV size) __attribute__visibility__("hidden"); PERL_CALLCONV SV * Perl_get_and_check_backslash_N_name(pTHX_ const char *s, const char *e, const bool is_utf8, const char **error_msg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; PERL_CALLCONV const char * Perl_get_deprecated_property_msg(const Size_t warning_offset) @@ -6097,80 +7164,125 @@ Perl_get_prop_values(const int table_index) __attribute__warn_unused_result__; PERL_CALLCONV Size_t Perl_inverse_folds_(pTHX_ const UV cp, U32 *first_folds_to, const U32 **remaining_folds_to) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; PERL_CALLCONV HV * Perl_load_charnames(pTHX_ SV *char_name, const char *context, const STRLEN context_len, const char **error_msg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; PERL_CALLCONV int Perl_mbtowc_(pTHX_ const wchar_t *pwc, const char *s, const Size_t len); PERL_CALLCONV MAGIC * Perl_mg_find_mglob(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; PERL_CALLCONV SV * -Perl_multiconcat_stringify(pTHX_ const OP *o); +Perl_multiconcat_stringify(pTHX_ const OP *o) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV SV * -Perl_multideref_stringify(pTHX_ const OP *o, CV *cv); +Perl_multideref_stringify(pTHX_ const OP *o, CV *cv) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV char * Perl_new_warnings_bitfield(pTHX_ char *buffer, const char * const bits, STRLEN size) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; PERL_CALLCONV void -Perl_op_clear(pTHX_ OP *o); +Perl_op_clear(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void Perl_qerror(pTHX_ SV *err); PERL_CALLCONV SV * -Perl_reg_named_buff(pTHX_ REGEXP * const rx, SV * const key, SV * const value, const U32 flags); +Perl_reg_named_buff(pTHX_ REGEXP * const rx, SV * const key, SV * const value, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV SV * -Perl_reg_named_buff_iter(pTHX_ REGEXP * const rx, const SV * const lastkey, const U32 flags); +Perl_reg_named_buff_iter(pTHX_ REGEXP * const rx, const SV * const lastkey, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void -Perl_reg_numbered_buff_fetch(pTHX_ REGEXP * const re, const I32 paren, SV * const sv); +Perl_reg_numbered_buff_fetch(pTHX_ REGEXP * const re, const I32 paren, SV * const sv) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void -Perl_reg_numbered_buff_fetch_flags(pTHX_ REGEXP * const re, const I32 paren, SV * const sv, U32 flags); +Perl_reg_numbered_buff_fetch_flags(pTHX_ REGEXP * const re, const I32 paren, SV * const sv, U32 flags) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV I32 -Perl_reg_numbered_buff_length(pTHX_ REGEXP * const rx, const SV * const sv, const I32 paren); +Perl_reg_numbered_buff_length(pTHX_ REGEXP * const rx, const SV * const sv, const I32 paren) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); PERL_CALLCONV void -Perl_reg_numbered_buff_store(pTHX_ REGEXP * const rx, const I32 paren, SV const * const value); +Perl_reg_numbered_buff_store(pTHX_ REGEXP * const rx, const I32 paren, SV const * const value) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV SV * -Perl_reg_qr_package(pTHX_ REGEXP * const rx); +Perl_reg_qr_package(pTHX_ REGEXP * const rx) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV REGEXP * -Perl_reg_temp_copy(pTHX_ REGEXP *dsv, REGEXP *ssv); +Perl_reg_temp_copy(pTHX_ REGEXP *dsv, REGEXP *ssv) + Perl_attribute_nonnull_(pTHX_2); PERL_CALLCONV void Perl_report_uninit(pTHX_ const SV *uninit_sv); PERL_CALLCONV char * Perl_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, char **delimp) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; PERL_CALLCONV char * -Perl_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp); +Perl_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_5); PERL_CALLCONV char * Perl_skipspace_flags(pTHX_ char *s, U32 flags) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; PERL_CALLCONV MAGIC * -Perl_sv_magicext_mglob(pTHX_ SV *sv); +Perl_sv_magicext_mglob(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV U8 * -Perl_utf16_to_utf8(pTHX_ U8 *p, U8 *d, Size_t bytelen, Size_t *newlen); +Perl_utf16_to_utf8(pTHX_ U8 *p, U8 *d, Size_t bytelen, Size_t *newlen) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_4); PERL_CALLCONV U8 * -Perl_utf16_to_utf8_base(pTHX_ U8 *p, U8 *d, Size_t bytelen, Size_t *newlen, const bool high, const bool low); +Perl_utf16_to_utf8_base(pTHX_ U8 *p, U8 *d, Size_t bytelen, Size_t *newlen, const bool high, const bool low) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_4); PERL_CALLCONV U8 * -Perl_utf16_to_utf8_reversed(pTHX_ U8 *p, U8 *d, Size_t bytelen, Size_t *newlen); +Perl_utf16_to_utf8_reversed(pTHX_ U8 *p, U8 *d, Size_t bytelen, Size_t *newlen) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_4); PERL_CALLCONV U8 * -Perl_utf8_to_utf16_base(pTHX_ U8 *s, U8 *d, Size_t bytelen, Size_t *newlen, const bool high, const bool low); +Perl_utf8_to_utf16_base(pTHX_ U8 *s, U8 *d, Size_t bytelen, Size_t *newlen, const bool high, const bool low) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_4); PERL_CALLCONV bool -Perl_validate_proto(pTHX_ SV *name, SV *proto, bool warn, bool curstash); +Perl_validate_proto(pTHX_ SV *name, SV *proto, bool warn, bool curstash) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void -Perl_vivify_defelem(pTHX_ SV *sv); +Perl_vivify_defelem(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV int Perl_yylex(pTHX); PERL_CALLCONV bool Perl_isSCRIPT_RUN(pTHX_ const U8 *s, const U8 *send, const bool utf8_target) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_ISSCRIPT_RUN \ assert(s); assert(send) +# if !defined(HAS_MEMRCHR) + +# endif # if defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || \ defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_ANY) || \ defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C) || \ defined(PERL_IN_UTF8_C) PERL_CALLCONV SSize_t Perl__invlist_search(SV * const invlist, const UV cp) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; # endif # if defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || \ @@ -6179,16 +7291,22 @@ PERL_CALLCONV SV * Perl__add_range_to_invlist(pTHX_ SV *invlist, UV start, UV end) __attribute__warn_unused_result__; PERL_CALLCONV void -Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV * const a, SV * const b, const bool complement_b, SV **i); +Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV * const a, SV * const b, const bool complement_b, SV **i) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_4); PERL_CALLCONV void -Perl__invlist_invert(pTHX_ SV * const invlist); +Perl__invlist_invert(pTHX_ SV * const invlist) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void -Perl__invlist_union_maybe_complement_2nd(pTHX_ SV * const a, SV * const b, const bool complement_b, SV **output); +Perl__invlist_union_maybe_complement_2nd(pTHX_ SV * const a, SV * const b, const bool complement_b, SV **output) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_4); PERL_CALLCONV SV * Perl__new_invlist(pTHX_ IV initial_size) __attribute__warn_unused_result__; PERL_CALLCONV SV * Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV **other_elements_ptr) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; # endif /* defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_UTF8_C) */ @@ -6196,15 +7314,27 @@ Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV **othe defined(PERL_IN_TOKE_C) PERL_CALLCONV const char * Perl_form_alien_digit_msg(pTHX_ const U8 which, const STRLEN valids_len, const char * const first_bad, const char * const send, const bool UTF, const bool braced) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_grok_bslash_c(pTHX_ const char source, U8 *result, const char **message, U32 *packed_warn) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_grok_bslash_o(pTHX_ char **s, const char * const send, UV *uv, const char **message, U32 *packed_warn, const bool strict, const bool allow_UV_MAX, const bool utf8) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_grok_bslash_x(pTHX_ char **s, const char * const send, UV *uv, const char **message, U32 *packed_warn, const bool strict, const bool allow_UV_MAX, const bool utf8) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; # endif /* defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) */ @@ -6217,39 +7347,56 @@ Perl_form_cp_too_large_msg(pTHX_ const U8 which, const char *string, const Size_ # if defined(PERL_IN_DUMP_C) || defined(PERL_IN_OP_C) || \ defined(PERL_IN_REGCOMP_ANY) PERL_CALLCONV void -Perl__invlist_dump(pTHX_ PerlIO *file, I32 level, const char * const indent, SV * const invlist); +Perl__invlist_dump(pTHX_ PerlIO *file, I32 level, const char * const indent, SV * const invlist) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4); # endif # if defined(PERL_IN_PERL_C) || defined(PERL_IN_REGCOMP_ANY) || \ defined(PERL_IN_UTF8_C) PERL_CALLCONV bool -Perl__invlistEQ(pTHX_ SV * const a, SV * const b, const bool complement_b); +Perl__invlistEQ(pTHX_ SV * const a, SV * const b, const bool complement_b) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); PERL_CALLCONV SV * Perl__new_invlist_C_array(pTHX_ const UV * const list) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # endif # if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || \ defined(PERL_IN_TOKE_C) PERL_CALLCONV bool Perl_is_grapheme(pTHX_ const U8 *strbeg, const U8 *s, const U8 *strend, const UV cp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # endif # if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || \ defined(PERL_IN_UTF8_C) PERL_CALLCONV UV -Perl_to_fold_latin1_(const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags); +Perl_to_fold_latin1_(const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(3); # endif # if defined(PERL_IN_REGCOMP_DEBUG_C) && defined(DEBUGGING) STATIC U8 -S_put_charclass_bitmap_innards(pTHX_ SV *sv, char *bitmap, SV *nonbitmap_invlist, SV *only_utf8_locale_invlist, const regnode * const node, const U8 flags, const bool force_as_is_display); +S_put_charclass_bitmap_innards(pTHX_ SV *sv, char *bitmap, SV *nonbitmap_invlist, SV *only_utf8_locale_invlist, const regnode * const node, const U8 flags, const bool force_as_is_display) + Perl_attribute_nonnull_(pTHX_1); STATIC SV * -S_put_charclass_bitmap_innards_common(pTHX_ SV *invlist, SV *posixes, SV *only_utf8, SV *not_utf8, SV *only_utf8_locale, const bool invert); +S_put_charclass_bitmap_innards_common(pTHX_ SV *invlist, SV *posixes, SV *only_utf8, SV *not_utf8, SV *only_utf8_locale, const bool invert) + Perl_attribute_nonnull_(pTHX_1); STATIC void -S_put_charclass_bitmap_innards_invlist(pTHX_ SV *sv, SV *invlist); +S_put_charclass_bitmap_innards_invlist(pTHX_ SV *sv, SV *invlist) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); STATIC void -S_put_code_point(pTHX_ SV *sv, UV c); +S_put_code_point(pTHX_ SV *sv, UV c) + Perl_attribute_nonnull_(pTHX_1); STATIC void -S_put_range(pTHX_ SV *sv, UV start, const UV end, const bool allow_literals); +S_put_range(pTHX_ SV *sv, UV start, const UV end, const bool allow_literals) + Perl_attribute_nonnull_(pTHX_1); STATIC void S_regdump_extflags(pTHX_ const char *lead, const U32 flags); STATIC void @@ -6258,12 +7405,14 @@ S_regdump_intflags(pTHX_ const char *lead, const U32 flags); #endif /* defined(PERL_CORE) || defined(PERL_EXT) */ #if defined(PERL_CORE) || defined(PERL_USE_VOLATILE_API) PERL_CALLCONV void -Perl_finalize_optree(pTHX_ OP *o); +Perl_finalize_optree(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FINALIZE_OPTREE \ assert(o) PERL_CALLCONV void -Perl_optimize_optree(pTHX_ OP *o); +Perl_optimize_optree(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_OPTIMIZE_OPTREE \ assert(o) @@ -6271,6 +7420,7 @@ Perl_optimize_optree(pTHX_ OP *o); #if defined(PERL_DEBUG_READONLY_COW) PERL_CALLCONV void Perl_sv_buf_to_ro(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_SV_BUF_TO_RO \ assert(sv) @@ -6278,7 +7428,8 @@ Perl_sv_buf_to_ro(pTHX_ SV *sv) #endif #if defined(PERL_DEBUG_READONLY_OPS) PERL_CALLCONV PADOFFSET -Perl_op_refcnt_dec(pTHX_ OP *o); +Perl_op_refcnt_dec(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_OP_REFCNT_DEC \ assert(o) @@ -6290,6 +7441,7 @@ Perl_op_refcnt_inc(pTHX_ OP *o); #if defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION) PERL_CALLCONV bool Perl_do_exec(pTHX_ const char *cmd) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_EXEC \ assert(cmd) @@ -6297,6 +7449,7 @@ Perl_do_exec(pTHX_ const char *cmd) #else PERL_CALLCONV bool Perl_do_exec(pTHX_ const char *cmd) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_EXEC \ assert(cmd) @@ -6309,33 +7462,66 @@ Perl_gv_SVadd(pTHX_ GV *gv); */ #endif #if defined(PERL_IMPLICIT_SYS) PERL_CALLCONV PerlInterpreter * -perl_alloc_using(const struct IPerlMem **ipM, const struct IPerlMem **ipMS, const struct IPerlMem **ipMP, const struct IPerlEnv **ipE, const struct IPerlStdIO **ipStd, const struct IPerlLIO **ipLIO, const struct IPerlDir **ipD, const struct IPerlSock **ipS, const struct IPerlProc **ipP); +perl_alloc_using(const struct IPerlMem **ipM, const struct IPerlMem **ipMS, const struct IPerlMem **ipMP, const struct IPerlEnv **ipE, const struct IPerlStdIO **ipStd, const struct IPerlLIO **ipLIO, const struct IPerlDir **ipD, const struct IPerlSock **ipS, const struct IPerlProc **ipP) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(3) + Perl_attribute_nonnull_(4) + Perl_attribute_nonnull_(5) + Perl_attribute_nonnull_(6) + Perl_attribute_nonnull_(7) + Perl_attribute_nonnull_(8) + Perl_attribute_nonnull_(9); # define PERL_ARGS_ASSERT_PERL_ALLOC_USING \ assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); \ assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) # if defined(USE_ITHREADS) PERL_CALLCONV PerlInterpreter * -perl_clone_using(PerlInterpreter *proto_perl, UV flags, const struct IPerlMem **ipM, const struct IPerlMem **ipMS, const struct IPerlMem **ipMP, const struct IPerlEnv **ipE, const struct IPerlStdIO **ipStd, const struct IPerlLIO **ipLIO, const struct IPerlDir **ipD, const struct IPerlSock **ipS, const struct IPerlProc **ipP); +perl_clone_using(PerlInterpreter *proto_perl, UV flags, const struct IPerlMem **ipM, const struct IPerlMem **ipMS, const struct IPerlMem **ipMP, const struct IPerlEnv **ipE, const struct IPerlStdIO **ipStd, const struct IPerlLIO **ipLIO, const struct IPerlDir **ipD, const struct IPerlSock **ipS, const struct IPerlProc **ipP) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(3) + Perl_attribute_nonnull_(4) + Perl_attribute_nonnull_(5) + Perl_attribute_nonnull_(6) + Perl_attribute_nonnull_(7) + Perl_attribute_nonnull_(8) + Perl_attribute_nonnull_(9) + Perl_attribute_nonnull_(10) + Perl_attribute_nonnull_(11); # define PERL_ARGS_ASSERT_PERL_CLONE_USING \ assert(proto_perl); assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); \ assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) -# endif +# endif /* defined(USE_ITHREADS) */ #else /* 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); +Perl_my_popen(pTHX_ const char *cmd, const char *mode) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_MY_POPEN \ assert(cmd); assert(mode) +# if defined(USE_ITHREADS) + +# if !defined(PERL_NO_INLINE_FUNCTIONS) +PERL_STATIC_INLINE bool +S_PerlEnv_putenv(pTHX_ char *str) + Perl_attribute_nonnull_(pTHX_1); +# define PERL_ARGS_ASSERT_PERLENV_PUTENV \ + assert(str) + +# endif +# endif /* defined(USE_ITHREADS) */ #endif /* !defined(PERL_IMPLICIT_SYS) */ #if defined(PERL_IN_AV_C) STATIC MAGIC * -S_get_aux_mg(pTHX_ AV *av); +S_get_aux_mg(pTHX_ AV *av) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GET_AUX_MG \ assert(av); assert(SvTYPE(av) == SVt_PVAV) @@ -6343,6 +7529,7 @@ S_get_aux_mg(pTHX_ AV *av); #if defined(PERL_IN_BUILTIN_C) || defined(PERL_IN_OP_C) PERL_CALLCONV void Perl_XS_builtin_indexed(pTHX_ CV *cv) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_XS_BUILTIN_INDEXED \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) @@ -6365,7 +7552,8 @@ Perl_prepare_export_lexical(pTHX) #endif /* defined(PERL_IN_BUILTIN_C) || defined(PERL_IN_OP_C) */ #if defined(PERL_IN_CLASS_C) STATIC void -S_class_cleanup_definition(pTHX_ HV *stash); +S_class_cleanup_definition(pTHX_ HV *stash) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLASS_CLEANUP_DEFINITION \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) @@ -6374,6 +7562,7 @@ S_class_cleanup_definition(pTHX_ HV *stash); defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) PERL_CALLCONV OP * Perl_ck_anoncode(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_ANONCODE \ @@ -6381,6 +7570,7 @@ Perl_ck_anoncode(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_backtick(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_BACKTICK \ @@ -6388,6 +7578,7 @@ Perl_ck_backtick(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_bitop(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_BITOP \ @@ -6395,6 +7586,7 @@ Perl_ck_bitop(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_classname(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_CLASSNAME \ @@ -6402,6 +7594,7 @@ Perl_ck_classname(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_cmp(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_CMP \ @@ -6409,6 +7602,7 @@ Perl_ck_cmp(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_concat(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_CONCAT \ @@ -6416,6 +7610,7 @@ Perl_ck_concat(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_defined(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_DEFINED \ @@ -6423,6 +7618,7 @@ Perl_ck_defined(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_delete(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_DELETE \ @@ -6430,6 +7626,7 @@ Perl_ck_delete(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_each(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_EACH \ @@ -6437,6 +7634,7 @@ Perl_ck_each(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_eof(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_EOF \ @@ -6444,6 +7642,7 @@ Perl_ck_eof(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_eval(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_EVAL \ @@ -6451,6 +7650,7 @@ Perl_ck_eval(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_exec(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_EXEC \ @@ -6458,6 +7658,7 @@ Perl_ck_exec(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_exists(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_EXISTS \ @@ -6465,6 +7666,7 @@ Perl_ck_exists(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_ftst(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_FTST \ @@ -6472,6 +7674,7 @@ Perl_ck_ftst(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_fun(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_FUN \ @@ -6479,6 +7682,7 @@ Perl_ck_fun(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_glob(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_GLOB \ @@ -6486,6 +7690,7 @@ Perl_ck_glob(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_grep(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_GREP \ @@ -6493,6 +7698,7 @@ Perl_ck_grep(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_helemexistsor(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_HELEMEXISTSOR \ @@ -6500,6 +7706,7 @@ Perl_ck_helemexistsor(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_index(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_INDEX \ @@ -6507,6 +7714,7 @@ Perl_ck_index(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_isa(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_ISA \ @@ -6514,6 +7722,7 @@ Perl_ck_isa(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_join(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_JOIN \ @@ -6521,6 +7730,7 @@ Perl_ck_join(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_length(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_LENGTH \ @@ -6528,6 +7738,7 @@ Perl_ck_length(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_lfun(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_LFUN \ @@ -6535,6 +7746,7 @@ Perl_ck_lfun(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_listiob(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_LISTIOB \ @@ -6542,6 +7754,7 @@ Perl_ck_listiob(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_match(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_MATCH \ @@ -6549,6 +7762,7 @@ Perl_ck_match(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_method(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_METHOD \ @@ -6556,6 +7770,7 @@ Perl_ck_method(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_null(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_NULL \ @@ -6563,6 +7778,7 @@ Perl_ck_null(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_open(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_OPEN \ @@ -6570,6 +7786,7 @@ Perl_ck_open(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_prototype(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_PROTOTYPE \ @@ -6577,6 +7794,7 @@ Perl_ck_prototype(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_readline(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_READLINE \ @@ -6584,6 +7802,7 @@ Perl_ck_readline(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_refassign(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_REFASSIGN \ @@ -6591,6 +7810,7 @@ Perl_ck_refassign(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_repeat(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_REPEAT \ @@ -6598,6 +7818,7 @@ Perl_ck_repeat(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_require(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_REQUIRE \ @@ -6605,6 +7826,7 @@ Perl_ck_require(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_return(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_RETURN \ @@ -6612,6 +7834,7 @@ Perl_ck_return(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_rfun(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_RFUN \ @@ -6619,6 +7842,7 @@ Perl_ck_rfun(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_rvconst(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_RVCONST \ @@ -6626,6 +7850,7 @@ Perl_ck_rvconst(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_sassign(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SASSIGN \ @@ -6633,6 +7858,7 @@ Perl_ck_sassign(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_scmp(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SCMP \ @@ -6640,6 +7866,7 @@ Perl_ck_scmp(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_select(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SELECT \ @@ -6647,6 +7874,7 @@ Perl_ck_select(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_shift(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SHIFT \ @@ -6654,6 +7882,7 @@ Perl_ck_shift(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_smartmatch(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SMARTMATCH \ @@ -6661,6 +7890,7 @@ Perl_ck_smartmatch(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_sort(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SORT \ @@ -6668,6 +7898,7 @@ Perl_ck_sort(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_spair(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SPAIR \ @@ -6675,6 +7906,7 @@ Perl_ck_spair(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_split(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SPLIT \ @@ -6682,6 +7914,7 @@ Perl_ck_split(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_stringify(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_STRINGIFY \ @@ -6689,6 +7922,7 @@ Perl_ck_stringify(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_subr(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SUBR \ @@ -6696,6 +7930,7 @@ Perl_ck_subr(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_substr(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SUBSTR \ @@ -6703,6 +7938,7 @@ Perl_ck_substr(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_svconst(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SVCONST \ @@ -6710,6 +7946,7 @@ Perl_ck_svconst(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_tell(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_TELL \ @@ -6717,6 +7954,7 @@ Perl_ck_tell(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_trunc(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_TRUNC \ @@ -6724,6 +7962,7 @@ Perl_ck_trunc(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_trycatch(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_TRYCATCH \ @@ -6735,23 +7974,29 @@ Perl_ck_trycatch(pTHX_ OP *o) defined(PERL_IN_PAD_C) || defined(PERL_IN_PERLY_C) || \ defined(PERL_IN_TOKE_C) PERL_CALLCONV void -Perl_class_add_ADJUST(pTHX_ HV *stash, CV *cv); +Perl_class_add_ADJUST(pTHX_ HV *stash, CV *cv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CLASS_ADD_ADJUST \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV); assert(cv); \ assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void -Perl_class_add_field(pTHX_ HV *stash, PADNAME *pn); +Perl_class_add_field(pTHX_ HV *stash, PADNAME *pn) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CLASS_ADD_FIELD \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV); assert(pn) PERL_CALLCONV void -Perl_class_apply_attributes(pTHX_ HV *stash, OP *attrlist); +Perl_class_apply_attributes(pTHX_ HV *stash, OP *attrlist) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLASS_APPLY_ATTRIBUTES \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void -Perl_class_apply_field_attributes(pTHX_ PADNAME *pn, OP *attrlist); +Perl_class_apply_field_attributes(pTHX_ PADNAME *pn, OP *attrlist) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLASS_APPLY_FIELD_ATTRIBUTES \ assert(pn) @@ -6760,22 +8005,27 @@ Perl_class_prepare_initfield_parse(pTHX); # define PERL_ARGS_ASSERT_CLASS_PREPARE_INITFIELD_PARSE PERL_CALLCONV void -Perl_class_prepare_method_parse(pTHX_ CV *cv); +Perl_class_prepare_method_parse(pTHX_ CV *cv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLASS_PREPARE_METHOD_PARSE \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void -Perl_class_seal_stash(pTHX_ HV *stash); +Perl_class_seal_stash(pTHX_ HV *stash) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLASS_SEAL_STASH \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void -Perl_class_set_field_defop(pTHX_ PADNAME *pn, OPCODE defmode, OP *defop); +Perl_class_set_field_defop(pTHX_ PADNAME *pn, OPCODE defmode, OP *defop) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_CLASS_SET_FIELD_DEFOP \ assert(pn); assert(defop) PERL_CALLCONV void -Perl_class_setup_stash(pTHX_ HV *stash); +Perl_class_setup_stash(pTHX_ HV *stash) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLASS_SETUP_STASH \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) @@ -6784,7 +8034,8 @@ Perl_class_wrap_method_body(pTHX_ OP *o); # define PERL_ARGS_ASSERT_CLASS_WRAP_METHOD_BODY PERL_CALLCONV void -Perl_croak_kw_unless_class(pTHX_ const char *kw); +Perl_croak_kw_unless_class(pTHX_ const char *kw) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CROAK_KW_UNLESS_CLASS \ assert(kw) @@ -6793,34 +8044,49 @@ Perl_croak_kw_unless_class(pTHX_ const char *kw); defined(PERL_IN_TOKE_C) */ #if defined(PERL_IN_DEB_C) STATIC void -S_deb_stack_n(pTHX_ SV **stack_base, SSize_t stack_min, SSize_t stack_max, SSize_t mark_min, SSize_t mark_max, SSize_t nonrc_base); +S_deb_stack_n(pTHX_ SV **stack_base, SSize_t stack_min, SSize_t stack_max, SSize_t mark_min, SSize_t mark_max, SSize_t nonrc_base) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DEB_STACK_N \ assert(stack_base) #endif #if defined(PERL_IN_DOIO_C) STATIC bool -S_argvout_final(pTHX_ MAGIC *mg, IO *io, bool is_explicit); +S_argvout_final(pTHX_ MAGIC *mg, IO *io, bool is_explicit) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_ARGVOUT_FINAL \ assert(mg); assert(io) STATIC void -S_exec_failed(pTHX_ const char *cmd, int fd, int do_report); +S_exec_failed(pTHX_ const char *cmd, int fd, int do_report) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_EXEC_FAILED \ assert(cmd) STATIC bool -S_is_fork_open(const char *name); +S_is_fork_open(const char *name) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_IS_FORK_OPEN \ assert(name) 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); +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) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5); # define PERL_ARGS_ASSERT_OPENN_CLEANUP \ assert(gv); assert(io); assert(mode); assert(oname) STATIC IO * -S_openn_setup(pTHX_ GV *gv, char *mode, PerlIO **saveifp, PerlIO **saveofp, int *savefd, char *savetype); +S_openn_setup(pTHX_ GV *gv, char *mode, PerlIO **saveifp, PerlIO **saveofp, int *savefd, char *savetype) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5) + Perl_attribute_nonnull_(pTHX_6); # define PERL_ARGS_ASSERT_OPENN_SETUP \ assert(gv); assert(mode); assert(saveifp); assert(saveofp); \ assert(savefd); assert(savetype) @@ -6836,30 +8102,40 @@ S_ingroup(pTHX_ Gid_t testgid, bool effective) #if defined(PERL_IN_DOOP_C) STATIC Size_t S_do_trans_complex(pTHX_ SV * const sv, const OPtrans_map * const tbl) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX \ assert(sv); assert(tbl) STATIC Size_t S_do_trans_count(pTHX_ SV * const sv, const OPtrans_map * const tbl) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DO_TRANS_COUNT \ assert(sv); assert(tbl) STATIC Size_t S_do_trans_count_invmap(pTHX_ SV * const sv, AV * const invmap) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DO_TRANS_COUNT_INVMAP \ assert(sv); assert(invmap); assert(SvTYPE(invmap) == SVt_PVAV) STATIC Size_t S_do_trans_invmap(pTHX_ SV * const sv, AV * const invmap) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DO_TRANS_INVMAP \ assert(sv); assert(invmap); assert(SvTYPE(invmap) == SVt_PVAV) STATIC Size_t S_do_trans_simple(pTHX_ SV * const sv, const OPtrans_map * const tbl) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE \ assert(sv); assert(tbl) @@ -6937,17 +8213,21 @@ S_deb_curcv(pTHX_ I32 ix); # define PERL_ARGS_ASSERT_DEB_CURCV STATIC void -S_debprof(pTHX_ const OP *o); +S_debprof(pTHX_ const OP *o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DEBPROF \ assert(o) STATIC SV * -S_pm_description(pTHX_ const PMOP *pm); +S_pm_description(pTHX_ const PMOP *pm) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_PM_DESCRIPTION \ assert(pm) STATIC char * -S_pv_display_flags(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim, I32 pretty_flags); +S_pv_display_flags(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim, I32 pretty_flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PV_DISPLAY_FLAGS \ assert(dsv); assert(pv) @@ -6960,6 +8240,7 @@ S_sequence_num(pTHX_ const OP *o); defined(PERL_IN_SCOPE_C) || defined(PERL_IN_SV_C) PERL_CALLCONV void Perl_hv_kill_backrefs(pTHX_ HV *hv) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_HV_KILL_BACKREFS \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) @@ -6973,43 +8254,60 @@ Perl_hv_kill_backrefs(pTHX_ HV *hv) #endif #if defined(PERL_IN_GV_C) STATIC bool -S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len, const U32 is_utf8, const I32 add, const svtype sv_type); +S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len, const U32 is_utf8, const I32 add, const svtype sv_type) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_FIND_DEFAULT_STASH \ assert(stash); assert(name) STATIC void -S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type); +S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GV_INIT_SVTYPE \ assert(gv) STATIC bool -S_gv_is_in_main(pTHX_ const char *name, STRLEN len, const U32 is_utf8); +S_gv_is_in_main(pTHX_ const char *name, STRLEN len, const U32 is_utf8) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GV_IS_IN_MAIN \ assert(name) STATIC bool -S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, const svtype sv_type); +S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, const svtype sv_type) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_GV_MAGICALIZE \ assert(gv); assert(stash); assert(SvTYPE(stash) == SVt_PVHV); \ assert(name) STATIC void -S_gv_magicalize_isa(pTHX_ GV *gv); +S_gv_magicalize_isa(pTHX_ GV *gv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA \ assert(gv) STATIC void -S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type); +S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_MAYBE_MULTIMAGIC_GV \ assert(gv); assert(name) STATIC bool -S_parse_gv_stash_name(pTHX_ HV **stash, GV **gv, const char **name, STRLEN *len, const char *nambeg, STRLEN full_len, const U32 is_utf8, const I32 add); +S_parse_gv_stash_name(pTHX_ HV **stash, GV **gv, const char **name, STRLEN *len, const char *nambeg, STRLEN full_len, const U32 is_utf8, const I32 add) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5); # define PERL_ARGS_ASSERT_PARSE_GV_STASH_NAME \ assert(stash); assert(gv); assert(name); assert(len); assert(nambeg) STATIC void -S_require_tie_mod(pTHX_ GV *gv, const char varname, const char *name, STRLEN len, const U32 flags); +S_require_tie_mod(pTHX_ GV *gv, const char varname, const char *name, STRLEN len, const U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_REQUIRE_TIE_MOD \ assert(gv); assert(name) @@ -7020,7 +8318,8 @@ S_gv_fetchmeth_internal(pTHX_ HV *stash, SV *meth, const char *name, STRLEN len, assert(!stash || SvTYPE(stash) == SVt_PVHV) PERL_STATIC_INLINE HV * -S_gv_stashpvn_internal(pTHX_ const char *name, U32 namelen, I32 flags); +S_gv_stashpvn_internal(pTHX_ const char *name, U32 namelen, I32 flags) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GV_STASHPVN_INTERNAL \ assert(name) @@ -7030,11 +8329,14 @@ S_gv_stashpvn_internal(pTHX_ const char *name, U32 namelen, I32 flags); defined(PERL_IN_PAD_C) || defined(PERL_IN_SV_C) PERL_CALLCONV void Perl_sv_add_backref(pTHX_ SV * const tsv, SV * const sv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_SV_ADD_BACKREF \ assert(tsv); assert(sv) -#endif +#endif /* defined(PERL_IN_GV_C) || defined(PERL_IN_OP_C) || + defined(PERL_IN_PAD_C) || defined(PERL_IN_SV_C) */ #if defined(PERL_IN_GV_C) || defined(PERL_IN_UNIVERSAL_C) # define PERL_ARGS_ASSERT_GV_STASHSVPVN_CACHED \ assert(namesv || name) @@ -7047,17 +8349,20 @@ Perl_gv_stashsvpvn_cached(pTHX_ SV *namesv, const char *name, U32 namelen, I32 f #endif /* defined(PERL_IN_GV_C) || defined(PERL_IN_UNIVERSAL_C) */ #if defined(PERL_IN_HV_C) STATIC void -S_clear_placeholders(pTHX_ HV *hv, U32 items); +S_clear_placeholders(pTHX_ HV *hv, U32 items) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLEAR_PLACEHOLDERS \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) STATIC void -S_hsplit(pTHX_ HV *hv, STRLEN const oldsize, STRLEN newsize); +S_hsplit(pTHX_ HV *hv, STRLEN const oldsize, STRLEN newsize) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_HSPLIT \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) STATIC struct xpvhv_aux * -S_hv_auxinit(pTHX_ HV *hv); +S_hv_auxinit(pTHX_ HV *hv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_HV_AUXINIT \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) @@ -7067,34 +8372,43 @@ S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_ assert(!hv || SvTYPE(hv) == SVt_PVHV) STATIC SV * -S_hv_free_ent_ret(pTHX_ HE *entry); +S_hv_free_ent_ret(pTHX_ HE *entry) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_HV_FREE_ENT_RET \ assert(entry) STATIC void -S_hv_free_entries(pTHX_ HV *hv); +S_hv_free_entries(pTHX_ HV *hv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_HV_FREE_ENTRIES \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) STATIC void -S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store); +S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(3); # define PERL_ARGS_ASSERT_HV_MAGIC_CHECK \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(needs_copy); \ assert(needs_store) PERL_STATIC_NO_RET void S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_4) __attribute__noreturn__; # define PERL_ARGS_ASSERT_HV_NOTALLOWED \ assert(key); assert(msg) STATIC SV * -S_refcounted_he_value(pTHX_ const struct refcounted_he *he); +S_refcounted_he_value(pTHX_ const struct refcounted_he *he) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE \ assert(he) STATIC HEK * S_save_hek_flags(const char *str, I32 len, U32 hash, int flags) + Perl_attribute_nonnull_(1) __attribute__malloc__ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SAVE_HEK_FLAGS \ @@ -7102,6 +8416,7 @@ S_save_hek_flags(const char *str, I32 len, U32 hash, int flags) STATIC HEK * S_share_hek_flags(pTHX_ const char *str, STRLEN len, U32 hash, int flags) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SHARE_HEK_FLAGS \ assert(str) @@ -7121,6 +8436,7 @@ S_new_he(pTHX) #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) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_SV_KILL_BACKREFS \ assert(sv) @@ -7129,23 +8445,28 @@ Perl_sv_kill_backrefs(pTHX_ SV * const sv, AV * const av) #if defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) PERL_CALLCONV SV * Perl_hfree_next_entry(pTHX_ HV *hv, STRLEN *indexp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_HFREE_NEXT_ENTRY \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(indexp) -#endif +#endif /* defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) */ #if defined(PERL_IN_LOCALE_C) STATIC utf8ness_t S_get_locale_string_utf8ness_i(pTHX_ const char *string, const locale_utf8ness_t known_utf8, const char *locale, const locale_category_index cat_index); # define PERL_ARGS_ASSERT_GET_LOCALE_STRING_UTF8NESS_I STATIC void -S_ints_to_tm(pTHX_ struct tm *my_tm, const char *locale, int sec, int min, int hour, int mday, int mon, int year, int isdst); +S_ints_to_tm(pTHX_ struct tm *my_tm, const char *locale, int sec, int min, int hour, int mday, int mon, int year, int isdst) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_INTS_TO_TM \ assert(my_tm); assert(locale) STATIC bool -S_is_locale_utf8(pTHX_ const char *locale); +S_is_locale_utf8(pTHX_ const char *locale) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_IS_LOCALE_UTF8 \ assert(locale) @@ -7154,31 +8475,49 @@ S_my_localeconv(pTHX_ const int item); # define PERL_ARGS_ASSERT_MY_LOCALECONV STATIC void -S_populate_hash_from_C_localeconv(pTHX_ HV *hv, const char *locale, const U32 which_mask, const lconv_offset_t *strings[2], const lconv_offset_t *integers[2]); +S_populate_hash_from_C_localeconv(pTHX_ HV *hv, const char *locale, const U32 which_mask, const lconv_offset_t *strings[2], const lconv_offset_t *integers[2]) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5); # define PERL_ARGS_ASSERT_POPULATE_HASH_FROM_C_LOCALECONV \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(locale); \ assert(strings); assert(integers) STATIC bool -S_strftime8(pTHX_ const char *fmt, SV *sv, const char *locale, const struct tm *mytm, const utf8ness_t fmt_utf8ness, utf8ness_t *result_utf8ness, const bool called_externally); +S_strftime8(pTHX_ const char *fmt, SV *sv, const char *locale, const struct tm *mytm, const utf8ness_t fmt_utf8ness, utf8ness_t *result_utf8ness, const bool called_externally) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_6); # define PERL_ARGS_ASSERT_STRFTIME8 \ assert(fmt); assert(sv); assert(locale); assert(mytm); \ assert(result_utf8ness) STATIC bool S_strftime_tm(pTHX_ const char *fmt, SV *sv, const char *locale, const struct tm *mytm) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) __attribute__format__(__strftime__,pTHX_1,0); # define PERL_ARGS_ASSERT_STRFTIME_TM \ assert(fmt); assert(sv); assert(locale); assert(mytm) STATIC SV * -S_sv_strftime_common(pTHX_ SV *fmt, const char *locale, const struct tm *mytm); +S_sv_strftime_common(pTHX_ SV *fmt, const char *locale, const struct tm *mytm) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_SV_STRFTIME_COMMON \ assert(fmt); assert(locale); assert(mytm) # if defined(HAS_MISSING_LANGINFO_ITEM_) || !defined(HAS_NL_LANGINFO) STATIC const char * -S_emulate_langinfo(pTHX_ const PERL_INTMAX_T item, const char *locale, SV *sv, utf8ness_t *utf8ness); +S_emulate_langinfo(pTHX_ const PERL_INTMAX_T item, const char *locale, SV *sv, utf8ness_t *utf8ness) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_EMULATE_LANGINFO \ assert(locale); assert(sv) @@ -7189,7 +8528,8 @@ S_calculate_LC_ALL_string(pTHX_ const char **category_locales_list, const calc_L # define PERL_ARGS_ASSERT_CALCULATE_LC_ALL_STRING STATIC const char * -S_external_call_langinfo(pTHX_ const nl_item item, SV *sv, utf8ness_t *utf8ness); +S_external_call_langinfo(pTHX_ const nl_item item, SV *sv, utf8ness_t *utf8ness) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_EXTERNAL_CALL_LANGINFO \ assert(sv) @@ -7203,7 +8543,8 @@ S_native_querylocale_i(pTHX_ const locale_category_index cat_index); # define PERL_ARGS_ASSERT_NATIVE_QUERYLOCALE_I STATIC void -S_new_LC_ALL(pTHX_ const char *lc_all, bool force); +S_new_LC_ALL(pTHX_ const char *lc_all, bool force) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_NEW_LC_ALL \ assert(lc_all) @@ -7212,7 +8553,9 @@ S_output_check_environment_warning(pTHX_ const char * const language, const char # define PERL_ARGS_ASSERT_OUTPUT_CHECK_ENVIRONMENT_WARNING STATIC parse_LC_ALL_string_return -S_parse_LC_ALL_string(pTHX_ const char *string, const char **output, const parse_LC_ALL_STRING_action, bool always_use_full_array, const bool panic_on_error, const line_t caller_line); +S_parse_LC_ALL_string(pTHX_ const char *string, const char **output, const parse_LC_ALL_STRING_action, bool always_use_full_array, const bool panic_on_error, const line_t caller_line) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PARSE_LC_ALL_STRING \ assert(string); assert(output) @@ -7230,12 +8573,15 @@ S_set_save_buffer_min_size(pTHX_ const Size_t min_len, char **buf, Size_t *buf_s PERL_STATIC_NO_RET void S_setlocale_failure_panic_via_i(pTHX_ const locale_category_index cat_index, const char *current, const char *failed, const line_t proxy_caller_line, const line_t immediate_caller_line, const char *higher_caller_file, const line_t higher_caller_line) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_6) __attribute__noreturn__; # define PERL_ARGS_ASSERT_SETLOCALE_FAILURE_PANIC_VIA_I \ assert(failed); assert(higher_caller_file) STATIC const char * -S_toggle_locale_i(pTHX_ const locale_category_index cat_index, const char *new_locale, const line_t caller_line); +S_toggle_locale_i(pTHX_ const locale_category_index cat_index, const char *new_locale, const line_t caller_line) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_TOGGLE_LOCALE_I \ assert(new_locale) @@ -7249,28 +8595,38 @@ S_my_setlocale_debug_string_i(pTHX_ const locale_category_index cat_index, const # if defined(HAS_LOCALECONV) && \ ( defined(USE_LOCALE_MONETARY) || defined(USE_LOCALE_NUMERIC) ) STATIC void -S_populate_hash_from_localeconv(pTHX_ HV *hv, const char *locale, const U32 which_mask, const lconv_offset_t *strings[2], const lconv_offset_t *integers[2]); +S_populate_hash_from_localeconv(pTHX_ HV *hv, const char *locale, const U32 which_mask, const lconv_offset_t *strings[2], const lconv_offset_t *integers[2]) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5); # define PERL_ARGS_ASSERT_POPULATE_HASH_FROM_LOCALECONV \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(locale); \ assert(strings); assert(integers) -# endif +# endif /* defined(HAS_LOCALECONV) && + ( defined(USE_LOCALE_MONETARY) || + defined(USE_LOCALE_NUMERIC) ) */ # if defined(HAS_NL_LANGINFO) STATIC const char * -S_langinfo_sv_i(pTHX_ const nl_item item, locale_category_index cat_index, const char *locale, SV *sv, utf8ness_t *utf8ness); +S_langinfo_sv_i(pTHX_ const nl_item item, locale_category_index cat_index, const char *locale, SV *sv, utf8ness_t *utf8ness) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_LANGINFO_SV_I \ assert(locale); assert(sv) # endif # if defined(LC_ALL) STATIC void -S_give_perl_locale_control(pTHX_ const char *lc_all_string, const line_t caller_line); +S_give_perl_locale_control(pTHX_ const char *lc_all_string, const line_t caller_line) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GIVE_PERL_LOCALE_CONTROL \ assert(lc_all_string) # else STATIC void -S_give_perl_locale_control(pTHX_ const char **curlocales, const line_t caller_line); +S_give_perl_locale_control(pTHX_ const char **curlocales, const line_t caller_line) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GIVE_PERL_LOCALE_CONTROL \ assert(curlocales) @@ -7284,13 +8640,16 @@ S_mortalized_pv_copy(pTHX_ const char * const pv) # endif # if defined(USE_LOCALE_COLLATE) STATIC void -S_new_collate(pTHX_ const char *newcoll, bool force); +S_new_collate(pTHX_ const char *newcoll, bool force) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_NEW_COLLATE \ assert(newcoll) # if defined(DEBUGGING) STATIC void -S_print_collxfrm_input_and_return(pTHX_ const char *s, const char *e, const char *xbuf, const STRLEN xlen, const bool is_utf8); +S_print_collxfrm_input_and_return(pTHX_ const char *s, const char *e, const char *xbuf, const STRLEN xlen, const bool is_utf8) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PRINT_COLLXFRM_INPUT_AND_RETURN \ assert(s); assert(e) @@ -7298,19 +8657,22 @@ S_print_collxfrm_input_and_return(pTHX_ const char *s, const char *e, const char # endif /* defined(USE_LOCALE_COLLATE) */ # if defined(USE_LOCALE_CTYPE) STATIC bool -S_is_codeset_name_UTF8(const char *name); +S_is_codeset_name_UTF8(const char *name) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_IS_CODESET_NAME_UTF8 \ assert(name) STATIC void -S_new_ctype(pTHX_ const char *newctype, bool force); +S_new_ctype(pTHX_ const char *newctype, bool force) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_NEW_CTYPE \ assert(newctype) # endif /* defined(USE_LOCALE_CTYPE) */ # if defined(USE_LOCALE_NUMERIC) STATIC void -S_new_numeric(pTHX_ const char *newnum, bool force); +S_new_numeric(pTHX_ const char *newnum, bool force) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_NEW_NUMERIC \ assert(newnum) @@ -7323,7 +8685,8 @@ S_get_LC_ALL_display(pTHX); # endif # if defined(USE_POSIX_2008_LOCALE) STATIC bool -S_bool_setlocale_2008_i(pTHX_ const locale_category_index index, const char *new_locale, const line_t caller_line); +S_bool_setlocale_2008_i(pTHX_ const locale_category_index index, const char *new_locale, const line_t caller_line) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_BOOL_SETLOCALE_2008_I \ assert(new_locale) @@ -7337,7 +8700,8 @@ S_use_curlocale_scratch(pTHX); # if !defined(USE_QUERYLOCALE) STATIC void -S_update_PL_curlocales_i(pTHX_ const locale_category_index index, const char *new_locale, const line_t caller_line); +S_update_PL_curlocales_i(pTHX_ const locale_category_index index, const char *new_locale, const line_t caller_line) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_UPDATE_PL_CURLOCALES_I \ assert(new_locale) @@ -7347,7 +8711,8 @@ S_update_PL_curlocales_i(pTHX_ const locale_category_index index, const char *ne !defined(USE_THREAD_SAFE_LOCALE_EMULATION) /* && !defined(USE_POSIX_2008_LOCALE) */ STATIC bool -S_less_dicey_bool_setlocale_r(pTHX_ const int cat, const char *locale); +S_less_dicey_bool_setlocale_r(pTHX_ const int cat, const char *locale) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_LESS_DICEY_BOOL_SETLOCALE_R \ assert(locale) @@ -7387,7 +8752,9 @@ S_find_locale_from_environment(pTHX_ const locale_category_index index); # endif /* defined(USE_LOCALE) */ # if defined(USE_LOCALE) || defined(DEBUGGING) STATIC const char * -S_get_displayable_string(pTHX_ const char * const s, const char * const e, const bool is_utf8); +S_get_displayable_string(pTHX_ const char * const s, const char * const e, const bool is_utf8) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_GET_DISPLAYABLE_STRING \ assert(s); assert(e) @@ -7395,24 +8762,32 @@ S_get_displayable_string(pTHX_ const char * const s, const char * const e, const #endif /* defined(PERL_IN_LOCALE_C) */ #if defined(PERL_IN_MALLOC_C) STATIC int -S_adjust_size_and_find_bucket(size_t *nbytes_p); +S_adjust_size_and_find_bucket(size_t *nbytes_p) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_ADJUST_SIZE_AND_FIND_BUCKET \ assert(nbytes_p) #endif #if defined(PERL_IN_MG_C) STATIC void -S_fixup_errno_string(pTHX_ SV *sv); +S_fixup_errno_string(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FIXUP_ERRNO_STRING \ assert(sv) STATIC SV * -S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, int n, SV *val); +S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, int n, SV *val) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_MAGIC_METHCALL1 \ assert(sv); assert(mg); assert(meth) STATIC int -S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth); +S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_MAGIC_METHPACK \ assert(sv); assert(mg); assert(meth) @@ -7421,7 +8796,8 @@ S_restore_magic(pTHX_ void *p); # define PERL_ARGS_ASSERT_RESTORE_MAGIC STATIC void -S_save_magic_flags(pTHX_ SSize_t mgs_ix, SV *sv, U32 flags); +S_save_magic_flags(pTHX_ SSize_t mgs_ix, SV *sv, U32 flags) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS \ assert(sv) @@ -7433,20 +8809,27 @@ S_unwind_handler_stack(pTHX_ void *p); #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) + Perl_attribute_nonnull_(6) + Perl_attribute_nonnull_(7) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_TRANSLATE_SUBSTR_OFFSETS \ assert(posp); assert(lenp) -#endif +#endif /* defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C) */ #if defined(PERL_IN_MRO_C) STATIC void -S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN len, HV * const exceptions, U32 hash, U32 flags); +S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN len, HV * const exceptions, U32 hash, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV \ assert(isa); assert(SvTYPE(isa) == SVt_PVHV); assert(name); \ assert(!exceptions || SvTYPE(exceptions) == SVt_PVHV) STATIC void -S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes, HV *stash, HV *oldstash, SV *namesv); +S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes, HV *stash, HV *oldstash, SV *namesv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_5); # define PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME \ assert(stashes); assert(SvTYPE(stashes) == SVt_PVHV); \ assert(seen_stashes); assert(SvTYPE(seen_stashes) == SVt_PVHV); \ @@ -7454,7 +8837,8 @@ S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes, HV *s assert(!oldstash || SvTYPE(oldstash) == SVt_PVHV); assert(namesv) STATIC AV * -S_mro_get_linear_isa_dfs(pTHX_ HV *stash, U32 level); +S_mro_get_linear_isa_dfs(pTHX_ HV *stash, U32 level) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) @@ -7467,12 +8851,17 @@ S_output_non_portable(pTHX_ const U8 shift); #endif #if defined(PERL_IN_OP_C) STATIC void -S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs); +S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_APPLY_ATTRS \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV); assert(target) STATIC void -S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp); +S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_APPLY_ATTRS_MY \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV); assert(target); \ assert(imopsp) @@ -7483,38 +8872,51 @@ S_assignment_type(pTHX_ const OP *o) # define PERL_ARGS_ASSERT_ASSIGNMENT_TYPE STATIC void -S_bad_type_gv(pTHX_ I32 n, GV *gv, const OP *kid, const char *t); +S_bad_type_gv(pTHX_ I32 n, GV *gv, const OP *kid, const char *t) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_BAD_TYPE_GV \ assert(gv); assert(kid); assert(t) STATIC void -S_bad_type_pv(pTHX_ I32 n, const char *t, const OP *o, const OP *kid); +S_bad_type_pv(pTHX_ I32 n, const char *t, const OP *o, const OP *kid) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_BAD_TYPE_PV \ assert(t); assert(o); assert(kid) STATIC void -S_clear_special_blocks(pTHX_ const char * const fullname, GV * const gv, CV * const cv); +S_clear_special_blocks(pTHX_ const char * const fullname, GV * const gv, CV * const cv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_CLEAR_SPECIAL_BLOCKS \ assert(fullname); assert(gv); assert(cv); \ assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) STATIC void -S_cop_free(pTHX_ COP *cop); +S_cop_free(pTHX_ COP *cop) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_COP_FREE \ assert(cop) STATIC OP * -S_dup_attrlist(pTHX_ OP *o); +S_dup_attrlist(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DUP_ATTRLIST \ assert(o) STATIC void -S_find_and_forget_pmops(pTHX_ OP *o); +S_find_and_forget_pmops(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS \ assert(o) STATIC OP * -S_fold_constants(pTHX_ OP * const o); +S_fold_constants(pTHX_ OP * const o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FOLD_CONSTANTS \ assert(o) @@ -7523,7 +8925,8 @@ S_force_list(pTHX_ OP *arg, bool nullit); # define PERL_ARGS_ASSERT_FORCE_LIST STATIC void -S_forget_pmop(pTHX_ PMOP * const o); +S_forget_pmop(pTHX_ PMOP * const o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FORGET_PMOP \ assert(o) @@ -7532,12 +8935,14 @@ S_gen_constant_list(pTHX_ OP *o); # define PERL_ARGS_ASSERT_GEN_CONSTANT_LIST STATIC void -S_inplace_aassign(pTHX_ OP *o); +S_inplace_aassign(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_INPLACE_AASSIGN \ assert(o) STATIC bool S_is_handle_constructor(const OP *o, I32 numargs) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR \ assert(o) @@ -7547,7 +8952,8 @@ S_listkids(pTHX_ OP *o); # define PERL_ARGS_ASSERT_LISTKIDS STATIC bool -S_looks_like_bool(pTHX_ const OP *o); +S_looks_like_bool(pTHX_ const OP *o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_LOOKS_LIKE_BOOL \ assert(o) @@ -7556,39 +8962,53 @@ 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); +S_move_proto_attr(pTHX_ OP **proto, OP **attrs, const GV *name, bool curstash) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_MOVE_PROTO_ATTR \ assert(proto); assert(attrs); assert(name) STATIC OP * -S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp); +S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_MY_KID \ assert(imopsp) STATIC OP * -S_newGIVWHENOP(pTHX_ OP *cond, OP *block, I32 enter_opcode, I32 leave_opcode, PADOFFSET entertarg); +S_newGIVWHENOP(pTHX_ OP *cond, OP *block, I32 enter_opcode, I32 leave_opcode, PADOFFSET entertarg) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_NEWGIVWHENOP \ assert(block) STATIC OP * S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NEW_LOGOP \ assert(firstp); assert(otherp) STATIC OP * S_no_fh_allowed(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NO_FH_ALLOWED \ assert(o) STATIC OP * -S_pmtrans(pTHX_ OP *o, OP *expr, OP *repl); +S_pmtrans(pTHX_ OP *o, OP *expr, OP *repl) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_PMTRANS \ assert(o); assert(expr); assert(repl) STATIC bool -S_process_special_blocks(pTHX_ I32 floor, const char * const fullname, GV * const gv, CV * const cv); +S_process_special_blocks(pTHX_ I32 floor, const char * const fullname, GV * const gv, CV * const cv) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS \ assert(fullname); assert(gv); assert(cv); \ assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) @@ -7607,7 +9027,8 @@ S_scalar_mod_type(const OP *o, I32 type) # define PERL_ARGS_ASSERT_SCALAR_MOD_TYPE STATIC OP * -S_scalarboolean(pTHX_ OP *o); +S_scalarboolean(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SCALARBOOLEAN \ assert(o) @@ -7617,23 +9038,29 @@ S_scalarkids(pTHX_ OP *o); STATIC OP * S_search_const(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SEARCH_CONST \ assert(o) STATIC void -S_simplify_sort(pTHX_ OP *o); +S_simplify_sort(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SIMPLIFY_SORT \ assert(o) STATIC OP * S_too_few_arguments_pv(pTHX_ OP *o, const char *name, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_PV \ assert(o); assert(name) STATIC OP * -S_too_many_arguments_pv(pTHX_ OP *o, const char *name, U32 flags); +S_too_many_arguments_pv(pTHX_ OP *o, const char *name, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_PV \ assert(o); assert(name) @@ -7643,14 +9070,16 @@ S_voidnonfinal(pTHX_ OP *o); # if defined(DEBUGGING) STATIC const char * -S_get_displayable_tr_operand(pTHX_ const U8 *s, STRLEN len, bool is_utf8); +S_get_displayable_tr_operand(pTHX_ const U8 *s, STRLEN len, bool is_utf8) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GET_DISPLAYABLE_TR_OPERAND \ assert(s) # endif # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE bool -S_is_standard_filehandle_name(const char *fhname); +S_is_standard_filehandle_name(const char *fhname) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_IS_STANDARD_FILEHANDLE_NAME \ assert(fhname) @@ -7659,17 +9088,21 @@ S_newMETHOP_internal(pTHX_ I32 type, I32 flags, OP *dynamic_meth, SV * const_met # define PERL_ARGS_ASSERT_NEWMETHOP_INTERNAL PERL_STATIC_INLINE OP * -S_op_integerize(pTHX_ OP *o); +S_op_integerize(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_OP_INTEGERIZE \ assert(o) PERL_STATIC_INLINE OP * -S_op_std_init(pTHX_ OP *o); +S_op_std_init(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_OP_STD_INIT \ assert(o) PERL_STATIC_INLINE U16 -S_opslab_slot_offset(const OPSLAB *slab, const OPSLOT *slot); +S_opslab_slot_offset(const OPSLAB *slab, const OPSLOT *slot) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2); # define PERL_ARGS_ASSERT_OPSLAB_SLOT_OFFSET \ assert(slab); assert(slot) @@ -7679,6 +9112,9 @@ S_size_to_psize(size_t size); # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ #endif /* defined(PERL_IN_OP_C) */ +#if defined(PERL_IN_OP_C) || defined(PERL_IN_PAD_C) + +#endif #if defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) PERL_CALLCONV void Perl_check_hash_fields_and_hekify(pTHX_ UNOP *rop, SVOP *key_op, int real) @@ -7687,24 +9123,29 @@ Perl_check_hash_fields_and_hekify(pTHX_ UNOP *rop, SVOP *key_op, int real) PERL_CALLCONV void Perl_no_bareword_allowed(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_NO_BAREWORD_ALLOWED \ assert(o) PERL_CALLCONV void Perl_op_prune_chain_head(OP **op_p) + Perl_attribute_nonnull_(1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OP_PRUNE_CHAIN_HEAD \ assert(op_p) PERL_CALLCONV SV * Perl_op_varname(pTHX_ const OP *o) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OP_VARNAME \ assert(o) PERL_CALLCONV void Perl_warn_elem_scalar_context(pTHX_ const OP *o, SV *name, bool is_hash, bool is_slice) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_WARN_ELEM_SCALAR_CONTEXT \ assert(o); assert(name) @@ -7716,6 +9157,8 @@ Perl_warn_elem_scalar_context(pTHX_ const OP *o, SV *name, bool is_hash, bool is #if defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C) PERL_CALLCONV void Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_cv, SV * const *new_const_svp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_REPORT_REDEFINED_CV \ assert(name); assert(old_cv) @@ -7729,17 +9172,23 @@ Perl_varname(pTHX_ const GV * const gv, const char gvtype, PADOFFSET targ, const #endif /* defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C) */ #if defined(PERL_IN_PAD_C) STATIC PADOFFSET -S_pad_alloc_name(pTHX_ PADNAME *name, U32 flags, HV *typestash, HV *ourstash); +S_pad_alloc_name(pTHX_ PADNAME *name, U32 flags, HV *typestash, HV *ourstash) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_PAD_ALLOC_NAME \ assert(name); assert(!ourstash || SvTYPE(ourstash) == SVt_PVHV) STATIC void -S_pad_check_dup(pTHX_ PADNAME *name, U32 flags, const HV *ourstash); +S_pad_check_dup(pTHX_ PADNAME *name, U32 flags, const HV *ourstash) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_PAD_CHECK_DUP \ assert(name) STATIC PADOFFSET -S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV *cv, U32 seq, int warn, SV **out_capture, PADNAME **out_name, int *out_flags); +S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV *cv, U32 seq, int warn, SV **out_capture, PADNAME **out_name, int *out_flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_8) + Perl_attribute_nonnull_(pTHX_9); # define PERL_ARGS_ASSERT_PAD_FINDLEX \ assert(namepv); assert(cv); assert(out_name); assert(out_flags) @@ -7749,7 +9198,9 @@ S_pad_reset(pTHX); # if defined(DEBUGGING) STATIC void -S_cv_dump(pTHX_ const CV *cv, const char *title); +S_cv_dump(pTHX_ const CV *cv, const char *title) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CV_DUMP \ assert(cv); assert(title) @@ -7757,24 +9208,30 @@ S_cv_dump(pTHX_ const CV *cv, const char *title); #endif /* defined(PERL_IN_PAD_C) */ #if defined(PERL_IN_PEEP_C) STATIC void -S_finalize_op(pTHX_ OP *o); +S_finalize_op(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FINALIZE_OP \ assert(o) STATIC void -S_optimize_op(pTHX_ OP *o); +S_optimize_op(pTHX_ OP *o) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_OPTIMIZE_OP \ assert(o) STATIC OP * -S_traverse_op_tree(pTHX_ OP *top, OP *o); +S_traverse_op_tree(pTHX_ OP *top, OP *o) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_TRAVERSE_OP_TREE \ assert(top); assert(o) #endif /* defined(PERL_IN_PEEP_C) */ #if defined(PERL_IN_PERL_C) STATIC void -S_find_beginning(pTHX_ SV *linestr_sv, PerlIO *rsfp); +S_find_beginning(pTHX_ SV *linestr_sv, PerlIO *rsfp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_FIND_BEGINNING \ assert(linestr_sv); assert(rsfp) @@ -7783,12 +9240,14 @@ 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); +S_incpush(pTHX_ const char * const dir, STRLEN len, U32 flags) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_INCPUSH \ assert(dir) STATIC void -S_incpush_use_sep(pTHX_ const char *p, STRLEN len, U32 flags); +S_incpush_use_sep(pTHX_ const char *p, STRLEN len, U32 flags) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_INCPUSH_USE_SEP \ assert(p) @@ -7809,7 +9268,8 @@ S_init_perllib(pTHX); # define PERL_ARGS_ASSERT_INIT_PERLLIB STATIC void -S_init_postdump_symbols(pTHX_ int argc, char **argv, char **env); +S_init_postdump_symbols(pTHX_ int argc, char **argv, char **env) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_INIT_POSTDUMP_SYMBOLS \ assert(argv) @@ -7818,7 +9278,8 @@ 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); +S_mayberelocate(pTHX_ const char * const dir, STRLEN len, U32 flags) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_MAYBERELOCATE \ assert(dir) @@ -7837,7 +9298,9 @@ S_nuke_stacks(pTHX); # define PERL_ARGS_ASSERT_NUKE_STACKS STATIC PerlIO * -S_open_script(pTHX_ const char *scriptname, bool dosearch, bool *suidscript); +S_open_script(pTHX_ const char *scriptname, bool dosearch, bool *suidscript) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_OPEN_SCRIPT \ assert(scriptname); assert(suidscript) @@ -7857,14 +9320,18 @@ S_usage(pTHX) # if !defined(PERL_IS_MINIPERL) STATIC SV * -S_incpush_if_exists(pTHX_ AV * const av, SV *dir, SV * const stem); +S_incpush_if_exists(pTHX_ AV * const av, SV *dir, SV * const stem) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_INCPUSH_IF_EXISTS \ assert(av); assert(SvTYPE(av) == SVt_PVAV); assert(dir); assert(stem) -# endif +# endif /* !defined(PERL_IS_MINIPERL) */ # if !defined(SETUID_SCRIPTS_ARE_SECURE_NOW) STATIC void -S_validate_suid(pTHX_ PerlIO *rsfp); +S_validate_suid(pTHX_ PerlIO *rsfp) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_VALIDATE_SUID \ assert(rsfp) @@ -7881,7 +9348,9 @@ S_validate_suid(pTHX_ PerlIO *rsfp); #endif #if defined(PERL_IN_PP_C) STATIC size_t -S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping); +S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_DO_CHOMP \ assert(retval); assert(sv) @@ -7891,6 +9360,7 @@ S_do_delete_local(pTHX); STATIC SV * S_refto(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_REFTO \ assert(sv) @@ -7900,28 +9370,38 @@ S_refto(pTHX_ SV *sv) PERL_CALLCONV GV * Perl_softref2xv(pTHX_ SV * const sv, const char * const what, const svtype type) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SOFTREF2XV \ assert(sv); assert(what) +#endif /* defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C) */ +#if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_ANY) || \ + defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C) + #endif #if defined(PERL_IN_PP_C) || defined(PERL_IN_UTF8_C) PERL_CALLCONV UV Perl_to_upper_title_latin1_(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_or_s) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_TO_UPPER_TITLE_LATIN1_ \ assert(p); assert(lenp) -#endif +#endif /* defined(PERL_IN_PP_C) || defined(PERL_IN_UTF8_C) */ #if defined(PERL_IN_PP_CTL_C) STATIC PerlIO * S_check_type_and_open(pTHX_ SV *name) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_CHECK_TYPE_AND_OPEN \ assert(name) STATIC void -S_destroy_matcher(pTHX_ PMOP *matcher); +S_destroy_matcher(pTHX_ PMOP *matcher) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DESTROY_MATCHER \ assert(matcher) @@ -7944,12 +9424,17 @@ S_doeval_compile(pTHX_ U8 gimme, CV *outside, U32 seq, HV *hh); STATIC OP * S_dofindlabel(pTHX_ OP *o, const char *label, STRLEN len, U32 flags, OP **opstack, OP **oplimit) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_5) + Perl_attribute_nonnull_(pTHX_6) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOFINDLABEL \ assert(o); assert(label); assert(opstack); assert(oplimit) STATIC MAGIC * -S_doparseform(pTHX_ SV *sv); +S_doparseform(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DOPARSEFORM \ assert(sv) @@ -7965,6 +9450,7 @@ S_dopoptogivenfor(pTHX_ I32 startingblock) STATIC I32 S_dopoptolabel(pTHX_ const char *label, STRLEN len, U32 flags) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOPOPTOLABEL \ assert(label) @@ -7976,6 +9462,7 @@ S_dopoptoloop(pTHX_ I32 startingblock) STATIC I32 S_dopoptosub_at(pTHX_ const PERL_CONTEXT *cxstk, I32 startingblock) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOPOPTOSUB_AT \ assert(cxstk) @@ -7987,12 +9474,15 @@ S_dopoptowhen(pTHX_ I32 startingblock) STATIC PMOP * S_make_matcher(pTHX_ REGEXP *re) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_MAKE_MATCHER \ assert(re) STATIC bool S_matcher_matches_sv(pTHX_ PMOP *matcher, SV *sv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_MATCHER_MATCHES_SV \ assert(matcher); assert(sv) @@ -8004,28 +9494,34 @@ S_num_overflow(NV value, I32 fldsize, I32 frcsize) STATIC I32 S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_RUN_USER_FILTER \ assert(buf_sv) STATIC void -S_rxres_free(pTHX_ void **rsp); +S_rxres_free(pTHX_ void **rsp) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RXRES_FREE \ assert(rsp) STATIC void -S_rxres_restore(pTHX_ void **rsp, REGEXP *rx); +S_rxres_restore(pTHX_ void **rsp, REGEXP *rx) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_RXRES_RESTORE \ assert(rsp); assert(rx) STATIC void -S_save_lines(pTHX_ AV *array, SV *sv); +S_save_lines(pTHX_ AV *array, SV *sv) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SAVE_LINES \ assert(!array || SvTYPE(array) == SVt_PVAV); assert(sv) # if !defined(PERL_DISABLE_PMC) STATIC PerlIO * S_doopen_pm(pTHX_ SV *name) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOOPEN_PM \ assert(name) @@ -8034,6 +9530,7 @@ S_doopen_pm(pTHX_ SV *name) # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE bool S_path_is_searchable(const char *name) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_PATH_IS_SEARCHABLE \ assert(name) @@ -8049,18 +9546,22 @@ Perl_invoke_exception_hook(pTHX_ SV *ex, bool warn) #endif #if defined(PERL_IN_PP_HOT_C) STATIC void -S_do_oddball(pTHX_ SV **oddkey, SV **firstkey); +S_do_oddball(pTHX_ SV **oddkey, SV **firstkey) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_DO_ODDBALL \ assert(oddkey); assert(firstkey) # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE HV * -S_opmethod_stash(pTHX_ SV *meth); +S_opmethod_stash(pTHX_ SV *meth) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_OPMETHOD_STASH \ assert(meth) PERL_STATIC_FORCE_INLINE bool S_should_we_output_Debug_r(pTHX_ regexp *prog) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__always_inline__; # define PERL_ARGS_ASSERT_SHOULD_WE_OUTPUT_DEBUG_R \ @@ -8070,175 +9571,241 @@ S_should_we_output_Debug_r(pTHX_ regexp *prog) #endif /* defined(PERL_IN_PP_HOT_C) */ #if defined(PERL_IN_PP_PACK_C) STATIC int -S_div128(pTHX_ SV *pnum, bool *done); +S_div128(pTHX_ SV *pnum, bool *done) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_DIV128 \ assert(pnum); assert(done) STATIC char -S_first_symbol(const char *pat, const char *patend); +S_first_symbol(const char *pat, const char *patend) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2); # define PERL_ARGS_ASSERT_FIRST_SYMBOL \ assert(pat); assert(patend) STATIC const char * S_get_num(pTHX_ const char *patptr, SSize_t *lenptr) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_GET_NUM \ assert(patptr); assert(lenptr) STATIC const char * -S_group_end(pTHX_ const char *patptr, const char *patend, char ender); +S_group_end(pTHX_ const char *patptr, const char *patend, char ender) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_GROUP_END \ assert(patptr); assert(patend) STATIC SV * S_is_an_int(pTHX_ const char *s, STRLEN l) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_AN_INT \ assert(s) STATIC SSize_t -S_measure_struct(pTHX_ struct tempsym *symptr); +S_measure_struct(pTHX_ struct tempsym *symptr) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_MEASURE_STRUCT \ assert(symptr) STATIC SV * -S_mul128(pTHX_ SV *sv, U8 m); +S_mul128(pTHX_ SV *sv, U8 m) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_MUL128 \ assert(sv) STATIC char * S_my_bytes_to_utf8(const U8 *start, STRLEN len, char *dest, const bool needs_swap) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(3) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_MY_BYTES_TO_UTF8 \ assert(start); assert(dest) STATIC bool -S_need_utf8(const char *pat, const char *patend); +S_need_utf8(const char *pat, const char *patend) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2); # define PERL_ARGS_ASSERT_NEED_UTF8 \ assert(pat); assert(patend) STATIC bool -S_next_symbol(pTHX_ struct tempsym *symptr); +S_next_symbol(pTHX_ struct tempsym *symptr) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_NEXT_SYMBOL \ assert(symptr) STATIC SV ** -S_pack_rec(pTHX_ SV *cat, struct tempsym *symptr, SV **beglist, SV **endlist); +S_pack_rec(pTHX_ SV *cat, struct tempsym *symptr, SV **beglist, SV **endlist) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_PACK_REC \ assert(cat); assert(symptr); assert(beglist); assert(endlist) STATIC char * S_sv_exp_grow(pTHX_ SV *sv, STRLEN needed) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SV_EXP_GROW \ assert(sv) STATIC SSize_t -S_unpack_rec(pTHX_ struct tempsym *symptr, const char *s, const char *strbeg, const char *strend, const char **new_s); +S_unpack_rec(pTHX_ struct tempsym *symptr, const char *s, const char *strbeg, const char *strend, const char **new_s) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_UNPACK_REC \ assert(symptr); assert(s); assert(strbeg); assert(strend) #endif /* defined(PERL_IN_PP_PACK_C) */ #if defined(PERL_IN_PP_SORT_C) + STATIC I32 -S_sortcv(pTHX_ SV * const a, SV * const b); +S_sortcv(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SORTCV \ assert(a); assert(b) STATIC I32 -S_sortcv_stacked(pTHX_ SV * const a, SV * const b); +S_sortcv_stacked(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SORTCV_STACKED \ assert(a); assert(b) STATIC I32 -S_sortcv_xsub(pTHX_ SV * const a, SV * const b); +S_sortcv_xsub(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SORTCV_XSUB \ assert(a); assert(b) # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE I32 -S_amagic_cmp(pTHX_ SV * const str1, SV * const str2); +S_amagic_cmp(pTHX_ SV * const str1, SV * const str2) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_CMP \ assert(str1); assert(str2) PERL_STATIC_INLINE I32 -S_amagic_cmp_desc(pTHX_ SV * const str1, SV * const str2); +S_amagic_cmp_desc(pTHX_ SV * const str1, SV * const str2) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_CMP_DESC \ assert(str1); assert(str2) PERL_STATIC_INLINE I32 -S_amagic_i_ncmp(pTHX_ SV * const a, SV * const b); +S_amagic_i_ncmp(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_I_NCMP \ assert(a); assert(b) PERL_STATIC_INLINE I32 -S_amagic_i_ncmp_desc(pTHX_ SV * const a, SV * const b); +S_amagic_i_ncmp_desc(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_I_NCMP_DESC \ assert(a); assert(b) PERL_STATIC_INLINE I32 -S_amagic_ncmp(pTHX_ SV * const a, SV * const b); +S_amagic_ncmp(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_NCMP \ assert(a); assert(b) PERL_STATIC_INLINE I32 -S_amagic_ncmp_desc(pTHX_ SV * const a, SV * const b); +S_amagic_ncmp_desc(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_NCMP_DESC \ assert(a); assert(b) PERL_STATIC_INLINE I32 -S_cmp_desc(pTHX_ SV * const str1, SV * const str2); +S_cmp_desc(pTHX_ SV * const str1, SV * const str2) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CMP_DESC \ assert(str1); assert(str2) PERL_STATIC_FORCE_INLINE void S_sortsv_flags_impl(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp, U32 flags) + Perl_attribute_nonnull_(pTHX_3) __attribute__always_inline__; # define PERL_ARGS_ASSERT_SORTSV_FLAGS_IMPL \ assert(cmp) PERL_STATIC_INLINE I32 -S_sv_i_ncmp(pTHX_ SV * const a, SV * const b); +S_sv_i_ncmp(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SV_I_NCMP \ assert(a); assert(b) PERL_STATIC_INLINE I32 -S_sv_i_ncmp_desc(pTHX_ SV * const a, SV * const b); +S_sv_i_ncmp_desc(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SV_I_NCMP_DESC \ assert(a); assert(b) PERL_STATIC_INLINE I32 -S_sv_ncmp(pTHX_ SV * const a, SV * const b); +S_sv_ncmp(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SV_NCMP \ assert(a); assert(b) PERL_STATIC_INLINE I32 -S_sv_ncmp_desc(pTHX_ SV * const a, SV * const b); +S_sv_ncmp_desc(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SV_NCMP_DESC \ assert(a); assert(b) # if defined(USE_LOCALE_COLLATE) PERL_STATIC_INLINE I32 -S_amagic_cmp_locale(pTHX_ SV * const str1, SV * const str2); +S_amagic_cmp_locale(pTHX_ SV * const str1, SV * const str2) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \ assert(str1); assert(str2) PERL_STATIC_INLINE I32 -S_amagic_cmp_locale_desc(pTHX_ SV * const str1, SV * const str2); +S_amagic_cmp_locale_desc(pTHX_ SV * const str1, SV * const str2) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE_DESC \ assert(str1); assert(str2) PERL_STATIC_INLINE I32 -S_cmp_locale_desc(pTHX_ SV * const str1, SV * const str2); +S_cmp_locale_desc(pTHX_ SV * const str1, SV * const str2) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CMP_LOCALE_DESC \ assert(str1); assert(str2) # endif /* defined(USE_LOCALE_COLLATE) */ # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ +# if defined(USE_LOCALE_COLLATE) + +# endif #endif /* defined(PERL_IN_PP_SORT_C) */ #if defined(PERL_IN_PP_SYS_C) STATIC OP * -S_doform(pTHX_ CV *cv, GV *gv, OP *retop); +S_doform(pTHX_ CV *cv, GV *gv, OP *retop) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_DOFORM \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ assert(gv) @@ -8248,18 +9815,21 @@ S_space_join_names_mortal(pTHX_ char * const *array); # define PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL STATIC void -S_warn_not_dirhandle(pTHX_ GV *gv); +S_warn_not_dirhandle(pTHX_ GV *gv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_WARN_NOT_DIRHANDLE \ assert(gv) # if !defined(HAS_MKDIR) || !defined(HAS_RMDIR) STATIC int S_dooneliner(pTHX_ const char *cmd, const char *filename) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOONELINER \ assert(cmd); assert(filename) -# endif +# endif /* !defined(HAS_MKDIR) || !defined(HAS_RMDIR) */ #endif /* defined(PERL_IN_PP_SYS_C) */ #if defined(PERL_IN_REGCOMP_ANY) # define PERL_ARGS_ASSERT_ADD_ABOVE_LATIN1_FOLDS \ @@ -8304,51 +9874,88 @@ S_dooneliner(pTHX_ const char *cmd, const char *filename) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV void Perl_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV **invlist) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); PERL_CALLCONV regnode * Perl_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *source, U32 depth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); PERL_CALLCONV SV * Perl_get_ANYOFHbbm_contents(pTHX_ const regnode *n) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); PERL_CALLCONV SV * Perl_get_ANYOFM_contents(pTHX_ const regnode *n) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); PERL_CALLCONV U32 Perl_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, UV *min_subtract, bool *unfolded_multi_char, U32 flags, regnode *val, U32 depth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) __attribute__visibility__("hidden"); PERL_CALLCONV I32 Perl_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *first, regnode *last, regnode *tail, U32 word_count, U32 flags, U32 depth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5) __attribute__visibility__("hidden"); PERL_CALLCONV void Perl_populate_anyof_bitmap_from_invlist(pTHX_ regnode *node, SV **invlist_ptr) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); PERL_CALLCONV U32 Perl_reg_add_data(RExC_state_t * const pRExC_state, const char * const s, const U32 n) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); PERL_CALLCONV void Perl_scan_commit(pTHX_ const RExC_state_t *pRExC_state, struct scan_data_t *data, SSize_t *minlenp, int is_inf) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); PERL_CALLCONV void Perl_set_ANYOF_arg(pTHX_ RExC_state_t * const pRExC_state, regnode * const node, SV * const cp_list, SV * const runtime_defns, SV * const only_utf8_locale_list) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); PERL_CALLCONV void Perl_ssc_init(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); PERL_CALLCONV SSize_t Perl_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, SSize_t *minlenp, SSize_t *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U32 recursed_depth, regnode_ssc *and_withp, U32 flags, U32 depth, bool was_mutate_ok) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5) __attribute__visibility__("hidden"); # if defined(PERL_IN_REGCOMP_TRIE_C) && defined(DEBUGGING) STATIC void -S_dump_trie(pTHX_ const struct reg_trie_data_ *trie, HV *widecharmap, AV *revcharmap, U32 depth); +S_dump_trie(pTHX_ const struct reg_trie_data_ *trie, HV *widecharmap, AV *revcharmap, U32 depth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); STATIC void -S_dump_trie_interim_list(pTHX_ const struct reg_trie_data_ *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth); +S_dump_trie_interim_list(pTHX_ const struct reg_trie_data_ *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); STATIC void -S_dump_trie_interim_table(pTHX_ const struct reg_trie_data_ *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth); -# endif +S_dump_trie_interim_table(pTHX_ const struct reg_trie_data_ *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); +# endif /* defined(PERL_IN_REGCOMP_TRIE_C) && defined(DEBUGGING) */ # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # if defined(PERL_IN_REGCOMP_TRIE_C) && defined(DEBUGGING) # define PERL_ARGS_ASSERT_DUMP_TRIE \ @@ -8380,15 +9987,19 @@ S_dump_trie_interim_table(pTHX_ const struct reg_trie_data_ *trie, HV *widecharm # if defined(PERL_CORE) || defined(PERL_EXT) PERL_STATIC_INLINE SV * S_invlist_contents(pTHX_ SV * const invlist, const bool traditional_style) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; PERL_STATIC_INLINE UV S_invlist_highest_range_start(SV * const invlist) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE bool S_invlist_is_iterating(const SV * const invlist) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE UV S_invlist_lowest(SV * const invlist) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ @@ -8399,9 +10010,10 @@ S_invlist_lowest(SV * const invlist) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV SV * -Perl_invlist_clone(pTHX_ SV * const invlist, SV *newlist); +Perl_invlist_clone(pTHX_ SV * const invlist, SV *newlist) + Perl_attribute_nonnull_(pTHX_1); # endif -#endif +#endif /* defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_SV_C) */ #if defined(PERL_IN_REGCOMP_C) # define PERL_ARGS_ASSERT_ADD_MULTI_MATCH \ assert(!multi_char_matches || SvTYPE(multi_char_matches) == SVt_PVAV); \ @@ -8466,6 +10078,7 @@ Perl_invlist_clone(pTHX_ SV * const invlist, SV *newlist); PERL_STATIC_NO_RET void S_re_croak(pTHX_ bool utf8, const char *pat, ...) + Perl_attribute_nonnull_(pTHX_2) __attribute__noreturn__ __attribute__format__(__printf__,pTHX_2,pTHX_3); # define PERL_ARGS_ASSERT_RE_CROAK \ @@ -8543,94 +10156,174 @@ S_re_croak(pTHX_ bool utf8, const char *pat, ...) # endif /* defined(DEBUGGING) */ # if defined(PERL_CORE) || defined(PERL_EXT) STATIC AV * -S_add_multi_match(pTHX_ AV *multi_char_matches, SV *multi_string, const STRLEN cp_count); +S_add_multi_match(pTHX_ AV *multi_char_matches, SV *multi_string, const STRLEN cp_count) + Perl_attribute_nonnull_(pTHX_2); STATIC void -S_change_engine_size(pTHX_ RExC_state_t *pRExC_state, const ptrdiff_t size); +S_change_engine_size(pTHX_ RExC_state_t *pRExC_state, const ptrdiff_t size) + Perl_attribute_nonnull_(pTHX_1); STATIC REGEXP * S_compile_wildcard(pTHX_ const char *subpattern, const STRLEN len, const bool ignore_case) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; STATIC U8 -S_compute_EXACTish(RExC_state_t *pRExC_state); +S_compute_EXACTish(RExC_state_t *pRExC_state) + Perl_attribute_nonnull_(1); STATIC int S_edit_distance(const UV *src, const UV *tgt, const STRLEN x, const STRLEN y, const SSize_t maxDistance) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; STATIC I32 -S_execute_wildcard(pTHX_ REGEXP * const prog, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *screamer, U32 nosave); +S_execute_wildcard(pTHX_ REGEXP * const prog, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *screamer, U32 nosave) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_6); STATIC U32 -S_get_quantifier_value(pTHX_ RExC_state_t *pRExC_state, const char *start, const char *end); +S_get_quantifier_value(pTHX_ RExC_state_t *pRExC_state, const char *start, const char *end) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); STATIC bool -S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode_offset *nodep, UV *code_point_p, int *cp_count, I32 *flagp, const bool strict, const U32 depth); +S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode_offset *nodep, UV *code_point_p, int *cp_count, I32 *flagp, const bool strict, const U32 depth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_5); STATIC regnode_offset -S_handle_named_backref(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, char *backref_parse_start, char ch); +S_handle_named_backref(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, char *backref_parse_start, char ch) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); STATIC bool -S_handle_names_wildcard(pTHX_ const char *wname, const STRLEN wname_len, SV **prop_definition, AV **strings); +S_handle_names_wildcard(pTHX_ const char *wname, const STRLEN wname_len, SV **prop_definition, AV **strings) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4); STATIC int -S_handle_possible_posix(pTHX_ RExC_state_t *pRExC_state, const char * const s, char **updated_parse_ptr, AV **posix_warnings, const bool check_only); +S_handle_possible_posix(pTHX_ RExC_state_t *pRExC_state, const char * const s, char **updated_parse_ptr, AV **posix_warnings, const bool check_only) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); STATIC regnode_offset -S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV **return_invlist, I32 *flagp, U32 depth); +S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV **return_invlist, I32 *flagp, U32 depth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); STATIC SV * -S_handle_user_defined_property(pTHX_ const char *name, const STRLEN name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, SV *contents, bool *user_defined_ptr, SV *msg, const STRLEN level); +S_handle_user_defined_property(pTHX_ const char *name, const STRLEN name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, SV *contents, bool *user_defined_ptr, SV *msg, const STRLEN level) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_7) + Perl_attribute_nonnull_(pTHX_8) + Perl_attribute_nonnull_(pTHX_9); STATIC bool -S_is_ssc_worth_it(const RExC_state_t *pRExC_state, const regnode_ssc *ssc); +S_is_ssc_worth_it(const RExC_state_t *pRExC_state, const regnode_ssc *ssc) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2); STATIC void -S_nextchar(pTHX_ RExC_state_t *pRExC_state); +S_nextchar(pTHX_ RExC_state_t *pRExC_state) + Perl_attribute_nonnull_(pTHX_1); STATIC U8 -S_optimize_regclass(pTHX_ RExC_state_t *pRExC_state, SV *cp_list, SV *only_utf8_locale_list, SV *upper_latin1_only_utf8_matches, const U32 has_runtime_dependency, const U32 posixl, U8 *anyof_flags, bool *invert, regnode_offset *ret, I32 *flagp); -STATIC void -S_output_posix_warnings(pTHX_ RExC_state_t *pRExC_state, AV *posix_warnings); -STATIC void -S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state); +S_optimize_regclass(pTHX_ RExC_state_t *pRExC_state, SV *cp_list, SV *only_utf8_locale_list, SV *upper_latin1_only_utf8_matches, const U32 has_runtime_dependency, const U32 posixl, U8 *anyof_flags, bool *invert, regnode_offset *ret, I32 *flagp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_7) + Perl_attribute_nonnull_(pTHX_8) + Perl_attribute_nonnull_(pTHX_9) + Perl_attribute_nonnull_(pTHX_10); +STATIC void +S_output_posix_warnings(pTHX_ RExC_state_t *pRExC_state, AV *posix_warnings) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); +STATIC void +S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state) + Perl_attribute_nonnull_(pTHX_1); STATIC SV * -S_parse_uniprop_string(pTHX_ const char * const name, Size_t name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, AV **strings, bool *user_defined_ptr, SV *msg, const STRLEN level); +S_parse_uniprop_string(pTHX_ const char * const name, Size_t name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, AV **strings, bool *user_defined_ptr, SV *msg, const STRLEN level) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_8) + Perl_attribute_nonnull_(pTHX_9); STATIC regnode_offset -S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth); +S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); STATIC regnode_offset -S_reg1node(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg); +S_reg1node(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg) + Perl_attribute_nonnull_(pTHX_1); STATIC regnode_offset -S_reg2node(pTHX_ RExC_state_t *pRExC_state, const U8 op, const U32 arg1, const I32 arg2); +S_reg2node(pTHX_ RExC_state_t *pRExC_state, const U8 op, const U32 arg1, const I32 arg2) + Perl_attribute_nonnull_(pTHX_1); STATIC regnode_offset -S_reg_la_NOTHING(pTHX_ RExC_state_t *pRExC_state, U32 flags, const char *type); +S_reg_la_NOTHING(pTHX_ RExC_state_t *pRExC_state, U32 flags, const char *type) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); STATIC regnode_offset -S_reg_la_OPFAIL(pTHX_ RExC_state_t *pRExC_state, U32 flags, const char *type); +S_reg_la_OPFAIL(pTHX_ RExC_state_t *pRExC_state, U32 flags, const char *type) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); STATIC regnode_offset -S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op); +S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op) + Perl_attribute_nonnull_(pTHX_1); STATIC SV * -S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags); +S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags) + Perl_attribute_nonnull_(pTHX_1); STATIC regnode_offset -S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth); +S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); STATIC regnode_offset -S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth); +S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); STATIC regnode_offset -S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, const bool strict, bool optimizable, SV **ret_invlist); +S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, const bool strict, bool optimizable, SV **ret_invlist) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); STATIC unsigned int S_regex_set_precedence(const U8 my_operator) __attribute__warn_unused_result__; STATIC void -S_reginsert(pTHX_ RExC_state_t *pRExC_state, const U8 op, const regnode_offset operand, const U32 depth); +S_reginsert(pTHX_ RExC_state_t *pRExC_state, const U8 op, const regnode_offset operand, const U32 depth) + Perl_attribute_nonnull_(pTHX_1); STATIC regnode_offset -S_regnode_guts(pTHX_ RExC_state_t *pRExC_state, const STRLEN extra_len); +S_regnode_guts(pTHX_ RExC_state_t *pRExC_state, const STRLEN extra_len) + Perl_attribute_nonnull_(pTHX_1); STATIC regnode_offset -S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth); +S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); STATIC regnode_offset -S_regpnode(pTHX_ RExC_state_t *pRExC_state, U8 op, SV *arg); +S_regpnode(pTHX_ RExC_state_t *pRExC_state, U8 op, SV *arg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); STATIC bool S_regtail(pTHX_ RExC_state_t *pRExC_state, const regnode_offset p, const regnode_offset val, const U32 depth) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; STATIC void -S_set_regex_pv(pTHX_ RExC_state_t *pRExC_state, REGEXP *Rx); +S_set_regex_pv(pTHX_ RExC_state_t *pRExC_state, REGEXP *Rx) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); STATIC void -S_skip_to_be_ignored_text(pTHX_ RExC_state_t *pRExC_state, char **p, const bool force_to_xmod); +S_skip_to_be_ignored_text(pTHX_ RExC_state_t *pRExC_state, char **p, const bool force_to_xmod) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); STATIC void -S_ssc_finalize(pTHX_ RExC_state_t *pRExC_state, regnode_ssc *ssc); +S_ssc_finalize(pTHX_ RExC_state_t *pRExC_state, regnode_ssc *ssc) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # if defined(DEBUGGING) STATIC regnode_offset -S_regnode_guts_debug(pTHX_ RExC_state_t *pRExC_state, const U8 op, const STRLEN extra_len); +S_regnode_guts_debug(pTHX_ RExC_state_t *pRExC_state, const U8 op, const STRLEN extra_len) + Perl_attribute_nonnull_(pTHX_1); STATIC bool S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode_offset p, const regnode_offset val, U32 depth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; # if defined(ENABLE_REGEX_SETS_DEBUGGING) STATIC void -S_dump_regex_sets_structures(pTHX_ RExC_state_t *pRExC_state, AV *stack, const IV fence, AV *fence_stack); +S_dump_regex_sets_structures(pTHX_ RExC_state_t *pRExC_state, AV *stack, const IV fence, AV *fence_stack) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_4); # endif # endif /* defined(DEBUGGING) */ # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ @@ -8643,9 +10336,13 @@ S_dump_regex_sets_structures(pTHX_ RExC_state_t *pRExC_state, AV *stack, const I # if defined(PERL_CORE) || defined(PERL_EXT) PERL_STATIC_INLINE Size_t -S_find_first_differing_byte_pos(const U8 *s1, const U8 *s2, const Size_t max); +S_find_first_differing_byte_pos(const U8 *s1, const U8 *s2, const Size_t max) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2); PERL_STATIC_INLINE char * -S_reg_skipcomment(RExC_state_t *pRExC_state, char *p); +S_reg_skipcomment(RExC_state_t *pRExC_state, char *p) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2); # endif # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ #endif /* defined(PERL_IN_REGCOMP_C) */ @@ -8659,11 +10356,15 @@ S_reg_skipcomment(RExC_state_t *pRExC_state, char *p); # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV void Perl_populate_bitmap_from_invlist(pTHX_ SV *invlist, const UV offset, const U8 *bitmap, const Size_t len) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); PERL_CALLCONV void Perl_populate_invlist_from_bitmap(pTHX_ const U8 *bitmap, const Size_t bitmap_len, SV **invlist, const UV offset) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); -# endif +# endif /* defined(PERL_CORE) || defined(PERL_EXT) */ #endif /* defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGCOMP_INVLIST_C) */ #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || \ defined(PERL_IN_TOKE_C) @@ -8684,6 +10385,8 @@ Perl_populate_invlist_from_bitmap(pTHX_ const U8 *bitmap, const Size_t bitmap_le # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV bool Perl_regcurly(const char *s, const char *e, const char *result[5]) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; # endif #endif /* defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) */ @@ -8713,7 +10416,8 @@ Perl_regcurly(const char *s, const char *e, const char *result[5]) assert(invlist) STATIC void -S_initialize_invlist_guts(pTHX_ SV *invlist, const Size_t initial_size); +S_initialize_invlist_guts(pTHX_ SV *invlist, const Size_t initial_size) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_INITIALIZE_INVLIST_GUTS \ assert(invlist) @@ -8722,9 +10426,12 @@ S_initialize_invlist_guts(pTHX_ SV *invlist, const Size_t initial_size); # if defined(PERL_CORE) || defined(PERL_EXT) STATIC void -S__append_range_to_invlist(pTHX_ SV * const invlist, const UV start, const UV end); +S__append_range_to_invlist(pTHX_ SV * const invlist, const UV start, const UV end) + Perl_attribute_nonnull_(pTHX_1); STATIC void -S_invlist_replace_list_destroys_src(pTHX_ SV *dest, SV *src); +S_invlist_replace_list_destroys_src(pTHX_ SV *dest, SV *src) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # endif # if !defined(PERL_NO_INLINE_FUNCTIONS) # define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT \ @@ -8751,22 +10458,29 @@ S_invlist_replace_list_destroys_src(pTHX_ SV *dest, SV *src); # if defined(PERL_CORE) || defined(PERL_EXT) PERL_STATIC_INLINE UV * S__invlist_array_init(SV * const invlist, const bool will_have_0) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE IV * S_get_invlist_previous_index_addr(SV *invlist) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE void -S_invlist_clear(pTHX_ SV *invlist); +S_invlist_clear(pTHX_ SV *invlist) + Perl_attribute_nonnull_(pTHX_1); PERL_STATIC_INLINE UV S_invlist_max(const SV * const invlist) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE IV S_invlist_previous_index(SV * const invlist) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE void -S_invlist_set_previous_index(SV * const invlist, const IV index); +S_invlist_set_previous_index(SV * const invlist, const IV index) + Perl_attribute_nonnull_(1); PERL_STATIC_INLINE void -S_invlist_trim(SV *invlist); +S_invlist_trim(SV *invlist) + Perl_attribute_nonnull_(1); # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ #endif /* defined(PERL_IN_REGCOMP_INVLIST_C) && !defined(PERL_EXT_RE_BUILD) */ @@ -8815,36 +10529,59 @@ S_invlist_trim(SV *invlist); # if defined(PERL_CORE) || defined(PERL_EXT) STATIC SV * -S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, const regnode_charclass * const node); +S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, const regnode_charclass * const node) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); STATIC SV * S_make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC void -S_rck_elide_nothing(pTHX_ regnode *node); +S_rck_elide_nothing(pTHX_ regnode *node) + Perl_attribute_nonnull_(pTHX_1); STATIC void -S_ssc_add_range(pTHX_ regnode_ssc *ssc, UV const start, UV const end); +S_ssc_add_range(pTHX_ regnode_ssc *ssc, UV const start, UV const end) + Perl_attribute_nonnull_(pTHX_1); STATIC void -S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *and_with); +S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *and_with) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); STATIC void -S_ssc_anything(pTHX_ regnode_ssc *ssc); +S_ssc_anything(pTHX_ regnode_ssc *ssc) + Perl_attribute_nonnull_(pTHX_1); STATIC void -S_ssc_clear_locale(regnode_ssc *ssc); +S_ssc_clear_locale(regnode_ssc *ssc) + Perl_attribute_nonnull_(1); STATIC void -S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp); +S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp) + Perl_attribute_nonnull_(pTHX_1); STATIC void -S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV * const invlist, const bool invert_2nd); +S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV * const invlist, const bool invert_2nd) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); STATIC int S_ssc_is_anything(const regnode_ssc *ssc) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; STATIC int S_ssc_is_cp_posixl_init(const RExC_state_t *pRExC_state, const regnode_ssc *ssc) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; STATIC void -S_ssc_or(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *or_with); +S_ssc_or(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *or_with) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); STATIC void -S_ssc_union(pTHX_ regnode_ssc *ssc, SV * const invlist, const bool invert_2nd); +S_ssc_union(pTHX_ regnode_ssc *ssc, SV * const invlist, const bool invert_2nd) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); STATIC void -S_unwind_scan_frames(pTHX_ void *p); +S_unwind_scan_frames(pTHX_ void *p) + Perl_attribute_nonnull_(pTHX_1); # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ #endif /* defined(PERL_IN_REGCOMP_STUDY_C) */ #if defined(PERL_IN_REGEXEC_C) @@ -8950,95 +10687,169 @@ S_unwind_scan_frames(pTHX_ void *p); # if defined(PERL_CORE) || defined(PERL_EXT) STATIC LB_enum S_advance_one_LB(pTHX_ U8 **curpos, const U8 * const strend, const bool utf8_target) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC SB_enum S_advance_one_SB(pTHX_ U8 **curpos, const U8 * const strend, const bool utf8_target) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC WB_enum S_advance_one_WB_(pTHX_ U8 **curpos, const U8 * const strend, const bool utf8_target, const bool skip_Extend_Format) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC GCB_enum S_backup_one_GCB(pTHX_ const U8 * const strbeg, U8 **curpos, const bool utf8_target) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC LB_enum S_backup_one_LB_(pTHX_ const U8 * const strbeg, U8 **curpos, const bool utf8_target, bool skip_CM_ZWJ) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC SB_enum S_backup_one_SB(pTHX_ const U8 * const strbeg, U8 **curpos, const bool utf8_target) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC WB_enum S_backup_one_WB_but_over_Extend_FO(pTHX_ WB_enum *previous, const U8 * const strbeg, U8 **curpos, const bool utf8_target) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; STATIC char * S_find_byclass(pTHX_ regexp *prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; STATIC U8 * S_find_next_masked(U8 *s, const U8 *send, const U8 byte, const U8 mask) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; STATIC U8 * S_find_span_end(U8 *s, const U8 *send, const U8 span_byte) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; STATIC U8 * S_find_span_end_mask(U8 *s, const U8 *send, const U8 span_byte, const U8 mask) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; STATIC bool S_isFOO_lc(pTHX_ const U8 classnum, const U8 character) __attribute__warn_unused_result__; STATIC bool S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8 *character, const U8 *e) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; STATIC bool S_isGCB(pTHX_ const GCB_enum before, const GCB_enum after, const U8 * const strbeg, const U8 * const curpos, const bool utf8_target) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; STATIC bool S_isLB(pTHX_ LB_enum before, LB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5) __attribute__warn_unused_result__; STATIC bool S_isSB(pTHX_ SB_enum before, SB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5) __attribute__warn_unused_result__; STATIC bool S_isWB(pTHX_ WB_enum previous, WB_enum before, WB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5) + Perl_attribute_nonnull_(pTHX_6) __attribute__warn_unused_result__; STATIC I32 S_reg_check_named_buff_matched(const regexp *rex, const regnode *scan) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; STATIC void -S_regcp_restore(pTHX_ regexp *rex, I32 ix, U32 *maxopenparen_p comma_pDEPTH); +S_regcp_restore(pTHX_ regexp *rex, I32 ix, U32 *maxopenparen_p comma_pDEPTH) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); STATIC void -S_regcppop(pTHX_ regexp *rex, U32 *maxopenparen_p comma_pDEPTH); +S_regcppop(pTHX_ regexp *rex, U32 *maxopenparen_p comma_pDEPTH) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); STATIC CHECKPOINT -S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen comma_pDEPTH); +S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen comma_pDEPTH) + Perl_attribute_nonnull_(pTHX_1); STATIC U8 * S_reghop3(U8 *s, SSize_t off, const U8 *lim) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(3) __attribute__warn_unused_result__; STATIC U8 * S_reghopmaybe3(U8 *s, SSize_t off, const U8 * const lim) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(3) __attribute__warn_unused_result__; STATIC bool S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8 * const p, const U8 * const p_end, bool const utf8_target) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; STATIC SSize_t S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; STATIC I32 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, char *loceol, regmatch_info * const reginfo, I32 max comma_pDEPTH) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5) __attribute__warn_unused_result__; STATIC bool S_regtry(pTHX_ regmatch_info *reginfo, char **startposp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC bool -S_to_byte_substr(pTHX_ regexp *prog); +S_to_byte_substr(pTHX_ regexp *prog) + Perl_attribute_nonnull_(pTHX_1); STATIC void -S_to_utf8_substr(pTHX_ regexp *prog); +S_to_utf8_substr(pTHX_ regexp *prog) + Perl_attribute_nonnull_(pTHX_1); # if defined(DEBUGGING) STATIC void -S_debug_start_match(pTHX_ const REGEXP *prog, const bool do_utf8, const char *start, const char *end, const char *blurb); +S_debug_start_match(pTHX_ const REGEXP *prog, const bool do_utf8, const char *start, const char *end, const char *blurb) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5); STATIC void -S_dump_exec_pos(pTHX_ const char *locinput, const regnode *scan, const char *loc_regeol, const char *loc_bostr, const char *loc_reg_starttry, const bool do_utf8, const U32 depth); +S_dump_exec_pos(pTHX_ const char *locinput, const regnode *scan, const char *loc_regeol, const char *loc_bostr, const char *loc_reg_starttry, const bool do_utf8, const U32 depth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5); PERL_CALLCONV int Perl_re_exec_indentf(pTHX_ const char *fmt, U32 depth, ...) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); -# endif +# endif /* defined(DEBUGGING) */ # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # if !defined(PERL_NO_INLINE_FUNCTIONS) # define PERL_ARGS_ASSERT_CAPTURE_CLEAR \ @@ -9052,12 +10863,17 @@ Perl_re_exec_indentf(pTHX_ const char *fmt, U32 depth, ...) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_STATIC_INLINE void -S_capture_clear(pTHX_ regexp *rex, U16 from_ix, U16 to_ix, const char *str comma_pDEPTH); +S_capture_clear(pTHX_ regexp *rex, U16 from_ix, U16 to_ix, const char *str comma_pDEPTH) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_4); PERL_STATIC_INLINE I32 -S_foldEQ_latin1_s2_folded(pTHX_ const char *a, const char *b, I32 len); +S_foldEQ_latin1_s2_folded(pTHX_ const char *a, const char *b, I32 len) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); PERL_STATIC_INLINE void -S_unwind_paren(pTHX_ regexp *rex, U32 lp, U32 lcp comma_pDEPTH); -# endif +S_unwind_paren(pTHX_ regexp *rex, U32 lp, U32 lcp comma_pDEPTH) + Perl_attribute_nonnull_(pTHX_1); +# endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ #endif /* defined(PERL_IN_REGEXEC_C) */ #if defined(PERL_IN_REGEX_ENGINE) @@ -9087,25 +10903,38 @@ S_unwind_paren(pTHX_ regexp *rex, U32 lp, U32 lcp comma_pDEPTH); # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV void Perl_debug_peep(pTHX_ const char *str, const RExC_state_t *pRExC_state, regnode *scan, U32 depth, U32 flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); PERL_CALLCONV void Perl_debug_show_study_flags(pTHX_ U32 flags, const char *open_str, const char *close_str) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); PERL_CALLCONV void Perl_debug_studydata(pTHX_ const char *where, scan_data_t *data, U32 depth, int is_inf, SSize_t min, SSize_t stopmin, SSize_t delta) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); PERL_CALLCONV const regnode * Perl_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node, const regnode *last, const regnode *plast, SV *sv, I32 indent, U32 depth) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_6) __attribute__visibility__("hidden"); PERL_CALLCONV int Perl_re_indentf(pTHX_ const char *fmt, U32 depth, ...) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); PERL_CALLCONV int Perl_re_printf(pTHX_ const char *fmt, ...) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden") __attribute__format__(__printf__,pTHX_1,pTHX_2); PERL_CALLCONV void Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_info *reginfo, const RExC_state_t *pRExC_state) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # endif /* defined(DEBUGGING) */ @@ -9116,6 +10945,7 @@ Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_ # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV SV * Perl_get_re_gclass_aux_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV **output_invlist) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # endif # else /* if !defined(PERL_EXT_RE_BUILD) */ @@ -9125,6 +10955,7 @@ Perl_get_re_gclass_aux_data(pTHX_ const regexp *prog, const struct regnode *node # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV SV * Perl_get_regclass_aux_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV **output_invlist) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # endif # endif /* !defined(PERL_EXT_RE_BUILD) */ @@ -9152,66 +10983,83 @@ S_save_pushptri32ptr(pTHX_ void * const ptr1, const I32 i, void * const ptr2, co # define PERL_ARGS_ASSERT_SAVE_PUSHPTRI32PTR STATIC SV * -S_save_scalar_at(pTHX_ SV **sptr, const U32 flags); +S_save_scalar_at(pTHX_ SV **sptr, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SAVE_SCALAR_AT \ assert(sptr) #endif /* defined(PERL_IN_SCOPE_C) */ #if defined(PERL_IN_SV_C) STATIC char * -S_F0convert(NV nv, char * const endbuf, STRLEN * const len); +S_F0convert(NV nv, char * const endbuf, STRLEN * const len) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(3); # define PERL_ARGS_ASSERT_F0CONVERT \ assert(endbuf); assert(len) STATIC void -S_anonymise_cv_maybe(pTHX_ GV *gv, CV *cv); +S_anonymise_cv_maybe(pTHX_ GV *gv, CV *cv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_ANONYMISE_CV_MAYBE \ assert(gv); assert(cv); \ assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) STATIC void -S_assert_uft8_cache_coherent(pTHX_ const char * const func, STRLEN from_cache, STRLEN real, SV * const sv); +S_assert_uft8_cache_coherent(pTHX_ const char * const func, STRLEN from_cache, STRLEN real, SV * const sv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_ASSERT_UFT8_CACHE_COHERENT \ assert(func); assert(sv) STATIC void -S_croak_sv_setsv_flags(pTHX_ SV * const dsv, SV * const ssv); +S_croak_sv_setsv_flags(pTHX_ SV * const dsv, SV * const ssv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CROAK_SV_SETSV_FLAGS \ assert(dsv); assert(ssv) STATIC bool -S_curse(pTHX_ SV * const sv, const bool check_refcnt); +S_curse(pTHX_ SV * const sv, const bool check_refcnt) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CURSE \ assert(sv) STATIC STRLEN S_expect_number(pTHX_ const char ** const pattern) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_EXPECT_NUMBER \ assert(pattern) STATIC SSize_t -S_find_array_subscript(pTHX_ const AV * const av, const SV * const val); +S_find_array_subscript(pTHX_ const AV * const av, const SV * const val) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_FIND_ARRAY_SUBSCRIPT \ assert(val) STATIC SV * -S_find_hash_subscript(pTHX_ const HV * const hv, const SV * const val); +S_find_hash_subscript(pTHX_ const HV * const hv, const SV * const val) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_FIND_HASH_SUBSCRIPT \ assert(val) STATIC SV * -S_find_uninit_var(pTHX_ const OP * const obase, const SV * const uninit_sv, bool match, const char **desc_p); +S_find_uninit_var(pTHX_ const OP * const obase, const SV * const uninit_sv, bool match, const char **desc_p) + Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_FIND_UNINIT_VAR \ assert(desc_p) STATIC bool -S_glob_2number(pTHX_ GV * const gv); +S_glob_2number(pTHX_ GV * const gv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GLOB_2NUMBER \ assert(gv) STATIC void -S_glob_assign_glob(pTHX_ SV * const dsv, SV * const ssv, const int dtype); +S_glob_assign_glob(pTHX_ SV * const dsv, SV * const ssv, const int dtype) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB \ assert(dsv); assert(ssv) @@ -9220,75 +11068,102 @@ Perl_more_sv(pTHX); # define PERL_ARGS_ASSERT_MORE_SV STATIC void -S_not_a_number(pTHX_ SV * const sv); +S_not_a_number(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_NOT_A_NUMBER \ assert(sv) STATIC void -S_not_incrementable(pTHX_ SV * const sv); +S_not_incrementable(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_NOT_INCREMENTABLE \ assert(sv) STATIC PTR_TBL_ENT_t * S_ptr_table_find(PTR_TBL_t * const tbl, const void * const sv) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_PTR_TABLE_FIND \ assert(tbl) STATIC bool -S_sv_2iuv_common(pTHX_ SV * const sv); +S_sv_2iuv_common(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_2IUV_COMMON \ assert(sv) STATIC void -S_sv_add_arena(pTHX_ char * const ptr, const U32 size, const U32 flags); +S_sv_add_arena(pTHX_ char * const ptr, const U32 size, const U32 flags) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_ADD_ARENA \ assert(ptr) STATIC const char * -S_sv_display(pTHX_ SV * const sv, char *tmpbuf, STRLEN tmpbuf_size); +S_sv_display(pTHX_ SV * const sv, char *tmpbuf, STRLEN tmpbuf_size) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SV_DISPLAY \ assert(sv); assert(tmpbuf) STATIC STRLEN -S_sv_pos_b2u_midway(pTHX_ const U8 * const s, const U8 * const target, const U8 *end, STRLEN endu); +S_sv_pos_b2u_midway(pTHX_ const U8 * const s, const U8 * const target, const U8 *end, STRLEN endu) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_SV_POS_B2U_MIDWAY \ assert(s); assert(target); assert(end) STATIC STRLEN -S_sv_pos_u2b_cached(pTHX_ SV * const sv, MAGIC ** const mgp, const U8 * const start, const U8 * const send, STRLEN uoffset, STRLEN uoffset0, STRLEN boffset0); +S_sv_pos_u2b_cached(pTHX_ SV * const sv, MAGIC ** const mgp, const U8 * const start, const U8 * const send, STRLEN uoffset, STRLEN uoffset0, STRLEN boffset0) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_SV_POS_U2B_CACHED \ assert(sv); assert(mgp); assert(start); assert(send) STATIC STRLEN -S_sv_pos_u2b_forwards(const U8 * const start, const U8 * const send, STRLEN * const uoffset, bool * const at_end, bool *canonical_position); +S_sv_pos_u2b_forwards(const U8 * const start, const U8 * const send, STRLEN * const uoffset, bool * const at_end, bool *canonical_position) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(3) + Perl_attribute_nonnull_(4) + Perl_attribute_nonnull_(5); # define PERL_ARGS_ASSERT_SV_POS_U2B_FORWARDS \ assert(start); assert(send); assert(uoffset); assert(at_end); \ assert(canonical_position) STATIC STRLEN -S_sv_pos_u2b_midway(const U8 * const start, const U8 *send, STRLEN uoffset, const STRLEN uend); +S_sv_pos_u2b_midway(const U8 * const start, const U8 *send, STRLEN uoffset, const STRLEN uend) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2); # define PERL_ARGS_ASSERT_SV_POS_U2B_MIDWAY \ assert(start); assert(send) STATIC void -S_utf8_mg_len_cache_update(pTHX_ SV * const sv, MAGIC ** const mgp, const STRLEN ulen); +S_utf8_mg_len_cache_update(pTHX_ SV * const sv, MAGIC ** const mgp, const STRLEN ulen) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_UTF8_MG_LEN_CACHE_UPDATE \ assert(sv); assert(mgp) STATIC void -S_utf8_mg_pos_cache_update(pTHX_ SV * const sv, MAGIC ** const mgp, const STRLEN byte, const STRLEN utf8, const STRLEN blen); +S_utf8_mg_pos_cache_update(pTHX_ SV * const sv, MAGIC ** const mgp, const STRLEN byte, const STRLEN utf8, const STRLEN blen) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_UTF8_MG_POS_CACHE_UPDATE \ assert(sv); assert(mgp) STATIC SSize_t -S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask); +S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_VISIT \ assert(f) # if defined(DEBUGGING) STATIC void -S_del_sv(pTHX_ SV *p); +S_del_sv(pTHX_ SV *p) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DEL_SV \ assert(p) @@ -9306,13 +11181,15 @@ Perl_sv_sweep_arenas(pTHX) # if !defined(NV_PRESERVES_UV) # if defined(DEBUGGING) STATIC int -S_sv_2iuv_non_preserve(pTHX_ SV * const sv, I32 numtype); +S_sv_2iuv_non_preserve(pTHX_ SV * const sv, I32 numtype) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ assert(sv) # else STATIC int -S_sv_2iuv_non_preserve(pTHX_ SV * const sv); +S_sv_2iuv_non_preserve(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ assert(sv) @@ -9320,14 +11197,16 @@ S_sv_2iuv_non_preserve(pTHX_ SV * const sv); # endif /* !defined(NV_PRESERVES_UV) */ # if defined(PERL_DEBUG_READONLY_COW) STATIC void -S_sv_buf_to_rw(pTHX_ SV *sv); +S_sv_buf_to_rw(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_BUF_TO_RW \ assert(sv) # endif # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE void -S_sv_unglob(pTHX_ SV * const sv, U32 flags); +S_sv_unglob(pTHX_ SV * const sv, U32 flags) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_UNGLOB \ assert(sv) @@ -9335,22 +11214,31 @@ S_sv_unglob(pTHX_ SV * const sv, U32 flags); # if defined(USE_ITHREADS) STATIC SV * S_sv_dup_common(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SV_DUP_COMMON \ assert(ssv); assert(param) STATIC void -S_sv_dup_hvaux(pTHX_ const SV * const ssv, SV *dsv, CLONE_PARAMS * const param); +S_sv_dup_hvaux(pTHX_ const SV * const ssv, SV *dsv, CLONE_PARAMS * const param) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_SV_DUP_HVAUX \ assert(ssv); assert(dsv); assert(param) STATIC SV ** -S_sv_dup_inc_multiple(pTHX_ SV * const *source, SV **dest, SSize_t items, CLONE_PARAMS * const param); +S_sv_dup_inc_multiple(pTHX_ SV * const *source, SV **dest, SSize_t items, CLONE_PARAMS * const param) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_SV_DUP_INC_MULTIPLE \ assert(source); assert(dest); assert(param) STATIC void -S_unreferenced_to_tmp_stack(pTHX_ AV * const unreferenced); +S_unreferenced_to_tmp_stack(pTHX_ AV * const unreferenced) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_UNREFERENCED_TO_TMP_STACK \ assert(unreferenced); assert(SvTYPE(unreferenced) == SVt_PVAV) @@ -9366,24 +11254,30 @@ S_check_uni(pTHX); # define PERL_ARGS_ASSERT_CHECK_UNI STATIC void -S_checkcomma(pTHX_ const char *s, const char *name, const char *what); +S_checkcomma(pTHX_ const char *s, const char *name, const char *what) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_CHECKCOMMA \ assert(s); assert(name); assert(what) STATIC char * S_filter_gets(pTHX_ SV *sv, STRLEN append) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_FILTER_GETS \ assert(sv) STATIC HV * S_find_in_my_stash(pTHX_ const char *pkgname, STRLEN len) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_FIND_IN_MY_STASH \ assert(pkgname) STATIC void -S_force_ident(pTHX_ const char *s, int kind); +S_force_ident(pTHX_ const char *s, int kind) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FORCE_IDENT \ assert(s) @@ -9396,43 +11290,54 @@ S_force_next(pTHX_ I32 type); # define PERL_ARGS_ASSERT_FORCE_NEXT STATIC char * -S_force_strict_version(pTHX_ char *s); +S_force_strict_version(pTHX_ char *s) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FORCE_STRICT_VERSION \ assert(s) STATIC char * -S_force_version(pTHX_ char *s, int guessing); +S_force_version(pTHX_ char *s, int guessing) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FORCE_VERSION \ assert(s) STATIC char * -S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack); +S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FORCE_WORD \ assert(start) STATIC SV * S_get_and_check_backslash_N_name_wrapper(pTHX_ const char *s, const char * const e) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME_WRAPPER \ assert(s); assert(e) STATIC void -S_incline(pTHX_ const char *s, const char *end); +S_incline(pTHX_ const char *s, const char *end) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_INCLINE \ assert(s); assert(end) STATIC int -S_intuit_method(pTHX_ char *start, SV *ioname, CV *cv); +S_intuit_method(pTHX_ char *start, SV *ioname, CV *cv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_INTUIT_METHOD \ assert(start) STATIC int -S_intuit_more(pTHX_ char *s, char *e); +S_intuit_more(pTHX_ char *s, char *e) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_INTUIT_MORE \ assert(s); assert(e) STATIC I32 -S_lop(pTHX_ enum yytokentype t, I32 f, U8 x, char *s); +S_lop(pTHX_ enum yytokentype t, I32 f, U8 x, char *s) + Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_LOP \ assert(s) @@ -9442,12 +11347,17 @@ S_missingterm(pTHX_ char *s, STRLEN len) # 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); +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) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_5); # define PERL_ARGS_ASSERT_NEW_CONSTANT \ assert(key); assert(sv) STATIC void -S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_package, bool is_utf8, bool check_dollar); +S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_package, bool is_utf8, bool check_dollar) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_PARSE_IDENT \ assert(s); assert(d); assert(e) @@ -9457,47 +11367,56 @@ S_pending_ident(pTHX); STATIC char * S_scan_const(pTHX_ char *start) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_CONST \ assert(start) STATIC char * S_scan_formline(pTHX_ char *s) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_FORMLINE \ assert(s) STATIC char * S_scan_heredoc(pTHX_ char *s) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_HEREDOC \ assert(s) STATIC char * -S_scan_ident(pTHX_ char *s, char *dest, STRLEN destlen, I32 ck_uni); +S_scan_ident(pTHX_ char *s, char *dest, STRLEN destlen, I32 ck_uni) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SCAN_IDENT \ assert(s); assert(dest) STATIC char * S_scan_inputsymbol(pTHX_ char *start) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_INPUTSYMBOL \ assert(start) STATIC char * S_scan_pat(pTHX_ char *start, I32 type) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_PAT \ assert(start) STATIC char * S_scan_subst(pTHX_ char *start) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_SUBST \ assert(start) STATIC char * S_scan_trans(pTHX_ char *start) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_TRANS \ assert(start) @@ -9519,18 +11438,21 @@ S_sublex_start(pTHX) STATIC char * S_swallow_bom(pTHX_ U8 *s) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SWALLOW_BOM \ assert(s) STATIC char * S_tokenize_use(pTHX_ int is_use, char *s) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_TOKENIZE_USE \ assert(s) STATIC SV * -S_tokeq(pTHX_ SV *sv); +S_tokeq(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_TOKEQ \ assert(sv) @@ -9539,41 +11461,49 @@ S_update_debugger_info(pTHX_ SV *orig_sv, const char * const buf, STRLEN len); # define PERL_ARGS_ASSERT_UPDATE_DEBUGGER_INFO STATIC void -S_warn_expect_operator(pTHX_ const char * const what, char *s, I32 pop_oldbufptr); +S_warn_expect_operator(pTHX_ const char * const what, char *s, I32 pop_oldbufptr) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_WARN_EXPECT_OPERATOR \ assert(what) STATIC void -S_yyerror_non_ascii_message(pTHX_ const U8 * const s); +S_yyerror_non_ascii_message(pTHX_ const U8 * const s) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_YYERROR_NON_ASCII_MESSAGE \ assert(s) STATIC int -S_yywarn(pTHX_ const char * const s, U32 flags); +S_yywarn(pTHX_ const char * const s, U32 flags) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_YYWARN \ assert(s) # if defined(DEBUGGING) STATIC void S_printbuf(pTHX_ const char * const fmt, const char * const s) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_1,0); # define PERL_ARGS_ASSERT_PRINTBUF \ assert(fmt); assert(s) STATIC int -S_tokereport(pTHX_ I32 rv, const YYSTYPE *lvalp); +S_tokereport(pTHX_ I32 rv, const YYSTYPE *lvalp) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_TOKEREPORT \ assert(lvalp) # endif /* defined(DEBUGGING) */ # if !defined(PERL_NO_UTF16_FILTER) STATIC U8 * -S_add_utf16_textfilter(pTHX_ U8 * const s, bool reversed); +S_add_utf16_textfilter(pTHX_ U8 * const s, bool reversed) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_ADD_UTF16_TEXTFILTER \ assert(s) STATIC I32 -S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen); +S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_UTF16_TEXTFILTER \ assert(sv) @@ -9581,12 +11511,14 @@ S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen); #endif /* defined(PERL_IN_TOKE_C) */ #if defined(PERL_IN_UNIVERSAL_C) STATIC bool -S_isa_lookup(pTHX_ HV *stash, SV *namesv, const char *name, STRLEN len, U32 flags); +S_isa_lookup(pTHX_ HV *stash, SV *namesv, const char *name, STRLEN len, U32 flags) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_ISA_LOOKUP \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV); assert(namesv || name) STATIC bool -S_sv_derived_from_svpvn(pTHX_ SV *sv, SV *namesv, const char *name, const STRLEN len, U32 flags); +S_sv_derived_from_svpvn(pTHX_ SV *sv, SV *namesv, const char *name, const STRLEN len, U32 flags) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_DERIVED_FROM_SVPVN \ assert(sv); assert(namesv || name) @@ -9594,18 +11526,25 @@ S_sv_derived_from_svpvn(pTHX_ SV *sv, SV *namesv, const char *name, const STRLEN #if defined(PERL_IN_UTF8_C) STATIC UV S_check_locale_boundary_crossing(pTHX_ const U8 * const p, const UV result, U8 * const ustrp, STRLEN *lenp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \ assert(p); assert(ustrp); assert(lenp) STATIC HV * S_new_msg_hv(pTHX_ const char * const message, U32 categories, U32 flag) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NEW_MSG_HV \ assert(message) STATIC UV -S_to_case_cp_list(pTHX_ const UV original, const U32 ** const remaining_list, Size_t *remaining_count, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal); +S_to_case_cp_list(pTHX_ const UV original, const U32 ** const remaining_list, Size_t *remaining_count, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5) + Perl_attribute_nonnull_(pTHX_8); # define PERL_ARGS_ASSERT_TO_CASE_CP_LIST \ assert(invlist); assert(invmap); assert(normal) @@ -9615,54 +11554,79 @@ S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp, const char dummy) # define PERL_ARGS_ASSERT_TO_LOWER_LATIN1 STATIC UV -S_to_utf8_case_(pTHX_ const UV original, const U8 *p, U8 *ustrp, STRLEN *lenp, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal); +S_to_utf8_case_(pTHX_ const UV original, const U8 *p, U8 *ustrp, STRLEN *lenp, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) + Perl_attribute_nonnull_(pTHX_5) + Perl_attribute_nonnull_(pTHX_6) + Perl_attribute_nonnull_(pTHX_9); # define PERL_ARGS_ASSERT_TO_UTF8_CASE_ \ assert(ustrp); assert(lenp); assert(invlist); assert(invmap); \ assert(normal) STATIC UV -S_turkic_fc(pTHX_ const U8 * const p, const U8 * const e, U8 *ustrp, STRLEN *lenp); +S_turkic_fc(pTHX_ const U8 * const p, const U8 * const e, U8 *ustrp, STRLEN *lenp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_TURKIC_FC \ assert(p); assert(e); assert(ustrp); assert(lenp) STATIC UV -S_turkic_lc(pTHX_ const U8 * const p0, const U8 * const e, U8 *ustrp, STRLEN *lenp); +S_turkic_lc(pTHX_ const U8 * const p0, const U8 * const e, U8 *ustrp, STRLEN *lenp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_TURKIC_LC \ assert(p0); assert(e); assert(ustrp); assert(lenp) STATIC UV -S_turkic_uc(pTHX_ const U8 * const p, const U8 * const e, U8 *ustrp, STRLEN *lenp); +S_turkic_uc(pTHX_ const U8 * const p, const U8 * const e, U8 *ustrp, STRLEN *lenp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_TURKIC_UC \ assert(p); assert(e); assert(ustrp); assert(lenp) STATIC char * S_unexpected_non_continuation_text(pTHX_ const U8 * const s, STRLEN print_len, const STRLEN non_cont_byte_pos, const STRLEN expect_len) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_UNEXPECTED_NON_CONTINUATION_TEXT \ assert(s) # if 0 STATIC void -S_warn_on_first_deprecated_use(pTHX_ U32 category, const char * const name, const char * const alternative, const bool use_locale, const char * const file, const unsigned line); +S_warn_on_first_deprecated_use(pTHX_ U32 category, const char * const name, const char * const alternative, const bool use_locale, const char * const file, const unsigned line) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_5); # define PERL_ARGS_ASSERT_WARN_ON_FIRST_DEPRECATED_USE \ assert(name); assert(alternative); assert(file) -# endif +# endif /* 0 */ # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE int S_does_utf8_overflow(const U8 * const s, const U8 *e) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOES_UTF8_OVERFLOW \ assert(s); assert(e) PERL_STATIC_INLINE int S_isFF_overlong(const U8 * const s, const STRLEN len) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_ISFF_OVERLONG \ assert(s) PERL_STATIC_INLINE int S_is_utf8_overlong(const U8 * const s, const STRLEN len) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_UTF8_OVERLONG \ assert(s) @@ -9679,22 +11643,27 @@ S_mess_alloc(pTHX); # define PERL_ARGS_ASSERT_MESS_ALLOC STATIC SV * -S_with_queued_errors(pTHX_ SV *ex); +S_with_queued_errors(pTHX_ SV *ex) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS \ assert(ex) STATIC void -S_xs_version_bootcheck(pTHX_ SSize_t items, SSize_t ax, const char *xs_p, STRLEN xs_len); +S_xs_version_bootcheck(pTHX_ SSize_t items, SSize_t ax, const char *xs_p, STRLEN xs_len) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_XS_VERSION_BOOTCHECK \ assert(xs_p) # if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL) STATIC void -S_mem_log_common(enum mem_log_type mlt, const UV n, const UV typesize, const char *type_name, const SV *sv, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); +S_mem_log_common(enum mem_log_type mlt, const UV n, const UV typesize, const char *type_name, const SV *sv, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname) + Perl_attribute_nonnull_(4) + Perl_attribute_nonnull_(8) + Perl_attribute_nonnull_(10); # define PERL_ARGS_ASSERT_MEM_LOG_COMMON \ assert(type_name); assert(filename); assert(funcname) -# endif +# endif /* defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL) */ # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE U32 S_ptr_hash(PTRV u); @@ -9710,27 +11679,41 @@ S_pidgone(pTHX_ Pid_t pid, int status); #endif /* defined(PERL_IN_UTIL_C) */ #if defined(PERL_MEM_LOG) PERL_CALLCONV Malloc_t -Perl_mem_log_alloc(const UV nconst, UV typesize, const char *type_name, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); +Perl_mem_log_alloc(const UV nconst, UV typesize, const char *type_name, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname) + Perl_attribute_nonnull_(3) + Perl_attribute_nonnull_(5) + Perl_attribute_nonnull_(7); # define PERL_ARGS_ASSERT_MEM_LOG_ALLOC \ assert(type_name); assert(filename); assert(funcname) PERL_CALLCONV void -Perl_mem_log_del_sv(const SV *sv, const char *filename, int linenumber, const char *funcname); +Perl_mem_log_del_sv(const SV *sv, const char *filename, int linenumber, const char *funcname) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(4); # define PERL_ARGS_ASSERT_MEM_LOG_DEL_SV \ assert(sv); assert(filename); assert(funcname) PERL_CALLCONV Malloc_t -Perl_mem_log_free(Malloc_t oldalloc, const char *filename, const int linenumber, const char *funcname); +Perl_mem_log_free(Malloc_t oldalloc, const char *filename, const int linenumber, const char *funcname) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(4); # define PERL_ARGS_ASSERT_MEM_LOG_FREE \ assert(filename); assert(funcname) PERL_CALLCONV void -Perl_mem_log_new_sv(const SV *sv, const char *filename, int linenumber, const char *funcname); +Perl_mem_log_new_sv(const SV *sv, const char *filename, int linenumber, const char *funcname) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(4); # define PERL_ARGS_ASSERT_MEM_LOG_NEW_SV \ assert(sv); assert(filename); assert(funcname) PERL_CALLCONV Malloc_t -Perl_mem_log_realloc(const UV n, const UV typesize, const char *type_name, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); +Perl_mem_log_realloc(const UV n, const UV typesize, const char *type_name, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname) + Perl_attribute_nonnull_(3) + Perl_attribute_nonnull_(6) + Perl_attribute_nonnull_(8); # define PERL_ARGS_ASSERT_MEM_LOG_REALLOC \ assert(type_name); assert(filename); assert(funcname) @@ -9738,17 +11721,20 @@ Perl_mem_log_realloc(const UV n, const UV typesize, const char *type_name, Mallo #if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE SSize_t Perl_AvFILL_(pTHX_ AV *av) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_AVFILL_ \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_STATIC_INLINE I32 * -Perl_CvDEPTH(const CV * const sv); +Perl_CvDEPTH(const CV * const sv) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_CVDEPTH \ assert(sv) PERL_STATIC_INLINE GV * -Perl_CvGV(pTHX_ CV *sv); +Perl_CvGV(pTHX_ CV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CVGV \ assert(sv); assert(SvTYPE(sv) == SVt_PVCV || SvTYPE(sv) == SVt_PVFM) @@ -9757,53 +11743,64 @@ Perl_POPMARK(pTHX); # define PERL_ARGS_ASSERT_POPMARK PERL_STATIC_INLINE struct regexp * -Perl_ReANY(const REGEXP * const re); +Perl_ReANY(const REGEXP * const re) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_REANY \ assert(re) PERL_STATIC_INLINE void -Perl_SvAMAGIC_off(SV *sv); +Perl_SvAMAGIC_off(SV *sv) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_SVAMAGIC_OFF \ assert(sv) PERL_STATIC_INLINE void -Perl_SvAMAGIC_on(SV *sv); +Perl_SvAMAGIC_on(SV *sv) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_SVAMAGIC_ON \ assert(sv) PERL_STATIC_INLINE void -Perl_SvGETMAGIC(pTHX_ SV *sv); +Perl_SvGETMAGIC(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVGETMAGIC \ assert(sv) PERL_STATIC_INLINE IV -Perl_SvIV(pTHX_ SV *sv); +Perl_SvIV(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVIV \ assert(sv) PERL_STATIC_INLINE IV -Perl_SvIV_nomg(pTHX_ SV *sv); +Perl_SvIV_nomg(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVIV_NOMG \ assert(sv) PERL_STATIC_INLINE NV -Perl_SvNV(pTHX_ SV *sv); +Perl_SvNV(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVNV \ assert(sv) PERL_STATIC_INLINE NV -Perl_SvNV_nomg(pTHX_ SV *sv); +Perl_SvNV_nomg(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVNV_NOMG \ assert(sv) PERL_STATIC_FORCE_INLINE bool Perl_SvPVXtrue(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__always_inline__; # define PERL_ARGS_ASSERT_SVPVXTRUE \ assert(sv) PERL_STATIC_FORCE_INLINE char * Perl_SvPV_helper(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags, const PL_SvPVtype type, Perl_SvPV_helper_non_trivial_t non_trivial, const bool or_null, const U32 return_flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_5) __attribute__always_inline__; # define PERL_ARGS_ASSERT_SVPV_HELPER \ assert(sv); assert(non_trivial) @@ -9813,7 +11810,8 @@ Perl_SvREFCNT_dec(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_SVREFCNT_DEC PERL_STATIC_INLINE void -Perl_SvREFCNT_dec_NN(pTHX_ SV *sv); +Perl_SvREFCNT_dec_NN(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVREFCNT_DEC_NN \ assert(sv) @@ -9826,7 +11824,8 @@ Perl_SvREFCNT_inc(SV *sv); # define PERL_ARGS_ASSERT_SVREFCNT_INC PERL_STATIC_INLINE SV * -Perl_SvREFCNT_inc_NN(SV *sv); +Perl_SvREFCNT_inc_NN(SV *sv) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_SVREFCNT_INC_NN \ assert(sv) @@ -9839,12 +11838,14 @@ Perl_SvTRUE(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_SVTRUE PERL_STATIC_INLINE bool -Perl_SvTRUE_NN(pTHX_ SV *sv); +Perl_SvTRUE_NN(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVTRUE_NN \ assert(sv) PERL_STATIC_INLINE bool -Perl_SvTRUE_common(pTHX_ SV *sv, const bool sv_2bool_is_fallback); +Perl_SvTRUE_common(pTHX_ SV *sv, const bool sv_2bool_is_fallback) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVTRUE_COMMON \ assert(sv) @@ -9853,12 +11854,14 @@ Perl_SvTRUE_nomg(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_SVTRUE_NOMG PERL_STATIC_INLINE UV -Perl_SvUV(pTHX_ SV *sv); +Perl_SvUV(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVUV \ assert(sv) PERL_STATIC_INLINE UV -Perl_SvUV_nomg(pTHX_ SV *sv); +Perl_SvUV_nomg(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVUV_NOMG \ assert(sv) @@ -9871,12 +11874,14 @@ Perl_TOPMARK(pTHX); PERL_STATIC_INLINE Size_t Perl_av_count(pTHX_ AV *av) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_AV_COUNT \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_STATIC_INLINE SV ** Perl_av_fetch_simple(pTHX_ AV *av, SSize_t key, I32 lval) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_AV_FETCH_SIMPLE \ assert(av); assert(SvTYPE(av) == SVt_PVAV) @@ -9888,47 +11893,62 @@ Perl_av_new_alloc(pTHX_ SSize_t size, bool zeroflag) assert(size > 0) PERL_STATIC_INLINE void -Perl_av_push_simple(pTHX_ AV *av, SV *val); +Perl_av_push_simple(pTHX_ AV *av, SV *val) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AV_PUSH_SIMPLE \ assert(av); assert(SvTYPE(av) == SVt_PVAV); assert(val) PERL_STATIC_INLINE void -Perl_av_remove_offset(pTHX_ AV *av); +Perl_av_remove_offset(pTHX_ AV *av) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_AV_REMOVE_OFFSET \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_STATIC_INLINE SV ** -Perl_av_store_simple(pTHX_ AV *av, SSize_t key, SV *val); +Perl_av_store_simple(pTHX_ AV *av, SSize_t key, SV *val) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_AV_STORE_SIMPLE \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_STATIC_INLINE U8 * -Perl_bytes_to_utf8(pTHX_ const U8 *s, STRLEN *lenp); +Perl_bytes_to_utf8(pTHX_ const U8 *s, STRLEN *lenp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_BYTES_TO_UTF8 \ assert(s); assert(lenp) PERL_STATIC_INLINE U8 * -Perl_bytes_to_utf8_temp_pv(pTHX_ const U8 *s, STRLEN *lenp); +Perl_bytes_to_utf8_temp_pv(pTHX_ const U8 *s, STRLEN *lenp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_BYTES_TO_UTF8_TEMP_PV \ assert(s); assert(lenp) PERL_STATIC_INLINE void -Perl_clear_defarray_simple(pTHX_ AV *av); +Perl_clear_defarray_simple(pTHX_ AV *av) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLEAR_DEFARRAY_SIMPLE \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_STATIC_INLINE I32 -Perl_foldEQ(pTHX_ const char *a, const char *b, I32 len); +Perl_foldEQ(pTHX_ const char *a, const char *b, I32 len) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_FOLDEQ \ assert(a); assert(b) PERL_STATIC_INLINE I32 -Perl_foldEQ_latin1(pTHX_ const char *a, const char *b, I32 len); +Perl_foldEQ_latin1(pTHX_ const char *a, const char *b, I32 len) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_FOLDEQ_LATIN1 \ assert(a); assert(b) PERL_STATIC_INLINE I32 -Perl_foldEQ_locale(pTHX_ const char *a, const char *b, I32 len); +Perl_foldEQ_locale(pTHX_ const char *a, const char *b, I32 len) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_FOLDEQ_LOCALE \ assert(a); assert(b) @@ -9939,73 +11959,93 @@ Perl_get_vtbl(pTHX_ int vtbl_id) PERL_STATIC_INLINE Size_t Perl_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_ISC9_STRICT_UTF8_CHAR \ assert(s0); assert(e) PERL_STATIC_INLINE Size_t Perl_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_ISSTRICT_UTF8_CHAR \ assert(s0); assert(e) PERL_STATIC_INLINE Size_t Perl_isUTF8_CHAR(const U8 * const s0, const U8 * const e) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_ISUTF8_CHAR \ assert(s0); assert(e) PERL_STATIC_INLINE Size_t Perl_isUTF8_CHAR_flags(const U8 * const s0, const U8 * const e, const U32 flags) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_ISUTF8_CHAR_FLAGS \ assert(s0); assert(e) PERL_STATIC_INLINE bool -Perl_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) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING_LOCLEN \ assert(s) PERL_STATIC_INLINE bool Perl_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3) + Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_SAFE_SYSCALL \ assert(pv); assert(what); assert(op_name) PERL_STATIC_INLINE bool -Perl_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) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING_LOCLEN \ assert(s) 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); +Perl_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_LOCLEN_FLAGS \ assert(s) PERL_STATIC_INLINE bool Perl_is_utf8_invariant_string_loc(const U8 * const s, STRLEN len, const U8 **ep) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_UTF8_INVARIANT_STRING_LOC \ assert(s) PERL_STATIC_INLINE bool Perl_is_utf8_string_flags(const U8 *s, STRLEN len, const U32 flags) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_UTF8_STRING_FLAGS \ assert(s) PERL_STATIC_INLINE bool -Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el); +Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN \ assert(s) PERL_STATIC_INLINE bool -Perl_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) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN_FLAGS \ assert(s) PERL_STATIC_INLINE bool Perl_is_utf8_valid_partial_char_flags(const U8 * const s0, const U8 * const e, const U32 flags) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR_FLAGS \ assert(s0); assert(e) @@ -10017,6 +12057,7 @@ Perl_lsbit_pos32(U32 word) PERL_STATIC_INLINE char * Perl_mortal_getenv(const char *str) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_MORTAL_GETENV \ assert(str) @@ -10033,6 +12074,7 @@ Perl_newPADxVOP(pTHX_ I32 type, I32 flags, PADOFFSET padix) PERL_STATIC_INLINE SV * Perl_newRV_noinc(pTHX_ SV * const tmpRef) + Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NEWRV_NOINC \ assert(tmpRef) @@ -10054,7 +12096,9 @@ Perl_newSVsv_flags(pTHX_ SV * const old, I32 flags) # define PERL_ARGS_ASSERT_NEWSVSV_FLAGS PERL_STATIC_INLINE SV * -Perl_new_sv(pTHX_ const char *file, int line, const char *func); +Perl_new_sv(pTHX_ const char *file, int line, const char *func) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_NEW_SV \ assert(file); assert(func) @@ -10067,7 +12111,8 @@ Perl_push_stackinfo(pTHX_ I32 type, UV flags); # define PERL_ARGS_ASSERT_PUSH_STACKINFO PERL_STATIC_INLINE void -Perl_rpp_context(pTHX_ SV **mark, U8 gimme, SSize_t extra); +Perl_rpp_context(pTHX_ SV **mark, U8 gimme, SSize_t extra) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_CONTEXT \ assert(mark) @@ -10076,12 +12121,14 @@ Perl_rpp_extend(pTHX_ SSize_t n); # define PERL_ARGS_ASSERT_RPP_EXTEND PERL_STATIC_INLINE void -Perl_rpp_invoke_xs(pTHX_ CV *cv); +Perl_rpp_invoke_xs(pTHX_ CV *cv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_INVOKE_XS \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_STATIC_INLINE bool -Perl_rpp_is_lone(pTHX_ SV *sv); +Perl_rpp_is_lone(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_IS_LONE \ assert(sv) @@ -10106,87 +12153,109 @@ Perl_rpp_popfree_2_NN(pTHX); # define PERL_ARGS_ASSERT_RPP_POPFREE_2_NN PERL_STATIC_INLINE void -Perl_rpp_popfree_to(pTHX_ SV **sp); +Perl_rpp_popfree_to(pTHX_ SV **sp) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_POPFREE_TO \ assert(sp) PERL_STATIC_INLINE void -Perl_rpp_popfree_to_NN(pTHX_ SV **sp); +Perl_rpp_popfree_to_NN(pTHX_ SV **sp) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_POPFREE_TO_NN \ assert(sp) PERL_STATIC_INLINE void -Perl_rpp_push_1(pTHX_ SV *sv); +Perl_rpp_push_1(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_PUSH_1 \ assert(sv) PERL_STATIC_INLINE void -Perl_rpp_push_1_norc(pTHX_ SV *sv); +Perl_rpp_push_1_norc(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_PUSH_1_NORC \ assert(sv) PERL_STATIC_INLINE void -Perl_rpp_push_2(pTHX_ SV *sv1, SV *sv2); +Perl_rpp_push_2(pTHX_ SV *sv1, SV *sv2) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_RPP_PUSH_2 \ assert(sv1); assert(sv2) PERL_STATIC_INLINE void -Perl_rpp_push_IMM(pTHX_ SV *sv); +Perl_rpp_push_IMM(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_PUSH_IMM \ assert(sv) PERL_STATIC_INLINE void -Perl_rpp_replace_1_1(pTHX_ SV *sv); +Perl_rpp_replace_1_1(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_REPLACE_1_1 \ assert(sv) PERL_STATIC_INLINE void -Perl_rpp_replace_1_1_NN(pTHX_ SV *sv); +Perl_rpp_replace_1_1_NN(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_REPLACE_1_1_NN \ assert(sv) PERL_STATIC_INLINE void -Perl_rpp_replace_1_IMM_NN(pTHX_ SV *sv); +Perl_rpp_replace_1_IMM_NN(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_REPLACE_1_IMM_NN \ assert(sv) PERL_STATIC_INLINE void -Perl_rpp_replace_2_1(pTHX_ SV *sv); +Perl_rpp_replace_2_1(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_REPLACE_2_1 \ assert(sv) PERL_STATIC_INLINE void -Perl_rpp_replace_2_1_COMMON(pTHX_ SV *sv); +Perl_rpp_replace_2_1_COMMON(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_REPLACE_2_1_COMMON \ assert(sv) PERL_STATIC_INLINE void -Perl_rpp_replace_2_1_NN(pTHX_ SV *sv); +Perl_rpp_replace_2_1_NN(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_REPLACE_2_1_NN \ assert(sv) PERL_STATIC_INLINE void -Perl_rpp_replace_2_IMM_NN(pTHX_ SV *sv); +Perl_rpp_replace_2_IMM_NN(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_REPLACE_2_IMM_NN \ assert(sv) PERL_STATIC_INLINE void -Perl_rpp_replace_at(pTHX_ SV **sp, SV *sv); +Perl_rpp_replace_at(pTHX_ SV **sp, SV *sv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_RPP_REPLACE_AT \ assert(sp); assert(sv) PERL_STATIC_INLINE void -Perl_rpp_replace_at_NN(pTHX_ SV **sp, SV *sv); +Perl_rpp_replace_at_NN(pTHX_ SV **sp, SV *sv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_RPP_REPLACE_AT_NN \ assert(sp); assert(sv) PERL_STATIC_INLINE void -Perl_rpp_replace_at_norc(pTHX_ SV **sp, SV *sv); +Perl_rpp_replace_at_norc(pTHX_ SV **sp, SV *sv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_RPP_REPLACE_AT_NORC \ assert(sp); assert(sv) PERL_STATIC_INLINE void -Perl_rpp_replace_at_norc_NN(pTHX_ SV **sp, SV *sv); +Perl_rpp_replace_at_norc_NN(pTHX_ SV **sp, SV *sv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_RPP_REPLACE_AT_NORC_NN \ assert(sp); assert(sv) @@ -10203,17 +12272,21 @@ Perl_rpp_try_AMAGIC_2(pTHX_ int method, int flags); # define PERL_ARGS_ASSERT_RPP_TRY_AMAGIC_2 PERL_STATIC_INLINE void -Perl_rpp_xpush_1(pTHX_ SV *sv); +Perl_rpp_xpush_1(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_XPUSH_1 \ assert(sv) PERL_STATIC_INLINE void -Perl_rpp_xpush_2(pTHX_ SV *sv1, SV *sv2); +Perl_rpp_xpush_2(pTHX_ SV *sv1, SV *sv2) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_RPP_XPUSH_2 \ assert(sv1); assert(sv2) PERL_STATIC_INLINE void -Perl_rpp_xpush_IMM(pTHX_ SV *sv); +Perl_rpp_xpush_IMM(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_XPUSH_IMM \ assert(sv) @@ -10231,6 +12304,7 @@ Perl_savepvn(pTHX_ const char *pv, Size_t len) PERL_STATIC_INLINE char * Perl_savesharedsvpv(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__malloc__ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SAVESHAREDSVPV \ @@ -10238,6 +12312,7 @@ Perl_savesharedsvpv(pTHX_ SV *sv) PERL_STATIC_INLINE char * Perl_savesvpv(pTHX_ SV *sv) + Perl_attribute_nonnull_(pTHX_1) __attribute__malloc__ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SAVESVPV \ @@ -10252,200 +12327,254 @@ Perl_single_1bit_pos32(U32 word) assert(sv) PERL_STATIC_INLINE char * -Perl_sv_pvbyten_force_wrapper(pTHX_ SV * const sv, STRLEN * const lp, const U32 dummy); +Perl_sv_pvbyten_force_wrapper(pTHX_ SV * const sv, STRLEN * const lp, const U32 dummy) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE_WRAPPER \ assert(sv) PERL_STATIC_INLINE char * -Perl_sv_pvutf8n_force_wrapper(pTHX_ SV * const sv, STRLEN * const lp, const U32 dummy); +Perl_sv_pvutf8n_force_wrapper(pTHX_ SV * const sv, STRLEN * const lp, const U32 dummy) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE_WRAPPER \ assert(sv) PERL_STATIC_INLINE char * -Perl_sv_setpv_freshbuf(pTHX_ SV * const sv); +Perl_sv_setpv_freshbuf(pTHX_ SV * const sv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_SETPV_FRESHBUF \ assert(sv) PERL_STATIC_INLINE void -Perl_switch_argstack(pTHX_ AV *to); +Perl_switch_argstack(pTHX_ AV *to) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SWITCH_ARGSTACK \ assert(to); assert(SvTYPE(to) == SVt_PVAV) PERL_STATIC_INLINE IV Perl_utf8_distance(pTHX_ const U8 *a, const U8 *b) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_UTF8_DISTANCE \ assert(a); assert(b) PERL_STATIC_INLINE U8 * Perl_utf8_hop(const U8 *s, SSize_t off) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_UTF8_HOP \ assert(s) PERL_STATIC_INLINE U8 * Perl_utf8_hop_back_overshoot(const U8 *s, SSize_t off, const U8 * const start, SSize_t *remaining) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(3) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_UTF8_HOP_BACK_OVERSHOOT \ assert(s); assert(start) PERL_STATIC_INLINE U8 * Perl_utf8_hop_forward_overshoot(const U8 *s, SSize_t off, const U8 * const end, SSize_t *remaining) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(3) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_UTF8_HOP_FORWARD_OVERSHOOT \ assert(s); assert(end) PERL_STATIC_INLINE U8 * Perl_utf8_hop_overshoot(const U8 *s, SSize_t off, const U8 * const start, const U8 * const end, SSize_t *remaining) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(3) + Perl_attribute_nonnull_(4) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_UTF8_HOP_OVERSHOOT \ assert(s); assert(start); assert(end) PERL_STATIC_INLINE bool -Perl_utf8_to_bytes_new_pv(pTHX_ U8 const **s_ptr, STRLEN *lenp, void **free_me); +Perl_utf8_to_bytes_new_pv(pTHX_ U8 const **s_ptr, STRLEN *lenp, void **free_me) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_UTF8_TO_BYTES_NEW_PV \ assert(s_ptr); assert(lenp); assert(free_me) PERL_STATIC_INLINE bool -Perl_utf8_to_bytes_overwrite(pTHX_ U8 **s_ptr, STRLEN *lenp); +Perl_utf8_to_bytes_overwrite(pTHX_ U8 **s_ptr, STRLEN *lenp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_UTF8_TO_BYTES_OVERWRITE \ assert(s_ptr); assert(lenp) PERL_STATIC_INLINE bool -Perl_utf8_to_bytes_temp_pv(pTHX_ U8 const **s_ptr, STRLEN *lenp); +Perl_utf8_to_bytes_temp_pv(pTHX_ U8 const **s_ptr, STRLEN *lenp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_UTF8_TO_BYTES_TEMP_PV \ assert(s_ptr); assert(lenp) PERL_STATIC_INLINE bool -Perl_utf8_to_uv_msgs(const U8 * const s0, const U8 *e, UV *cp_p, Size_t *advance_p, U32 flags, U32 *errors, AV **msgs); +Perl_utf8_to_uv_msgs(const U8 * const s0, const U8 *e, UV *cp_p, Size_t *advance_p, U32 flags, U32 *errors, AV **msgs) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(3); # define PERL_ARGS_ASSERT_UTF8_TO_UV_MSGS \ assert(s0); assert(e); assert(cp_p) PERL_STATIC_INLINE UV -Perl_utf8_to_uv_or_die(const U8 * const s, const U8 *e, Size_t *advance_p); +Perl_utf8_to_uv_or_die(const U8 * const s, const U8 *e, Size_t *advance_p) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2); # define PERL_ARGS_ASSERT_UTF8_TO_UV_OR_DIE \ assert(s); assert(e) PERL_STATIC_INLINE UV -Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen); +Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF \ assert(s); assert(send) PERL_STATIC_INLINE UV -Perl_utf8n_to_uvchr_msgs(const U8 * const s0, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 *errors, AV **msgs); +Perl_utf8n_to_uvchr_msgs(const U8 * const s0, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 *errors, AV **msgs) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_MSGS \ assert(s0) PERL_STATIC_INLINE U8 * -Perl_uv_to_utf8(pTHX_ U8 *d, UV uv); +Perl_uv_to_utf8(pTHX_ U8 *d, UV uv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_UV_TO_UTF8 \ assert(d) PERL_STATIC_INLINE U8 * -Perl_uv_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); +Perl_uv_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_UV_TO_UTF8_FLAGS \ assert(d) PERL_STATIC_INLINE UV Perl_valid_utf8_to_uv(const U8 *s, STRLEN *retlen) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_VALID_UTF8_TO_UV \ assert(s) PERL_STATIC_INLINE void -Perl_cx_popblock(pTHX_ PERL_CONTEXT *cx); +Perl_cx_popblock(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPBLOCK \ assert(cx) PERL_STATIC_INLINE void -Perl_cx_popeval(pTHX_ PERL_CONTEXT *cx); +Perl_cx_popeval(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPEVAL \ assert(cx) PERL_STATIC_INLINE void -Perl_cx_popformat(pTHX_ PERL_CONTEXT *cx); +Perl_cx_popformat(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPFORMAT \ assert(cx) PERL_STATIC_INLINE void -Perl_cx_popgiven(pTHX_ PERL_CONTEXT *cx); +Perl_cx_popgiven(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPGIVEN \ assert(cx) PERL_STATIC_INLINE void -Perl_cx_poploop(pTHX_ PERL_CONTEXT *cx); +Perl_cx_poploop(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPLOOP \ assert(cx) PERL_STATIC_INLINE void -Perl_cx_popsub(pTHX_ PERL_CONTEXT *cx); +Perl_cx_popsub(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPSUB \ assert(cx) PERL_STATIC_INLINE void -Perl_cx_popsub_args(pTHX_ PERL_CONTEXT *cx); +Perl_cx_popsub_args(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPSUB_ARGS \ assert(cx) PERL_STATIC_INLINE void -Perl_cx_popsub_common(pTHX_ PERL_CONTEXT *cx); +Perl_cx_popsub_common(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPSUB_COMMON \ assert(cx) PERL_STATIC_INLINE void -Perl_cx_popwhen(pTHX_ PERL_CONTEXT *cx); +Perl_cx_popwhen(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPWHEN \ assert(cx) PERL_STATIC_INLINE PERL_CONTEXT * -Perl_cx_pushblock(pTHX_ U8 type, U8 gimme, SV **sp, I32 saveix); +Perl_cx_pushblock(pTHX_ U8 type, U8 gimme, SV **sp, I32 saveix) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_CX_PUSHBLOCK \ assert(sp) PERL_STATIC_INLINE void -Perl_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv); +Perl_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_PUSHEVAL \ assert(cx) PERL_STATIC_INLINE void -Perl_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_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CX_PUSHFORMAT \ assert(cx); assert(cv); \ assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_STATIC_INLINE void -Perl_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv); +Perl_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_PUSHGIVEN \ assert(cx) PERL_STATIC_INLINE void -Perl_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV *itersave); +Perl_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV *itersave) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CX_PUSHLOOP_FOR \ assert(cx); assert(itervarp) PERL_STATIC_INLINE void -Perl_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx); +Perl_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_PUSHLOOP_PLAIN \ assert(cx) PERL_STATIC_INLINE void -Perl_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) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CX_PUSHSUB \ assert(cx); assert(cv); \ assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_STATIC_INLINE void -Perl_cx_pushtry(pTHX_ PERL_CONTEXT *cx, OP *retop); +Perl_cx_pushtry(pTHX_ PERL_CONTEXT *cx, OP *retop) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_PUSHTRY \ assert(cx) PERL_STATIC_INLINE void -Perl_cx_pushwhen(pTHX_ PERL_CONTEXT *cx); +Perl_cx_pushwhen(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_PUSHWHEN \ assert(cx) PERL_STATIC_INLINE void -Perl_cx_topblock(pTHX_ PERL_CONTEXT *cx); +Perl_cx_topblock(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_TOPBLOCK \ assert(cx) @@ -10458,39 +12587,40 @@ PERL_STATIC_INLINE Size_t Perl_my_strlcat(char *dst, const char *src, Size_t size); # define PERL_ARGS_ASSERT_MY_STRLCAT -# endif -# if !defined(HAS_STRNLEN) -PERL_STATIC_INLINE Size_t -Perl_my_strnlen(const char *str, Size_t maxlen); -# define PERL_ARGS_ASSERT_MY_STRNLEN \ - assert(str) - # endif # if defined(PERL_CORE) || defined(PERL_EXT) PERL_STATIC_INLINE void -Perl_append_utf8_from_native_byte(const U8 byte, U8 **dest); +Perl_append_utf8_from_native_byte(const U8 byte, U8 **dest) + Perl_attribute_nonnull_(2); PERL_STATIC_INLINE bool -Perl_sv_only_taint_gmagic(SV *sv); +Perl_sv_only_taint_gmagic(SV *sv) + Perl_attribute_nonnull_(1); PERL_STATIC_INLINE bool Perl_is_utf8_non_invariant_string(const U8 * const s, STRLEN len) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_UTF8_NON_INVARIANT_STRING \ assert(s) PERL_STATIC_INLINE STRLEN -S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp); +S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SV_OR_PV_POS_U2B \ assert(sv); assert(pv) PERL_STATIC_INLINE Size_t S_variant_under_utf8_count(const U8 * const s, const U8 * const e) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_VARIANT_UNDER_UTF8_COUNT \ assert(s); assert(e) # if !defined(HAS_MEMRCHR) PERL_STATIC_INLINE void * -S_my_memrchr(const char *s, const char c, const STRLEN len); +S_my_memrchr(const char *s, const char c, const STRLEN len) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_MY_MEMRCHR \ assert(s) @@ -10501,15 +12631,19 @@ S_my_memrchr(const char *s, const char c, const STRLEN len); defined(PERL_IN_UTF8_C) PERL_STATIC_INLINE bool S__invlist_contains_cp(SV * const invlist, const UV cp) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE UV S__invlist_len(SV * const invlist) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE bool * S_get_invlist_offset_addr(SV *invlist) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE UV * S_invlist_array(SV * const invlist) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE bool S_is_invlist(const SV * const invlist) @@ -10524,18 +12658,22 @@ PERL_STATIC_INLINE SV * S_add_cp_to_invlist(pTHX_ SV *invlist, const UV cp) __attribute__warn_unused_result__; PERL_STATIC_INLINE void -S_invlist_extend(pTHX_ SV * const invlist, const UV len); +S_invlist_extend(pTHX_ SV * const invlist, const UV len) + Perl_attribute_nonnull_(pTHX_1); PERL_STATIC_INLINE UV S_invlist_highest(SV * const invlist) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE void -S_invlist_set_len(pTHX_ SV * const invlist, const UV len, const bool offset); +S_invlist_set_len(pTHX_ SV * const invlist, const UV len, const bool offset) + Perl_attribute_nonnull_(pTHX_1); # endif /* defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_REGCOMP_ANY) */ # if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_ANY) || \ defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C) PERL_STATIC_INLINE const char * -S_get_regex_charset_name(const U32 flags, STRLEN * const lenp); +S_get_regex_charset_name(const U32 flags, STRLEN * const lenp) + Perl_attribute_nonnull_(2); # endif # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # if defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || \ @@ -10577,7 +12715,8 @@ S_get_regex_charset_name(const U32 flags, STRLEN * const lenp); defined(PERL_IN_REGCOMP_ANY) */ # if defined(PERL_IN_OP_C) || defined(PERL_IN_PAD_C) PERL_STATIC_INLINE bool -S_PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq); +S_PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_PADNAMEIN_SCOPE \ assert(pn) @@ -10598,19 +12737,26 @@ S_PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq); # if defined(PERL_CORE) || defined(PERL_EXT) PERL_STATIC_INLINE STRLEN * S_get_invlist_iter_addr(SV *invlist) + Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE void -S_invlist_iterfinish(SV *invlist); +S_invlist_iterfinish(SV *invlist) + Perl_attribute_nonnull_(1); PERL_STATIC_INLINE void -S_invlist_iterinit(SV *invlist); +S_invlist_iterinit(SV *invlist) + Perl_attribute_nonnull_(1); PERL_STATIC_INLINE bool S_invlist_iternext(SV *invlist, UV *start, UV *end) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) + Perl_attribute_nonnull_(3) __attribute__warn_unused_result__; # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # endif /* defined(PERL_IN_OP_C) || defined(PERL_IN_REGCOMP_ANY) */ # if defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C) PERL_STATIC_INLINE bool S_lossless_NV_to_IV(const NV nv, IV *ivp) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_LOSSLESS_NV_TO_IV \ assert(ivp) @@ -10641,18 +12787,12 @@ Perl_single_1bit_pos64(U64 word) # endif /* defined(U64TYPE) */ # if defined(USE_ITHREADS) PERL_STATIC_INLINE AV * -Perl_cop_file_avn(pTHX_ const COP *cop); +Perl_cop_file_avn(pTHX_ const COP *cop) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_COP_FILE_AVN \ assert(cop) -# if !defined(PERL_IMPLICIT_SYS) -PERL_STATIC_INLINE bool -S_PerlEnv_putenv(pTHX_ char *str); -# define PERL_ARGS_ASSERT_PERLENV_PUTENV \ - assert(str) - -# endif -# endif /* defined(USE_ITHREADS) */ +# endif # if !defined(WIN32) PERL_STATIC_INLINE void * Perl_get_context(void) @@ -10670,14 +12810,17 @@ Perl_runops_wrap(pTHX); # define PERL_ARGS_ASSERT_RUNOPS_WRAP PERL_CALLCONV void -Perl_xs_wrap(pTHX_ XSUBADDR_t xsub, CV *cv); +Perl_xs_wrap(pTHX_ XSUBADDR_t xsub, CV *cv) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_XS_WRAP \ assert(xsub); assert(cv); \ assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV OP * -Perl_pp_wrap(pTHX_ Perl_ppaddr_t real_pp_fn, I32 nargs, int nlists); +Perl_pp_wrap(pTHX_ Perl_ppaddr_t real_pp_fn, I32 nargs, int nlists) + Perl_attribute_nonnull_(pTHX_1); # endif #endif /* defined(PERL_RC_STACK) */ #if defined(PERL_USE_3ARG_SIGHANDLER) @@ -10706,14 +12849,16 @@ Perl_sighandler(int sig) #endif #if defined(UNLINK_ALL_VERSIONS) PERL_CALLCONV I32 -Perl_unlnk(pTHX_ const char *f); +Perl_unlnk(pTHX_ const char *f) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_UNLNK \ assert(f) #endif #if defined(USE_C_BACKTRACE) PERL_CALLCONV bool -Perl_dump_c_backtrace(pTHX_ PerlIO *fp, int max_depth, int skip); +Perl_dump_c_backtrace(pTHX_ PerlIO *fp, int max_depth, int skip) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE \ assert(fp) @@ -10744,93 +12889,113 @@ Perl_get_c_backtrace_dump(pTHX_ int max_depth, int skip); # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV void -Perl_dtrace_probe_call(pTHX_ CV *cv, bool is_call); +Perl_dtrace_probe_call(pTHX_ CV *cv, bool is_call) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void -Perl_dtrace_probe_load(pTHX_ const char *name, bool is_loading); +Perl_dtrace_probe_load(pTHX_ const char *name, bool is_loading) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void -Perl_dtrace_probe_op(pTHX_ const OP *op); +Perl_dtrace_probe_op(pTHX_ const OP *op) + Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void Perl_dtrace_probe_phase(pTHX_ enum perl_phase phase); -# endif +# endif /* defined(PERL_CORE) || defined(PERL_EXT) */ #endif /* defined(USE_DTRACE) */ #if defined(USE_ITHREADS) PERL_CALLCONV PADOFFSET -Perl_alloccopstash(pTHX_ HV *hv); +Perl_alloccopstash(pTHX_ HV *hv) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_ALLOCCOPSTASH \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void * Perl_any_dup(pTHX_ void *v, const PerlInterpreter *proto_perl) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_ANY_DUP \ assert(proto_perl) PERL_CALLCONV void -Perl_clone_params_del(CLONE_PARAMS *param); +Perl_clone_params_del(CLONE_PARAMS *param) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_CLONE_PARAMS_DEL \ assert(param) PERL_CALLCONV CLONE_PARAMS * Perl_clone_params_new(PerlInterpreter * const from, PerlInterpreter * const to) + Perl_attribute_nonnull_(1) + Perl_attribute_nonnull_(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_CLONE_PARAMS_NEW \ assert(from); assert(to) PERL_CALLCONV PERL_CONTEXT * Perl_cx_dup(pTHX_ PERL_CONTEXT *cx, I32 ix, I32 max, CLONE_PARAMS *param) + Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_CX_DUP \ assert(param) PERL_CALLCONV DIR * Perl_dirp_dup(pTHX_ DIR * const dp, CLONE_PARAMS * const param) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DIRP_DUP \ assert(param) PERL_CALLCONV PerlIO * -Perl_fp_dup(pTHX_ PerlIO * const fp, const char type, CLONE_PARAMS * const param); +Perl_fp_dup(pTHX_ PerlIO * const fp, const char type, CLONE_PARAMS * const param) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_FP_DUP \ assert(param) PERL_CALLCONV GP * Perl_gp_dup(pTHX_ GP * const gp, CLONE_PARAMS * const param) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_GP_DUP \ assert(param) PERL_CALLCONV HE * Perl_he_dup(pTHX_ const HE *e, bool shared, CLONE_PARAMS *param) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_HE_DUP \ assert(param) PERL_CALLCONV HEK * Perl_hek_dup(pTHX_ HEK *e, CLONE_PARAMS *param) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_HEK_DUP \ assert(param) PERL_CALLCONV MAGIC * Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS * const param) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_MG_DUP \ assert(param) PERL_CALLCONV struct mro_meta * Perl_mro_meta_dup(pTHX_ struct mro_meta *smeta, CLONE_PARAMS *param) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MRO_META_DUP \ assert(smeta); assert(param) PERL_CALLCONV OP * Perl_newPADOP(pTHX_ I32 type, I32 flags, SV *sv) + Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NEWPADOP \ assert(sv) PERL_CALLCONV PADLIST * Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_PADLIST_DUP \ @@ -10838,6 +13003,8 @@ Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param) PERL_CALLCONV PADNAME * Perl_padname_dup(pTHX_ PADNAME *src, CLONE_PARAMS *param) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_PADNAME_DUP \ @@ -10845,56 +13012,72 @@ Perl_padname_dup(pTHX_ PADNAME *src, CLONE_PARAMS *param) PERL_CALLCONV PADNAMELIST * Perl_padnamelist_dup(pTHX_ PADNAMELIST *srcpad, CLONE_PARAMS *param) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_PADNAMELIST_DUP \ assert(param) PERL_CALLCONV yy_parser * -Perl_parser_dup(pTHX_ const yy_parser * const proto, CLONE_PARAMS * const param); +Perl_parser_dup(pTHX_ const yy_parser * const proto, CLONE_PARAMS * const param) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PARSER_DUP \ assert(param) PERL_CALLCONV PerlInterpreter * -perl_clone(PerlInterpreter *proto_perl, UV flags); +perl_clone(PerlInterpreter *proto_perl, UV flags) + Perl_attribute_nonnull_(1); # define PERL_ARGS_ASSERT_PERL_CLONE \ assert(proto_perl) PERL_CALLCONV void -Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS *param); +Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS *param) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_RE_DUP_GUTS \ assert(sstr); assert(dstr); assert(param) PERL_CALLCONV void * -Perl_regdupe_internal(pTHX_ REGEXP * const r, CLONE_PARAMS *param); +Perl_regdupe_internal(pTHX_ REGEXP * const r, CLONE_PARAMS *param) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_REGDUPE_INTERNAL \ assert(r); assert(param) PERL_CALLCONV void -Perl_rvpv_dup(pTHX_ SV * const dsv, const SV * const ssv, CLONE_PARAMS * const param); +Perl_rvpv_dup(pTHX_ SV * const dsv, const SV * const ssv, CLONE_PARAMS * const param) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_RVPV_DUP \ assert(dsv); assert(ssv); assert(param) PERL_CALLCONV PERL_SI * Perl_si_dup(pTHX_ PERL_SI *si, CLONE_PARAMS *param) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SI_DUP \ assert(param) PERL_CALLCONV ANY * Perl_ss_dup(pTHX_ PerlInterpreter *proto_perl, CLONE_PARAMS *param) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SS_DUP \ assert(proto_perl); assert(param) PERL_CALLCONV SV * Perl_sv_dup(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SV_DUP \ assert(param) PERL_CALLCONV SV * Perl_sv_dup_inc(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) + Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SV_DUP_INC \ assert(param) @@ -10902,11 +13085,13 @@ Perl_sv_dup_inc(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) # if defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) PERL_CALLCONV void Perl_op_relocate_sv(pTHX_ SV **svp, PADOFFSET *targp) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OP_RELOCATE_SV \ assert(svp); assert(targp) -# endif +# endif /* defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) */ #else /* if !defined(USE_ITHREADS) */ /* PERL_CALLCONV void Perl_CopFILEGV_set(pTHX_ COP *c, GV *gv); */ @@ -10915,12 +13100,16 @@ Perl_CopFILEGV_set(pTHX_ COP *c, GV *gv); */ #if defined(USE_LOCALE_COLLATE) PERL_CALLCONV int Perl_magic_freecollxfrm(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MAGIC_FREECOLLXFRM \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM \ assert(sv); assert(mg) @@ -10932,20 +13121,25 @@ Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg) Perl_sv_collxfrm(pTHX_ SV * const sv, STRLEN * const nxp); */ PERL_CALLCONV char * -Perl_sv_collxfrm_flags(pTHX_ SV * const sv, STRLEN * const nxp, I32 const flags); +Perl_sv_collxfrm_flags(pTHX_ SV * const sv, STRLEN * const nxp, I32 const flags) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SV_COLLXFRM_FLAGS \ assert(sv); assert(nxp) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV SV * -Perl_strxfrm(pTHX_ SV *src); +Perl_strxfrm(pTHX_ SV *src) + Perl_attribute_nonnull_(pTHX_1); # if defined(PERL_IN_LOCALE_C) || defined(PERL_IN_MATHOMS_C) || \ defined(PERL_IN_SV_C) PERL_CALLCONV char * Perl_mem_collxfrm_(pTHX_ const char *input_string, STRLEN len, STRLEN *xlen, bool utf8) + Perl_attribute_nonnull_(pTHX_1) + Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); # endif -# endif +# endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # if defined(PERL_IN_LOCALE_C) || defined(PERL_IN_MATHOMS_C) || \ defined(PERL_IN_SV_C) # define PERL_ARGS_ASSERT_MEM_COLLXFRM_ \ @@ -11007,7 +13201,8 @@ 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); +Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PERLIO_READ \ assert(vbuf) @@ -11055,12 +13250,14 @@ 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); +Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PERLIO_UNREAD \ assert(vbuf) PERL_CALLCONV SSize_t -Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count); +Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count) + Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PERLIO_WRITE \ assert(vbuf) @@ -11074,12 +13271,14 @@ Perl_switch_locale_context(pTHX); #if defined(USE_QUADMATH) PERL_CALLCONV bool Perl_quadmath_format_needed(const char *format) + Perl_attribute_nonnull_(1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_QUADMATH_FORMAT_NEEDED \ assert(format) PERL_CALLCONV bool Perl_quadmath_format_valid(const char *format) + Perl_attribute_nonnull_(1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_QUADMATH_FORMAT_VALID \ assert(format) @@ -11097,17 +13296,21 @@ Perl_thread_locale_term(pTHX); #endif #if defined(VMS) || defined(WIN32) PERL_CALLCONV int -Perl_do_aspawn(pTHX_ SV *really, SV **mark, SV **sp); +Perl_do_aspawn(pTHX_ SV *really, SV **mark, SV **sp) + Perl_attribute_nonnull_(pTHX_2) + Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_DO_ASPAWN \ assert(mark); assert(sp) PERL_CALLCONV int -Perl_do_spawn(pTHX_ char *cmd); +Perl_do_spawn(pTHX_ char *cmd) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DO_SPAWN \ assert(cmd) PERL_CALLCONV int -Perl_do_spawn_nowait(pTHX_ char *cmd); +Perl_do_spawn_nowait(pTHX_ char *cmd) + Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DO_SPAWN_NOWAIT \ assert(cmd) @@ -11125,6 +13328,7 @@ Perl_get_win32_message_utf8ness(pTHX_ const char *string) PERL_CALLCONV_NO_RET void win32_croak_not_implemented(const char *fname) + Perl_attribute_nonnull_(1) __attribute__noreturn__; # define PERL_ARGS_ASSERT_WIN32_CROAK_NOT_IMPLEMENTED \ assert(fname) @@ -11132,11 +13336,12 @@ win32_croak_not_implemented(const char *fname) #else /* if !defined(WIN32) */ PERL_CALLCONV bool Perl_do_exec3(pTHX_ const char *incmd, int fd, int do_report) + Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_EXEC3 \ assert(incmd) -#endif +#endif /* !defined(WIN32) */ #ifdef PERL_CORE # include "pp_proto.h" diff --git a/regen/embed.pl b/regen/embed.pl index 17c9ac003744..c9c6ff5b406e 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -337,8 +337,14 @@ sub generate_proto_h { my $argname = $1; if (defined $argname && (! $has_mflag || $binarycompat)) { - if ($nn||$nz) { + if ($nn || $nz) { push @asserts, "assert($argname)"; + if ($nn) { + my $string_n = $n; + $string_n = "pTHX_$string_n" if $has_context; + push @attrs, + "Perl_attribute_nonnull_($string_n)"; + } } if ( ! $nocheck @@ -422,11 +428,12 @@ sub generate_proto_h { die_at_end "$plain_func: Function with '...' arguments must have" . " f or F flag"; } + if ( @attrs ) { - $ret .= "\n"; - $ret .= join( "\n", map { (" " x 8) . $_ } @attrs ); + $ret .= "\n" + . join( "\n", map { (" " x 8) . $_ } @attrs); } - $ret .= ";"; + $ret .= ';'; $ret = "/* $ret */" if $has_mflag; # Hide the prototype from non-authorized code. This acts kind of like @@ -483,6 +490,12 @@ sub generate_proto_h { my $fh = open_print_header("proto.h"); print $fh <<~"EOF"; + #ifdef DEBUGGING /* See GH #23641 */ + # define Perl_attribute_nonnull_(which) + #else + # define Perl_attribute_nonnull_(which) __attribute__nonnull__(which) + #endif + START_EXTERN_C $clean #ifdef PERL_CORE From b484be972fe433e872454b32f2db968d87d6408f Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Wed, 10 Sep 2025 19:44:36 -0600 Subject: [PATCH 14/14] Add __attribute_nonnull__ to aTHX parameter This parameter is always non-null when built with MULTIPLICITY. At no runtime cost, make sure the compiler knows that. --- proto.h | 2528 +++++++++++++++++++++++++++++++++++++++++------- regen/embed.pl | 8 + 2 files changed, 2177 insertions(+), 359 deletions(-) diff --git a/proto.h b/proto.h index f1625f76c268..e9a3c1968c35 100644 --- a/proto.h +++ b/proto.h @@ -25,31 +25,42 @@ # define Perl_attribute_nonnull_(which) __attribute__nonnull__(which) #endif +#if defined(MULTIPLICITY) +# define Perl_attribute_nonnull_aTHX_ __attribute__nonnull__(1) +#else +# define Perl_attribute_nonnull_aTHX_ +#endif + START_EXTERN_C PERL_CALLCONV int Perl_Gv_AMupdate(pTHX_ HV *stash, bool destructing) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_AMUPDATE \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV const char * -Perl_PerlIO_context_layers(pTHX_ const char *mode); +Perl_PerlIO_context_layers(pTHX_ const char *mode) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PERLIO_CONTEXT_LAYERS PERL_CALLCONV int Perl_PerlLIO_dup2_cloexec(pTHX_ int oldfd, int newfd) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PERLLIO_DUP2_CLOEXEC PERL_CALLCONV int Perl_PerlLIO_dup_cloexec(pTHX_ int oldfd) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PERLLIO_DUP_CLOEXEC PERL_CALLCONV int Perl_PerlLIO_open3_cloexec(pTHX_ const char *file, int flag, int perm) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -58,6 +69,7 @@ Perl_PerlLIO_open3_cloexec(pTHX_ const char *file, int flag, int perm) PERL_CALLCONV int Perl_PerlLIO_open_cloexec(pTHX_ const char *file, int flag) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -65,7 +77,8 @@ Perl_PerlLIO_open_cloexec(pTHX_ const char *file, int flag) assert(file) /* PERL_CALLCONV const XOP * -Perl_custom_op_xop(pTHX_ const OP *o); */ +Perl_custom_op_xop(pTHX_ const OP *o) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV const char * Perl_langinfo(const nl_item item); @@ -78,7 +91,8 @@ Perl_langinfo8(const nl_item item, utf8ness_t *utf8ness) assert(utf8ness) PERL_CALLCONV HV * -Perl_localeconv(pTHX); +Perl_localeconv(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PERL_LOCALECONV PERL_CALLCONV const char * @@ -87,20 +101,24 @@ Perl_setlocale(const int category, const char *locale); PERL_CALLCONV void * Perl_Slab_Alloc(pTHX_ size_t sz) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SLAB_ALLOC PERL_CALLCONV void Perl_Slab_Free(pTHX_ void *op) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SLAB_FREE \ assert(op) /* PERL_CALLCONV void -Perl_SvREFCNT_dec_set_NULL(pTHX_ SV *sv); */ +Perl_SvREFCNT_dec_set_NULL(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV_NO_RET void Perl_abort_execution(pTHX_ SV *msg_sv, const char * const name) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__noreturn__ __attribute__visibility__("hidden"); @@ -109,11 +127,13 @@ Perl_abort_execution(pTHX_ SV *msg_sv, const char * const name) PERL_CALLCONV LOGOP * Perl_alloc_LOGOP(pTHX_ I32 type, OP *first, OP *other) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_ALLOC_LOGOP PERL_CALLCONV PADOFFSET Perl_allocmy(pTHX_ const char * const name, const STRLEN len, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_ALLOCMY \ @@ -121,12 +141,14 @@ Perl_allocmy(pTHX_ const char * const name, const STRLEN len, const U32 flags) PERL_CALLCONV bool Perl_amagic_applies(pTHX_ SV *sv, int method, int flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AMAGIC_APPLIES \ assert(sv) PERL_CALLCONV SV * Perl_amagic_call(pTHX_ SV *left, SV *right, int method, int dir) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_AMAGIC_CALL \ @@ -134,17 +156,20 @@ Perl_amagic_call(pTHX_ SV *left, SV *right, int method, int dir) PERL_CALLCONV SV * Perl_amagic_deref_call(pTHX_ SV *ref, int method) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL \ assert(ref) PERL_CALLCONV bool Perl_amagic_is_enabled(pTHX_ int method) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_AMAGIC_IS_ENABLED PERL_CALLCONV SSize_t Perl_apply(pTHX_ I32 type, SV **mark, SV **sp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); @@ -153,6 +178,7 @@ Perl_apply(pTHX_ I32 type, SV **mark, SV **sp) PERL_CALLCONV void Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv, const char *attrstr, STRLEN len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -163,6 +189,7 @@ Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv, const char *attrstr, PERL_CALLCONV OP * Perl_apply_builtin_cv_attributes(pTHX_ CV *cv, OP *attrlist) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_APPLY_BUILTIN_CV_ATTRIBUTES \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) @@ -181,18 +208,21 @@ Perl_atfork_unlock(void); PERL_CALLCONV SV ** Perl_av_arylen_p(pTHX_ AV *av) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_ARYLEN_P \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_clear(pTHX_ AV *av) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_CLEAR \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_create_and_push(pTHX_ AV ** const avp, SV * const val) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH \ @@ -200,6 +230,7 @@ Perl_av_create_and_push(pTHX_ AV ** const avp, SV * const val) PERL_CALLCONV SV ** Perl_av_create_and_unshift_one(pTHX_ AV ** const avp, SV * const val) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE \ @@ -207,17 +238,20 @@ Perl_av_create_and_unshift_one(pTHX_ AV ** const avp, SV * const val) PERL_CALLCONV SV * Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_DELETE \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void -Perl_av_dump(pTHX_ AV *av); +Perl_av_dump(pTHX_ AV *av) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_AV_DUMP \ assert(!av || SvTYPE(av) == SVt_PVAV) PERL_CALLCONV bool Perl_av_exists(pTHX_ AV *av, SSize_t key) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_EXISTS \ @@ -225,12 +259,14 @@ Perl_av_exists(pTHX_ AV *av, SSize_t key) PERL_CALLCONV void Perl_av_extend(pTHX_ AV *av, SSize_t key) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_EXTEND \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_extend_guts(pTHX_ AV *av, SSize_t key, SSize_t *maxp, SV ***allocp, SV ***arrayp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) Perl_attribute_nonnull_(pTHX_5) @@ -241,6 +277,7 @@ Perl_av_extend_guts(pTHX_ AV *av, SSize_t key, SSize_t *maxp, SV ***allocp, SV * PERL_CALLCONV SV ** Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_FETCH \ @@ -248,18 +285,21 @@ Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval) PERL_CALLCONV void Perl_av_fill(pTHX_ AV *av, SSize_t fill) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_FILL \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV IV * Perl_av_iter_p(pTHX_ AV *av) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_ITER_P \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV SSize_t Perl_av_len(pTHX_ AV *av) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_LEN \ @@ -267,6 +307,7 @@ Perl_av_len(pTHX_ AV *av) PERL_CALLCONV AV * Perl_av_make(pTHX_ SSize_t size, SV **strp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_MAKE \ @@ -274,6 +315,7 @@ Perl_av_make(pTHX_ SSize_t size, SV **strp) PERL_CALLCONV SV * Perl_av_nonelem(pTHX_ AV *av, SSize_t ix) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_AV_NONELEM \ @@ -281,12 +323,14 @@ Perl_av_nonelem(pTHX_ AV *av, SSize_t ix) PERL_CALLCONV SV * Perl_av_pop(pTHX_ AV *av) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_POP \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_push(pTHX_ AV *av, SV *val) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_AV_PUSH \ @@ -297,6 +341,7 @@ Perl_av_push(pTHX_ AV *av, SV *val) PERL_CALLCONV SV * Perl_av_shift(pTHX_ AV *av) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_SHIFT \ @@ -304,24 +349,28 @@ Perl_av_shift(pTHX_ AV *av) PERL_CALLCONV SV ** Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_STORE \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_undef(pTHX_ AV *av) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_UNDEF \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_unshift(pTHX_ AV *av, SSize_t num) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_AV_UNSHIFT \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV OP * Perl_bind_match(pTHX_ I32 type, OP *left, OP *right) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__ @@ -331,47 +380,56 @@ Perl_bind_match(pTHX_ I32 type, OP *left, OP *right) PERL_CALLCONV OP * Perl_block_end(pTHX_ I32 floor, OP *seq) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_BLOCK_END PERL_CALLCONV U8 Perl_block_gimme(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_BLOCK_GIMME PERL_CALLCONV int Perl_block_start(pTHX_ int full) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_BLOCK_START PERL_CALLCONV void Perl_blockhook_register(pTHX_ BHK *hk) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER \ assert(hk) PERL_CALLCONV void Perl_boot_core_PerlIO(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_BOOT_CORE_PERLIO PERL_CALLCONV void Perl_boot_core_UNIVERSAL(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_BOOT_CORE_UNIVERSAL PERL_CALLCONV void Perl_boot_core_builtin(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_BOOT_CORE_BUILTIN PERL_CALLCONV void Perl_boot_core_mro(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_BOOT_CORE_MRO PERL_CALLCONV OP * Perl_build_infix_plugin(pTHX_ OP *lhs, OP *rhs, void *tokendata) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -383,6 +441,7 @@ Perl_build_infix_plugin(pTHX_ OP *lhs, OP *rhs, void *tokendata) PERL_CALLCONV int Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_BYTES_CMP_UTF8 \ @@ -390,6 +449,7 @@ Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen) PERL_CALLCONV U8 * Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *lenp, bool *is_utf8p) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -398,6 +458,7 @@ Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *lenp, bool *is_utf8p) PERL_CALLCONV U8 * Perl_bytes_to_utf8_free_me(pTHX_ const U8 *s, STRLEN *lenp, void **free_me) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_BYTES_TO_UTF8_FREE_ME \ @@ -408,41 +469,48 @@ Perl_c9strict_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_ PERL_CALLCONV SSize_t Perl_call_argv(pTHX_ const char *sub_name, I32 flags, char **argv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_CALL_ARGV \ assert(sub_name); assert(argv) PERL_CALLCONV void -Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr); +Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_CALL_ATEXIT PERL_CALLCONV void Perl_call_list(pTHX_ I32 oldscope, AV *paramList) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_CALL_LIST \ assert(paramList); assert(SvTYPE(paramList) == SVt_PVAV) PERL_CALLCONV SSize_t Perl_call_method(pTHX_ const char *methname, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CALL_METHOD \ assert(methname) PERL_CALLCONV SSize_t Perl_call_pv(pTHX_ const char *sub_name, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CALL_PV \ assert(sub_name) PERL_CALLCONV SSize_t Perl_call_sv(pTHX_ SV *sv, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CALL_SV \ assert(sv) PERL_CALLCONV const PERL_CONTEXT * -Perl_caller_cx(pTHX_ I32 level, const PERL_CONTEXT **dbcxp); +Perl_caller_cx(pTHX_ I32 level, const PERL_CONTEXT **dbcxp) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_CALLER_CX PERL_CALLCONV Malloc_t @@ -453,6 +521,7 @@ Perl_calloc(MEM_SIZE elements, MEM_SIZE size) PERL_CALLCONV bool Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t *statbufp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -481,6 +550,7 @@ Perl_cast_uv(NV f) PERL_CALLCONV bool Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CHECK_UTF8_PRINT \ @@ -488,6 +558,7 @@ Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len) PERL_CALLCONV OP * Perl_ck_entersub_args_core(pTHX_ OP *entersubop, GV *namegv, SV *protosv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -497,12 +568,14 @@ Perl_ck_entersub_args_core(pTHX_ OP *entersubop, GV *namegv, SV *protosv) PERL_CALLCONV OP * Perl_ck_entersub_args_list(pTHX_ OP *entersubop) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_LIST \ assert(entersubop) PERL_CALLCONV OP * Perl_ck_entersub_args_proto(pTHX_ OP *entersubop, GV *namegv, SV *protosv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -511,6 +584,7 @@ Perl_ck_entersub_args_proto(pTHX_ OP *entersubop, GV *namegv, SV *protosv) PERL_CALLCONV OP * Perl_ck_entersub_args_proto_or_list(pTHX_ OP *entersubop, GV *namegv, SV *protosv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -519,6 +593,7 @@ Perl_ck_entersub_args_proto_or_list(pTHX_ OP *entersubop, GV *namegv, SV *protos PERL_CALLCONV void Perl_ck_warner(pTHX_ U32 err, const char *pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_CK_WARNER \ @@ -526,6 +601,7 @@ Perl_ck_warner(pTHX_ U32 err, const char *pat, ...) PERL_CALLCONV void Perl_ck_warner_d(pTHX_ U32 err, const char *pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_CK_WARNER_D \ @@ -533,24 +609,28 @@ Perl_ck_warner_d(pTHX_ U32 err, const char *pat, ...) PERL_CALLCONV bool Perl_ckwarn(pTHX_ U32 w) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__ __attribute__pure__; #define PERL_ARGS_ASSERT_CKWARN PERL_CALLCONV bool Perl_ckwarn_d(pTHX_ U32 w) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__ __attribute__pure__; #define PERL_ARGS_ASSERT_CKWARN_D PERL_CALLCONV void Perl_clear_defarray(pTHX_ AV *av, bool abandon) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CLEAR_DEFARRAY \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV const COP * Perl_closest_cop(pTHX_ const COP *cop, const OP *o, const OP *curop, bool opnext) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CLOSEST_COP \ @@ -558,6 +638,7 @@ Perl_closest_cop(pTHX_ const COP *cop, const OP *o, const OP *curop, bool opnext PERL_CALLCONV OP * Perl_cmpchain_extend(pTHX_ I32 type, OP *ch, OP *right) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -566,6 +647,7 @@ Perl_cmpchain_extend(pTHX_ I32 type, OP *ch, OP *right) PERL_CALLCONV OP * Perl_cmpchain_finish(pTHX_ OP *ch) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -574,6 +656,7 @@ Perl_cmpchain_finish(pTHX_ OP *ch) PERL_CALLCONV OP * Perl_cmpchain_start(pTHX_ I32 type, OP *left, OP *right) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CMPCHAIN_START @@ -582,30 +665,35 @@ Perl_cmpchain_start(pTHX_ I32 type, OP *left, OP *right) PERL_CALLCONV void Perl_cop_disable_warning(pTHX_ COP *cop, int warn_bit) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_COP_DISABLE_WARNING \ assert(cop) PERL_CALLCONV void Perl_cop_enable_warning(pTHX_ COP *cop, int warn_bit) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_COP_ENABLE_WARNING \ assert(cop) PERL_CALLCONV const char * Perl_cop_fetch_label(pTHX_ COP * const cop, STRLEN *len, U32 *flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_COP_FETCH_LABEL \ assert(cop) PERL_CALLCONV bool Perl_cop_has_warning(pTHX_ const COP *cop, int warn_bit) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_COP_HAS_WARNING \ assert(cop) PERL_CALLCONV void Perl_cop_store_label(pTHX_ COP * const cop, const char *label, STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_COP_STORE_LABEL \ @@ -613,6 +701,7 @@ Perl_cop_store_label(pTHX_ COP * const cop, const char *label, STRLEN len, U32 f PERL_CALLCONV SV * Perl_core_prototype(pTHX_ SV *sv, const char *name, const int code, int * const opnum) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CORE_PROTOTYPE \ @@ -620,6 +709,7 @@ Perl_core_prototype(pTHX_ SV *sv, const char *name, const int code, int * const PERL_CALLCONV OP * Perl_coresub_op(pTHX_ SV * const coreargssv, const int code, const int opnum) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CORESUB_OP \ @@ -627,6 +717,7 @@ Perl_coresub_op(pTHX_ SV * const coreargssv, const int code, const int opnum) PERL_CALLCONV void Perl_create_eval_scope(pTHX_ OP *retop, SV **sp, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CREATE_EVAL_SCOPE \ @@ -634,6 +725,7 @@ Perl_create_eval_scope(pTHX_ OP *retop, SV **sp, U32 flags) PERL_CALLCONV_NO_RET void Perl_croak(pTHX_ const char *pat, ...) + Perl_attribute_nonnull_aTHX_ __attribute__noreturn__ __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_CROAK @@ -676,6 +768,7 @@ Perl_croak_popstack(void) PERL_CALLCONV_NO_RET void Perl_croak_sv(pTHX_ SV *baseex) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__noreturn__; #define PERL_ARGS_ASSERT_CROAK_SV \ @@ -701,6 +794,7 @@ Perl_csighandler3(int sig, Siginfo_t *info, void *uap); PERL_CALLCONV XOPRETANY Perl_custom_op_get_field(pTHX_ const OP *o, const xop_flags_enum field) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CUSTOM_OP_GET_FIELD \ @@ -708,6 +802,7 @@ Perl_custom_op_get_field(pTHX_ const OP *o, const xop_flags_enum field) PERL_CALLCONV void Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER \ @@ -718,6 +813,7 @@ Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop) PERL_CALLCONV CV * Perl_cv_clone(pTHX_ CV *proto) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CV_CLONE \ assert(proto); \ @@ -725,6 +821,7 @@ Perl_cv_clone(pTHX_ CV *proto) PERL_CALLCONV CV * Perl_cv_clone_into(pTHX_ CV *proto, CV *target) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -747,12 +844,14 @@ Perl_cv_const_sv_or_av(const CV * const cv) PERL_CALLCONV void Perl_cv_forget_slab(pTHX_ CV *cv) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CV_FORGET_SLAB \ assert(!cv || SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -762,6 +861,7 @@ Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p) PERL_CALLCONV void Perl_cv_get_call_checker_flags(pTHX_ CV *cv, U32 gflags, Perl_call_checker *ckfun_p, SV **ckobj_p, U32 *ckflags_p) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) @@ -772,12 +872,14 @@ Perl_cv_get_call_checker_flags(pTHX_ CV *cv, U32 gflags, Perl_call_checker *ckfu PERL_CALLCONV SV * Perl_cv_name(pTHX_ CV *cv, SV *sv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CV_NAME \ assert(cv) PERL_CALLCONV void Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -787,6 +889,7 @@ Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj) PERL_CALLCONV void Perl_cv_set_call_checker_flags(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj, U32 ckflags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -796,12 +899,14 @@ Perl_cv_set_call_checker_flags(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj, PERL_CALLCONV void Perl_cv_undef(pTHX_ CV *cv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CV_UNDEF \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_cv_undef_flags(pTHX_ CV *cv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CV_UNDEF_FLAGS \ @@ -809,18 +914,21 @@ Perl_cv_undef_flags(pTHX_ CV *cv, U32 flags) PERL_CALLCONV GV * Perl_cvgv_from_hek(pTHX_ CV *cv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CVGV_FROM_HEK \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_cvgv_set(pTHX_ CV *cv, GV *gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CVGV_SET \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_cvstash_set(pTHX_ CV *cv, HV *stash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CVSTASH_SET \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ @@ -828,17 +936,20 @@ Perl_cvstash_set(pTHX_ CV *cv, HV *stash) PERL_CALLCONV void Perl_cx_dump(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_CX_DUMP \ assert(cx) PERL_CALLCONV I32 Perl_cxinc(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CXINC PERL_CALLCONV void Perl_deb(pTHX_ const char *pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_DEB \ @@ -846,34 +957,41 @@ Perl_deb(pTHX_ const char *pat, ...) PERL_CALLCONV void Perl_deb_stack_all(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DEB_STACK_ALL PERL_CALLCONV I32 Perl_debop(pTHX_ const OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_DEBOP \ assert(o) PERL_CALLCONV void -Perl_debprofdump(pTHX); +Perl_debprofdump(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_DEBPROFDUMP PERL_CALLCONV I32 -Perl_debstack(pTHX); +Perl_debstack(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_DEBSTACK PERL_CALLCONV I32 -Perl_debstackptrs(pTHX); +Perl_debstackptrs(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_DEBSTACKPTRS PERL_CALLCONV void Perl_debug_hash_seed(pTHX_ bool via_debug_h) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DEBUG_HASH_SEED PERL_CALLCONV SV * Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -882,6 +1000,7 @@ Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV void Perl_delete_eval_scope(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DELETE_EVAL_SCOPE @@ -901,17 +1020,20 @@ Perl_delimcpy(char *to, const char *to_end, const char *from, const char *from_e assert(retlen) PERL_CALLCONV void -Perl_despatch_signals(pTHX); +Perl_despatch_signals(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_DESPATCH_SIGNALS PERL_CALLCONV_NO_RET OP * Perl_die(pTHX_ const char *pat, ...) + Perl_attribute_nonnull_aTHX_ __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) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__noreturn__; #define PERL_ARGS_ASSERT_DIE_SV \ @@ -919,6 +1041,7 @@ Perl_die_sv(pTHX_ SV *baseex) PERL_CALLCONV_NO_RET void Perl_die_unwind(pTHX_ SV *msv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__noreturn__ __attribute__visibility__("hidden"); @@ -926,10 +1049,12 @@ Perl_die_unwind(pTHX_ SV *msv) assert(msv) /* PERL_CALLCONV bool -Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp); */ +Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV bool Perl_do_aexec5(pTHX_ SV *really, SV **mark, SV **sp, int fd, int do_report) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); @@ -937,11 +1062,13 @@ Perl_do_aexec5(pTHX_ SV *really, SV **mark, SV **sp, int fd, int do_report) assert(mark); assert(sp) PERL_CALLCONV bool -Perl_do_close(pTHX_ GV *gv, bool is_explicit); +Perl_do_close(pTHX_ GV *gv, bool is_explicit) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_DO_CLOSE PERL_CALLCONV void Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_DUMP_PAD \ @@ -949,6 +1076,7 @@ Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full) PERL_CALLCONV bool Perl_do_eof(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_EOF \ @@ -956,6 +1084,7 @@ Perl_do_eof(pTHX_ GV *gv) PERL_CALLCONV void Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_DO_GV_DUMP \ @@ -963,6 +1092,7 @@ Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv) PERL_CALLCONV void Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_DO_GVGV_DUMP \ @@ -970,6 +1100,7 @@ Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv) PERL_CALLCONV void Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_DO_HV_DUMP \ @@ -977,6 +1108,7 @@ Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv) PERL_CALLCONV void Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -986,12 +1118,14 @@ Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp) PERL_CALLCONV void Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_DO_MAGIC_DUMP \ assert(file) PERL_CALLCONV I32 Perl_do_ncmp(pTHX_ SV * const left, SV * const right) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__ @@ -1001,15 +1135,18 @@ Perl_do_ncmp(pTHX_ SV * const left, SV * const right) PERL_CALLCONV void Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_DO_OP_DUMP \ assert(file) /* PERL_CALLCONV bool -Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp); */ +Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV bool Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -1018,6 +1155,7 @@ Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, PERL_CALLCONV bool Perl_do_open_raw(pTHX_ GV *gv, const char *oname, STRLEN len, int rawmode, int rawperm, Stat_t *statbufp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -1026,6 +1164,7 @@ Perl_do_open_raw(pTHX_ GV *gv, const char *oname, STRLEN len, int rawmode, int r PERL_CALLCONV bool Perl_do_openn(pTHX_ GV *gv, const char *oname, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV **svp, I32 num) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_DO_OPENN \ @@ -1033,12 +1172,14 @@ Perl_do_openn(pTHX_ GV *gv, const char *oname, I32 len, int as_raw, int rawmode, PERL_CALLCONV void Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_DO_PMOP_DUMP \ assert(file) PERL_CALLCONV bool Perl_do_print(pTHX_ SV *sv, PerlIO *fp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_PRINT \ @@ -1046,17 +1187,20 @@ Perl_do_print(pTHX_ SV *sv, PerlIO *fp) PERL_CALLCONV OP * Perl_do_readline(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_READLINE PERL_CALLCONV bool Perl_do_seek(pTHX_ GV *gv, Off_t pos, int whence) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_SEEK PERL_CALLCONV void Perl_do_sprintf(pTHX_ SV *sv, SSize_t len, SV **sarg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_DO_SPRINTF \ @@ -1064,12 +1208,14 @@ Perl_do_sprintf(pTHX_ SV *sv, SSize_t len, SV **sarg) PERL_CALLCONV void Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_DO_SV_DUMP \ assert(file) PERL_CALLCONV Off_t Perl_do_sysseek(pTHX_ GV *gv, Off_t pos, int whence) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_SYSSEEK \ @@ -1077,6 +1223,7 @@ Perl_do_sysseek(pTHX_ GV *gv, Off_t pos, int whence) PERL_CALLCONV Off_t Perl_do_tell(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -1085,6 +1232,7 @@ Perl_do_tell(pTHX_ GV *gv) PERL_CALLCONV Size_t Perl_do_trans(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_TRANS \ @@ -1095,6 +1243,7 @@ Perl_do_trans(pTHX_ SV *sv) PERL_CALLCONV UV Perl_do_vecget(pTHX_ SV *sv, STRLEN offset, int size) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_VECGET \ @@ -1102,6 +1251,7 @@ Perl_do_vecget(pTHX_ SV *sv, STRLEN offset, int size) PERL_CALLCONV void Perl_do_vecset(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_VECSET \ @@ -1109,6 +1259,7 @@ Perl_do_vecset(pTHX_ SV *sv) PERL_CALLCONV void Perl_do_vop(pTHX_ I32 optype, SV *sv, SV *left, SV *right) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) @@ -1118,6 +1269,7 @@ Perl_do_vop(pTHX_ I32 optype, SV *sv, SV *left, SV *right) PERL_CALLCONV OP * Perl_dofile(pTHX_ OP *term, I32 force_builtin) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DOFILE \ @@ -1130,16 +1282,19 @@ Perl_doing_taint(int argc, char **argv, char **env) PERL_CALLCONV OP * Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_DOREF \ assert(o) PERL_CALLCONV void -Perl_dounwind(pTHX_ I32 cxix); +Perl_dounwind(pTHX_ I32 cxix) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_DOUNWIND PERL_CALLCONV U8 Perl_dowantarray(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_DOWANTARRAY @@ -1157,26 +1312,31 @@ Perl_drand48_r(perl_drand48_t *random_state) assert(random_state) PERL_CALLCONV void -Perl_dump_all(pTHX); +Perl_dump_all(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_DUMP_ALL PERL_CALLCONV void Perl_dump_all_perl(pTHX_ bool justperl) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DUMP_ALL_PERL PERL_CALLCONV void -Perl_dump_eval(pTHX); +Perl_dump_eval(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_DUMP_EVAL PERL_CALLCONV void Perl_dump_form(pTHX_ const GV *gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_DUMP_FORM \ assert(gv) PERL_CALLCONV void Perl_dump_indent(pTHX_ I32 level, PerlIO *file, const char *pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__format__(__printf__,pTHX_3,pTHX_4); @@ -1185,12 +1345,14 @@ Perl_dump_indent(pTHX_ I32 level, PerlIO *file, const char *pat, ...) PERL_CALLCONV void Perl_dump_packsubs(pTHX_ const HV *stash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_DUMP_PACKSUBS \ assert(stash) PERL_CALLCONV void Perl_dump_packsubs_perl(pTHX_ const HV *stash, bool justperl) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DUMP_PACKSUBS_PERL \ @@ -1198,12 +1360,14 @@ Perl_dump_packsubs_perl(pTHX_ const HV *stash, bool justperl) PERL_CALLCONV void Perl_dump_sub(pTHX_ const GV *gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_DUMP_SUB \ assert(gv) PERL_CALLCONV void Perl_dump_sub_perl(pTHX_ const GV *gv, bool justperl) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DUMP_SUB_PERL \ @@ -1211,6 +1375,7 @@ Perl_dump_sub_perl(pTHX_ const GV *gv, bool justperl) PERL_CALLCONV void Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char *pat, va_list *args) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_DUMP_VINDENT \ @@ -1223,12 +1388,14 @@ Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char *pat, va_list *args) PERL_CALLCONV SV * Perl_eval_pv(pTHX_ const char *p, I32 croak_on_error) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_EVAL_PV \ assert(p) PERL_CALLCONV SSize_t Perl_eval_sv(pTHX_ SV *sv, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_EVAL_SV \ assert(sv) @@ -1240,6 +1407,7 @@ Perl_extended_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_ PERL_CALLCONV void Perl_fatal_warner(pTHX_ U32 err, const char *pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_FATAL_WARNER \ @@ -1247,12 +1415,14 @@ Perl_fatal_warner(pTHX_ U32 err, const char *pat, ...) PERL_CALLCONV void Perl_fbm_compile(pTHX_ SV *sv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_FBM_COMPILE \ assert(sv) PERL_CALLCONV char * Perl_fbm_instr(pTHX_ unsigned char *big, unsigned char *bigend, SV *littlestr, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -1261,17 +1431,20 @@ Perl_fbm_instr(pTHX_ unsigned char *big, unsigned char *bigend, SV *littlestr, U assert(big); assert(bigend); assert(littlestr) PERL_CALLCONV SV * -Perl_filter_add(pTHX_ filter_t funcp, SV *datasv); +Perl_filter_add(pTHX_ filter_t funcp, SV *datasv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_FILTER_ADD PERL_CALLCONV void Perl_filter_del(pTHX_ filter_t funcp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_FILTER_DEL \ assert(funcp) PERL_CALLCONV I32 Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_FILTER_READ \ @@ -1279,36 +1452,43 @@ Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen) PERL_CALLCONV CV * Perl_find_lexical_cv(pTHX_ PADOFFSET off) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_FIND_LEXICAL_CV PERL_CALLCONV CV * Perl_find_runcv(pTHX_ U32 *db_seqp) + Perl_attribute_nonnull_aTHX_ __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) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_FIND_RUNCV_WHERE PERL_CALLCONV SV * -Perl_find_rundefsv(pTHX); +Perl_find_rundefsv(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_FIND_RUNDEFSV PERL_CALLCONV char * Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char * const * const search_ext, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_FIND_SCRIPT \ assert(scriptname) /* PERL_CALLCONV I32 -Perl_foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ +Perl_foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2) + Perl_attribute_nonnull_aTHX_; */ 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) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_5); #define PERL_ARGS_ASSERT_FOLDEQ_UTF8_FLAGS \ @@ -1316,6 +1496,7 @@ Perl_foldEQ_utf8_flags(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const c PERL_CALLCONV void Perl_forbid_outofblock_ops(pTHX_ OP *o, const char *blockname) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_FORBID_OUTOFBLOCK_OPS \ @@ -1323,11 +1504,13 @@ Perl_forbid_outofblock_ops(pTHX_ OP *o, const char *blockname) PERL_CALLCONV void Perl_force_locale_unlock(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_FORCE_LOCALE_UNLOCK PERL_CALLCONV void Perl_force_out_malformed_utf8_message_(pTHX_ const U8 * const p, const U8 * const e, U32 flags, const bool die_here) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_FORCE_OUT_MALFORMED_UTF8_MESSAGE_ \ @@ -1335,6 +1518,7 @@ Perl_force_out_malformed_utf8_message_(pTHX_ const U8 * const p, const U8 * cons PERL_CALLCONV char * Perl_form(pTHX_ const char *pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_FORM \ @@ -1342,11 +1526,13 @@ Perl_form(pTHX_ const char *pat, ...) PERL_CALLCONV void Perl_free_tied_hv_pool(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_FREE_TIED_HV_POOL PERL_CALLCONV void -Perl_free_tmps(pTHX); +Perl_free_tmps(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_FREE_TMPS #define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME \ @@ -1354,24 +1540,28 @@ Perl_free_tmps(pTHX); PERL_CALLCONV AV * Perl_get_av(pTHX_ const char *name, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GET_AV \ assert(name) PERL_CALLCONV CV * Perl_get_cv(pTHX_ const char *name, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GET_CV \ assert(name) PERL_CALLCONV CV * Perl_get_cvn_flags(pTHX_ const char *name, STRLEN len, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GET_CVN_FLAGS \ assert(name) PERL_CALLCONV void Perl_get_db_sub(pTHX_ SV **svp, CV *cv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GET_DB_SUB \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) @@ -1385,6 +1575,7 @@ Perl_get_extended_os_errno(void) PERL_CALLCONV void Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_GET_HASH_SEED \ @@ -1392,12 +1583,14 @@ Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer) PERL_CALLCONV HV * Perl_get_hv(pTHX_ const char *name, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GET_HV \ assert(name) PERL_CALLCONV const char * Perl_get_no_modify(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__ @@ -1406,6 +1599,7 @@ Perl_get_no_modify(pTHX) PERL_CALLCONV char ** Perl_get_op_descs(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; @@ -1413,6 +1607,7 @@ Perl_get_op_descs(pTHX) PERL_CALLCONV char ** Perl_get_op_names(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; @@ -1420,6 +1615,7 @@ Perl_get_op_names(pTHX) PERL_CALLCONV U32 * Perl_get_opargs(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__ @@ -1428,6 +1624,7 @@ Perl_get_opargs(pTHX) PERL_CALLCONV PPADDR_t * Perl_get_ppaddr(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; @@ -1438,27 +1635,32 @@ Perl_get_ppaddr(pTHX) #define PERL_ARGS_ASSERT_GET_PROP_VALUES PERL_CALLCONV REGEXP * -Perl_get_re_arg(pTHX_ SV *sv); +Perl_get_re_arg(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_GET_RE_ARG PERL_CALLCONV SV * Perl_get_sv(pTHX_ const char *name, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GET_SV \ assert(name) PERL_CALLCONV int Perl_getcwd_sv(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GETCWD_SV \ assert(sv) PERL_CALLCONV void -Perl_gp_free(pTHX_ GV *gv); +Perl_gp_free(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_GP_FREE PERL_CALLCONV GP * -Perl_gp_ref(pTHX_ GP *gp); +Perl_gp_ref(pTHX_ GP *gp) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_GP_REF PERL_CALLCONV bool @@ -1470,6 +1672,7 @@ Perl_grok_atoUV(const char *pv, UV *valptr, const char **endptr) PERL_CALLCONV UV Perl_grok_bin(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -1478,6 +1681,7 @@ Perl_grok_bin(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) PERL_CALLCONV UV Perl_grok_bin_oct_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result, const unsigned shift, const U8 lookup_bit, const char prefix) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -1486,6 +1690,7 @@ Perl_grok_bin_oct_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *re PERL_CALLCONV UV Perl_grok_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -1494,6 +1699,7 @@ Perl_grok_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) PERL_CALLCONV int Perl_grok_infnan(pTHX_ const char **sp, const char *send) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GROK_INFNAN \ @@ -1501,18 +1707,21 @@ Perl_grok_infnan(pTHX_ const char **sp, const char *send) PERL_CALLCONV int Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GROK_NUMBER \ assert(pv) PERL_CALLCONV int Perl_grok_number_flags(pTHX_ const char *pv, STRLEN len, UV *valuep, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GROK_NUMBER_FLAGS \ assert(pv) PERL_CALLCONV bool Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -1521,6 +1730,7 @@ Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send) PERL_CALLCONV UV Perl_grok_oct(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -1528,20 +1738,25 @@ Perl_grok_oct(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) assert(start); assert(len_p); assert(flags) /* PERL_CALLCONV GV * -Perl_gv_AVadd(pTHX_ GV *gv); */ +Perl_gv_AVadd(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV GV * -Perl_gv_HVadd(pTHX_ GV *gv); */ +Perl_gv_HVadd(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV GV * -Perl_gv_IOadd(pTHX_ GV *gv); */ +Perl_gv_IOadd(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV GV * -Perl_gv_add_by_type(pTHX_ GV *gv, svtype type); +Perl_gv_add_by_type(pTHX_ GV *gv, svtype type) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_GV_ADD_BY_TYPE PERL_CALLCONV GV * Perl_gv_autoload_pv(pTHX_ HV *stash, const char *namepv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PV \ @@ -1549,6 +1764,7 @@ Perl_gv_autoload_pv(pTHX_ HV *stash, const char *namepv, U32 flags) PERL_CALLCONV GV * Perl_gv_autoload_pvn(pTHX_ HV *stash, const char *name, STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PVN \ @@ -1556,6 +1772,7 @@ Perl_gv_autoload_pvn(pTHX_ HV *stash, const char *name, STRLEN len, U32 flags) PERL_CALLCONV GV * Perl_gv_autoload_sv(pTHX_ HV *stash, SV *namesv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_AUTOLOAD_SV \ @@ -1563,26 +1780,31 @@ Perl_gv_autoload_sv(pTHX_ HV *stash, SV *namesv, U32 flags) PERL_CALLCONV void Perl_gv_check(pTHX_ HV *stash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_CHECK \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV SV * Perl_gv_const_sv(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_CONST_SV \ assert(gv) PERL_CALLCONV void -Perl_gv_dump(pTHX_ GV *gv); +Perl_gv_dump(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_GV_DUMP /* PERL_CALLCONV void -Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); */ +Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_gv_efullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_EFULLNAME4 \ @@ -1590,63 +1812,75 @@ Perl_gv_efullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain PERL_CALLCONV GV * Perl_gv_fetchfile(pTHX_ const char *name) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_FETCHFILE \ assert(name) PERL_CALLCONV GV * Perl_gv_fetchfile_flags(pTHX_ const char * const name, const STRLEN len, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS \ assert(name) /* PERL_CALLCONV GV * -Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level); */ +Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV GV * -Perl_gv_fetchmeth_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level); */ +Perl_gv_fetchmeth_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV GV * Perl_gv_fetchmeth_pv(pTHX_ HV *stash, const char *name, I32 level, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV \ assert(name) PERL_CALLCONV GV * Perl_gv_fetchmeth_pv_autoload(pTHX_ HV *stash, const char *name, I32 level, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV_AUTOLOAD \ assert(name) PERL_CALLCONV GV * Perl_gv_fetchmeth_pvn(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN \ assert(name) PERL_CALLCONV GV * Perl_gv_fetchmeth_pvn_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN_AUTOLOAD \ assert(name) PERL_CALLCONV GV * Perl_gv_fetchmeth_sv(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV \ assert(namesv) PERL_CALLCONV GV * Perl_gv_fetchmeth_sv_autoload(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV_AUTOLOAD \ assert(namesv) /* PERL_CALLCONV GV * -Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name); */ +Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV GV * Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD \ @@ -1654,6 +1888,7 @@ Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload) PERL_CALLCONV GV * Perl_gv_fetchmethod_pv_flags(pTHX_ HV *stash, const char *name, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PV_FLAGS \ @@ -1661,6 +1896,7 @@ Perl_gv_fetchmethod_pv_flags(pTHX_ HV *stash, const char *name, U32 flags) PERL_CALLCONV GV * Perl_gv_fetchmethod_pvn_flags(pTHX_ HV *stash, const char *name, const STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PVN_FLAGS \ @@ -1668,6 +1904,7 @@ Perl_gv_fetchmethod_pvn_flags(pTHX_ HV *stash, const char *name, const STRLEN le PERL_CALLCONV GV * Perl_gv_fetchmethod_sv_flags(pTHX_ HV *stash, SV *namesv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_SV_FLAGS \ @@ -1675,27 +1912,32 @@ Perl_gv_fetchmethod_sv_flags(pTHX_ HV *stash, SV *namesv, U32 flags) PERL_CALLCONV GV * Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 flags, const svtype sv_type) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_FETCHPV \ assert(nambeg) PERL_CALLCONV GV * Perl_gv_fetchpvn_flags(pTHX_ const char *name, STRLEN len, I32 flags, const svtype sv_type) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_FETCHPVN_FLAGS \ assert(name) PERL_CALLCONV GV * Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_FETCHSV \ assert(name) /* PERL_CALLCONV void -Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); */ +Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_gv_fullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_FULLNAME4 \ @@ -1703,15 +1945,18 @@ Perl_gv_fullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain) PERL_CALLCONV CV * Perl_gv_handler(pTHX_ HV *stash, I32 id) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_HANDLER \ assert(!stash || SvTYPE(stash) == SVt_PVHV) /* PERL_CALLCONV void -Perl_gv_init(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, int multi); */ +Perl_gv_init(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, int multi) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_gv_init_pv(pTHX_ GV *gv, HV *stash, const char *name, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_GV_INIT_PV \ @@ -1719,6 +1964,7 @@ Perl_gv_init_pv(pTHX_ GV *gv, HV *stash, const char *name, U32 flags) PERL_CALLCONV void Perl_gv_init_pvn(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_GV_INIT_PVN \ @@ -1726,6 +1972,7 @@ Perl_gv_init_pvn(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, U32 flag PERL_CALLCONV void Perl_gv_init_sv(pTHX_ GV *gv, HV *stash, SV *namesv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_GV_INIT_SV \ @@ -1733,6 +1980,7 @@ Perl_gv_init_sv(pTHX_ GV *gv, HV *stash, SV *namesv, U32 flags) PERL_CALLCONV void Perl_gv_name_set(pTHX_ GV *gv, const char *name, U32 len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_GV_NAME_SET \ @@ -1740,12 +1988,14 @@ Perl_gv_name_set(pTHX_ GV *gv, const char *name, U32 len, U32 flags) PERL_CALLCONV GV * Perl_gv_override(pTHX_ const char * const name, const STRLEN len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_OVERRIDE \ assert(name) PERL_CALLCONV void Perl_gv_setref(pTHX_ SV * const dsv, SV * const ssv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -1754,30 +2004,35 @@ Perl_gv_setref(pTHX_ SV * const dsv, SV * const ssv) PERL_CALLCONV HV * Perl_gv_stashpv(pTHX_ const char *name, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_STASHPV \ assert(name) PERL_CALLCONV HV * Perl_gv_stashpvn(pTHX_ const char *name, U32 namelen, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_STASHPVN \ assert(name) PERL_CALLCONV HV * Perl_gv_stashsv(pTHX_ SV *sv, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_STASHSV \ assert(sv) PERL_CALLCONV void Perl_gv_try_downgrade(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_GV_TRY_DOWNGRADE \ assert(gv) PERL_CALLCONV struct xpvhv_aux * Perl_hv_auxalloc(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_HV_AUXALLOC \ @@ -1785,6 +2040,7 @@ Perl_hv_auxalloc(pTHX_ HV *hv) PERL_CALLCONV AV ** Perl_hv_backreferences_p(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_HV_BACKREFERENCES_P \ @@ -1792,56 +2048,67 @@ Perl_hv_backreferences_p(pTHX_ HV *hv) PERL_CALLCONV SV * Perl_hv_bucket_ratio(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_BUCKET_RATIO \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void -Perl_hv_clear(pTHX_ HV *hv); +Perl_hv_clear(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_HV_CLEAR \ assert(!hv || SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_clear_placeholders(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_CLEAR_PLACEHOLDERS \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void * -Perl_hv_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int flags, int action, SV *val, U32 hash); +Perl_hv_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int flags, int action, SV *val, U32 hash) + Perl_attribute_nonnull_aTHX_; #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) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_HV_COMMON_KEY_LEN \ assert(!hv || SvTYPE(hv) == SVt_PVHV); assert(key) PERL_CALLCONV HV * Perl_hv_copy_hints_hv(pTHX_ HV * const ohv) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_COPY_HINTS_HV \ assert(!ohv || SvTYPE(ohv) == SVt_PVHV) PERL_CALLCONV void -Perl_hv_delayfree_ent(pTHX_ HV *notused, HE *entry); +Perl_hv_delayfree_ent(pTHX_ HV *notused, HE *entry) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_HV_DELAYFREE_ENT \ assert(!notused || SvTYPE(notused) == SVt_PVHV) /* PERL_CALLCONV SV * -Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags); */ +Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV SV * -Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash); */ +Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void -Perl_hv_dump(pTHX_ HV *hv); +Perl_hv_dump(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_HV_DUMP \ assert(!hv || SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV HE ** Perl_hv_eiter_p(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_EITER_P \ @@ -1849,12 +2116,14 @@ Perl_hv_eiter_p(pTHX_ HV *hv) PERL_CALLCONV void Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_EITER_SET \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_ename_add(pTHX_ HV *hv, const char *name, U32 len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -1863,6 +2132,7 @@ Perl_hv_ename_add(pTHX_ HV *hv, const char *name, U32 len, U32 flags) PERL_CALLCONV void Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -1871,37 +2141,45 @@ Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len, U32 flags) /* PERL_CALLCONV bool Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ /* PERL_CALLCONV bool Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ /* PERL_CALLCONV SV ** -Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval); */ +Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV HE * -Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash); */ +Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV STRLEN Perl_hv_fill(pTHX_ HV * const hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_FILL \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void -Perl_hv_free_ent(pTHX_ HV *notused, HE *entry); +Perl_hv_free_ent(pTHX_ HV *notused, HE *entry) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_HV_FREE_ENT \ assert(!notused || SvTYPE(notused) == SVt_PVHV) PERL_CALLCONV I32 Perl_hv_iterinit(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_ITERINIT \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV char * Perl_hv_iterkey(pTHX_ HE *entry, I32 *retlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -1910,6 +2188,7 @@ Perl_hv_iterkey(pTHX_ HE *entry, I32 *retlen) PERL_CALLCONV SV * Perl_hv_iterkeysv(pTHX_ HE *entry) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERKEYSV \ @@ -1917,10 +2196,12 @@ Perl_hv_iterkeysv(pTHX_ HE *entry) /* PERL_CALLCONV HE * Perl_hv_iternext(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ PERL_CALLCONV HE * Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERNEXT_FLAGS \ @@ -1928,6 +2209,7 @@ Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags) PERL_CALLCONV SV * Perl_hv_iternextsv(pTHX_ HV *hv, char **key, I32 *retlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -1937,6 +2219,7 @@ Perl_hv_iternextsv(pTHX_ HV *hv, char **key, I32 *retlen) PERL_CALLCONV SV * Perl_hv_iterval(pTHX_ HV *hv, HE *entry) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -1945,21 +2228,25 @@ Perl_hv_iterval(pTHX_ HV *hv, HE *entry) PERL_CALLCONV void Perl_hv_ksplit(pTHX_ HV *hv, IV newmax) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_KSPLIT \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) /* PERL_CALLCONV void -Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how); */ +Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_NAME_SET \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV I32 Perl_hv_placeholders_get(pTHX_ const HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_GET \ @@ -1967,6 +2254,7 @@ Perl_hv_placeholders_get(pTHX_ const HV *hv) PERL_CALLCONV SSize_t * Perl_hv_placeholders_p(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_P \ @@ -1974,12 +2262,14 @@ Perl_hv_placeholders_p(pTHX_ HV *hv) PERL_CALLCONV void Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_SET \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_pushkv(pTHX_ HV *hv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_HV_PUSHKV \ @@ -1987,12 +2277,14 @@ Perl_hv_pushkv(pTHX_ HV *hv, U32 flags) PERL_CALLCONV void Perl_hv_rand_set(pTHX_ HV *hv, U32 new_xhv_rand) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_RAND_SET \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV I32 * Perl_hv_riter_p(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_RITER_P \ @@ -2000,52 +2292,64 @@ Perl_hv_riter_p(pTHX_ HV *hv) PERL_CALLCONV void Perl_hv_riter_set(pTHX_ HV *hv, I32 riter) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_HV_RITER_SET \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV SV * Perl_hv_scalar(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_SCALAR \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) /* PERL_CALLCONV SV ** -Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash); */ +Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV HE * -Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash); */ +Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV SV ** -Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags); */ +Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV SV ** -Perl_hv_stores(pTHX_ HV *hv, const char * const key, SV *val); */ +Perl_hv_stores(pTHX_ HV *hv, const char * const key, SV *val) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV void -Perl_hv_undef(pTHX_ HV *hv); */ +Perl_hv_undef(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void -Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags); +Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_HV_UNDEF_FLAGS \ assert(!hv || SvTYPE(hv) == SVt_PVHV) /* PERL_CALLCONV I32 Perl_ibcmp(pTHX_ const char *a, const char *b, I32 len) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__ __attribute__pure__; */ /* PERL_CALLCONV I32 Perl_ibcmp_locale(pTHX_ const char *a, const char *b, I32 len) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__ __attribute__pure__; */ /* PERL_CALLCONV I32 -Perl_ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ +Perl_ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV STRLEN Perl_infix_plugin_standard(pTHX_ char *operator_ptr, STRLEN operator_len, struct Perl_custom_infix **def) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_INFIX_PLUGIN_STANDARD \ @@ -2053,6 +2357,7 @@ Perl_infix_plugin_standard(pTHX_ char *operator_ptr, STRLEN operator_len, struct PERL_CALLCONV void Perl_init_argv_symbols(pTHX_ int argc, char **argv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS \ @@ -2060,25 +2365,30 @@ Perl_init_argv_symbols(pTHX_ int argc, char **argv) PERL_CALLCONV void Perl_init_constants(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_INIT_CONSTANTS PERL_CALLCONV void Perl_init_dbargs(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_INIT_DBARGS PERL_CALLCONV void Perl_init_debugger(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_INIT_DEBUGGER PERL_CALLCONV int -Perl_init_i18nl10n(pTHX_ int printwarn); +Perl_init_i18nl10n(pTHX_ int printwarn) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_INIT_I18NL10N PERL_CALLCONV void Perl_init_named_cv(pTHX_ CV *cv, OP *nameop) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_INIT_NAMED_CV \ @@ -2086,17 +2396,20 @@ Perl_init_named_cv(pTHX_ CV *cv, OP *nameop) assert(nameop) PERL_CALLCONV void -Perl_init_stacks(pTHX); +Perl_init_stacks(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_INIT_STACKS PERL_CALLCONV void Perl_init_tm(pTHX_ struct tm *ptm) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_INIT_TM \ assert(ptm) PERL_CALLCONV void Perl_init_uniprops(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_INIT_UNIPROPS @@ -2106,7 +2419,8 @@ Perl_instr(const char *big, const char *little) __attribute__pure__; */ PERL_CALLCONV U32 -Perl_intro_my(pTHX); +Perl_intro_my(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_INTRO_MY #define PERL_ARGS_ASSERT_INVERSE_FOLDS_ \ @@ -2114,12 +2428,14 @@ Perl_intro_my(pTHX); PERL_CALLCONV OP * Perl_invert(pTHX_ OP *cmd) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_INVERT PERL_CALLCONV void Perl_invmap_dump(pTHX_ SV *invlist, UV *map) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2128,6 +2444,7 @@ Perl_invmap_dump(pTHX_ SV *invlist, UV *map) PERL_CALLCONV bool Perl_io_close(pTHX_ IO *io, GV *gv, bool is_explicit, bool warn_on_fail) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_IO_CLOSE \ @@ -2141,11 +2458,13 @@ Perl_is_c9strict_utf8_string(const U8 *s, STRLEN len) Perl_is_c9strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ PERL_CALLCONV bool -Perl_is_in_locale_category_(pTHX_ const bool compiling, const int category); +Perl_is_in_locale_category_(pTHX_ const bool compiling, const int category) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_IS_IN_LOCALE_CATEGORY_ PERL_CALLCONV I32 Perl_is_lvalue_sub(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_LVALUE_SUB @@ -2158,16 +2477,19 @@ Perl_is_strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ PERL_CALLCONV bool Perl_is_uni_FOO_(pTHX_ const U8 classnum, const UV c) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UNI_FOO_ PERL_CALLCONV bool Perl_is_uni_perl_idcont_(pTHX_ UV c) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UNI_PERL_IDCONT_ PERL_CALLCONV bool Perl_is_uni_perl_idstart_(pTHX_ UV c) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UNI_PERL_IDSTART_ @@ -2182,6 +2504,7 @@ Perl_is_utf8_FF_helper_(const U8 * const s0, const U8 * const e, const bool requ PERL_CALLCONV Size_t Perl_is_utf8_FOO_(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; @@ -2208,6 +2531,7 @@ Perl_is_utf8_fixed_width_buf_loc_flags(const U8 * const s, STRLEN len, const U8 PERL_CALLCONV Size_t Perl_is_utf8_perl_idcont_(pTHX_ const U8 *p, const U8 * const e) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -2216,6 +2540,7 @@ Perl_is_utf8_perl_idcont_(pTHX_ const U8 *p, const U8 * const e) PERL_CALLCONV Size_t Perl_is_utf8_perl_idstart_(pTHX_ const U8 *p, const U8 * const e) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -2245,6 +2570,7 @@ Perl_isinfnan(NV nv) PERL_CALLCONV bool Perl_isinfnansv(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_ISINFNANSV \ @@ -2252,6 +2578,7 @@ Perl_isinfnansv(pTHX_ SV *sv) PERL_CALLCONV OP * Perl_jmaybe(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_JMAYBE \ @@ -2259,6 +2586,7 @@ Perl_jmaybe(pTHX_ OP *o) PERL_CALLCONV I32 Perl_keyword(pTHX_ const char *name, I32 len, bool all_keywords) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__pure__ @@ -2268,6 +2596,7 @@ Perl_keyword(pTHX_ const char *name, I32 len, bool all_keywords) PERL_CALLCONV int Perl_keyword_plugin_standard(pTHX_ char *keyword_ptr, STRLEN keyword_len, OP **op_ptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_KEYWORD_PLUGIN_STANDARD \ @@ -2275,81 +2604,97 @@ Perl_keyword_plugin_standard(pTHX_ char *keyword_ptr, STRLEN keyword_len, OP **o PERL_CALLCONV void Perl_leave_adjust_stacks(pTHX_ SV **from_sp, SV **to_sp, U8 gimme, int filter) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_LEAVE_ADJUST_STACKS \ assert(from_sp); assert(to_sp) PERL_CALLCONV void -Perl_leave_scope(pTHX_ I32 base); +Perl_leave_scope(pTHX_ I32 base) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_LEAVE_SCOPE PERL_CALLCONV bool -Perl_lex_bufutf8(pTHX); +Perl_lex_bufutf8(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_LEX_BUFUTF8 PERL_CALLCONV void Perl_lex_discard_to(pTHX_ char *ptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_LEX_DISCARD_TO \ assert(ptr) PERL_CALLCONV char * -Perl_lex_grow_linestr(pTHX_ STRLEN len); +Perl_lex_grow_linestr(pTHX_ STRLEN len) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_LEX_GROW_LINESTR PERL_CALLCONV bool -Perl_lex_next_chunk(pTHX_ U32 flags); +Perl_lex_next_chunk(pTHX_ U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_LEX_NEXT_CHUNK PERL_CALLCONV I32 -Perl_lex_peek_unichar(pTHX_ U32 flags); +Perl_lex_peek_unichar(pTHX_ U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_LEX_PEEK_UNICHAR PERL_CALLCONV void -Perl_lex_read_space(pTHX_ U32 flags); +Perl_lex_read_space(pTHX_ U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_LEX_READ_SPACE PERL_CALLCONV void Perl_lex_read_to(pTHX_ char *ptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_LEX_READ_TO \ assert(ptr) PERL_CALLCONV I32 -Perl_lex_read_unichar(pTHX_ U32 flags); +Perl_lex_read_unichar(pTHX_ U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_LEX_READ_UNICHAR PERL_CALLCONV void -Perl_lex_start(pTHX_ SV *line, PerlIO *rsfp, U32 flags); +Perl_lex_start(pTHX_ SV *line, PerlIO *rsfp, U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_LEX_START PERL_CALLCONV void Perl_lex_stuff_pv(pTHX_ const char *pv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_LEX_STUFF_PV \ assert(pv) PERL_CALLCONV void Perl_lex_stuff_pvn(pTHX_ const char *pv, STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_LEX_STUFF_PVN \ assert(pv) PERL_CALLCONV void Perl_lex_stuff_sv(pTHX_ SV *sv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_LEX_STUFF_SV \ assert(sv) PERL_CALLCONV void Perl_lex_unstuff(pTHX_ char *ptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_LEX_UNSTUFF \ assert(ptr) PERL_CALLCONV OP * Perl_list(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_LIST @@ -2358,6 +2703,7 @@ Perl_list(pTHX_ OP *o) PERL_CALLCONV void Perl_load_module(pTHX_ U32 flags, SV *name, SV *ver, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_LOAD_MODULE \ assert(name) @@ -2372,6 +2718,7 @@ Perl_locale_panic(const char *msg, const line_t immediate_caller_line, const cha PERL_CALLCONV OP * Perl_localize(pTHX_ OP *o, I32 lex) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_LOCALIZE \ @@ -2386,6 +2733,7 @@ Perl_long_valid_utf8_to_uv(const U8 * const s, const U8 * const e) PERL_CALLCONV I32 Perl_looks_like_number(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_LOOKS_LIKE_NUMBER \ @@ -2393,6 +2741,7 @@ Perl_looks_like_number(pTHX_ SV * const sv) PERL_CALLCONV int Perl_magic_clear_all_env(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2401,6 +2750,7 @@ Perl_magic_clear_all_env(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_cleararylen_p(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2409,6 +2759,7 @@ Perl_magic_cleararylen_p(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_clearenv(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2417,6 +2768,7 @@ Perl_magic_clearenv(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_clearhint(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2425,6 +2777,7 @@ Perl_magic_clearhint(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_clearhints(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2433,6 +2786,7 @@ Perl_magic_clearhints(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_clearhook(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARHOOK \ @@ -2440,6 +2794,7 @@ Perl_magic_clearhook(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_clearhookall(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARHOOKALL \ @@ -2447,6 +2802,7 @@ Perl_magic_clearhookall(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_clearisa(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARISA \ @@ -2454,6 +2810,7 @@ Perl_magic_clearisa(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_clearpack(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2462,6 +2819,7 @@ Perl_magic_clearpack(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_clearsig(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2470,6 +2828,7 @@ Perl_magic_clearsig(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_copycallchecker(pTHX_ SV *sv, MAGIC *mg, SV *nsv, const char *name, I32 namlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -2478,11 +2837,13 @@ Perl_magic_copycallchecker(pTHX_ SV *sv, MAGIC *mg, SV *nsv, const char *name, I assert(sv); assert(mg); assert(nsv) PERL_CALLCONV void -Perl_magic_dump(pTHX_ const MAGIC *mg); +Perl_magic_dump(pTHX_ const MAGIC *mg) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_MAGIC_DUMP PERL_CALLCONV int Perl_magic_existspack(pTHX_ SV *sv, const MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2491,6 +2852,7 @@ Perl_magic_existspack(pTHX_ SV *sv, const MAGIC *mg) PERL_CALLCONV int Perl_magic_freearylen_p(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2499,6 +2861,7 @@ Perl_magic_freearylen_p(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_freedestruct(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2507,6 +2870,7 @@ Perl_magic_freedestruct(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_freemglob(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2515,6 +2879,7 @@ Perl_magic_freemglob(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_freeovrld(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2523,6 +2888,7 @@ Perl_magic_freeovrld(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_freeutf8(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2531,6 +2897,7 @@ Perl_magic_freeutf8(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_get(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2539,6 +2906,7 @@ Perl_magic_get(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_getarylen(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2547,6 +2915,7 @@ Perl_magic_getarylen(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_getdebugvar(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2555,6 +2924,7 @@ Perl_magic_getdebugvar(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2563,6 +2933,7 @@ Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_getnkeys(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2571,6 +2942,7 @@ Perl_magic_getnkeys(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_getpack(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2579,6 +2951,7 @@ Perl_magic_getpack(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_getpos(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2587,6 +2960,7 @@ Perl_magic_getpos(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_getsig(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2595,6 +2969,7 @@ Perl_magic_getsig(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_getsubstr(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2603,6 +2978,7 @@ Perl_magic_getsubstr(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_gettaint(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2611,6 +2987,7 @@ Perl_magic_gettaint(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_getuvar(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2619,6 +2996,7 @@ Perl_magic_getuvar(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_getvec(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2627,6 +3005,7 @@ Perl_magic_getvec(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2635,6 +3014,7 @@ Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV SV * Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, U32 argc, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -2644,6 +3024,7 @@ Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, U32 argc PERL_CALLCONV int Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -2653,6 +3034,7 @@ Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key) PERL_CALLCONV U32 Perl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2661,6 +3043,7 @@ Perl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2669,6 +3052,7 @@ Perl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV SV * Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2677,6 +3061,7 @@ Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg) PERL_CALLCONV int Perl_magic_set(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2685,6 +3070,7 @@ Perl_magic_set(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_set_all_env(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2693,6 +3079,7 @@ Perl_magic_set_all_env(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setarylen(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2701,6 +3088,7 @@ Perl_magic_setarylen(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setdbline(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2709,6 +3097,7 @@ Perl_magic_setdbline(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setdebugvar(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2717,6 +3106,7 @@ Perl_magic_setdebugvar(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setdefelem(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2725,6 +3115,7 @@ Perl_magic_setdefelem(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setenv(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2733,6 +3124,7 @@ Perl_magic_setenv(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_sethint(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2741,6 +3133,7 @@ Perl_magic_sethint(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_sethook(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETHOOK \ @@ -2748,6 +3141,7 @@ Perl_magic_sethook(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_sethookall(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2756,6 +3150,7 @@ Perl_magic_sethookall(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setisa(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2764,6 +3159,7 @@ Perl_magic_setisa(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setlvref(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2772,6 +3168,7 @@ Perl_magic_setlvref(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setmglob(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2780,6 +3177,7 @@ Perl_magic_setmglob(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setnkeys(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2788,6 +3186,7 @@ Perl_magic_setnkeys(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setnonelem(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2796,6 +3195,7 @@ Perl_magic_setnonelem(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setpack(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2804,6 +3204,7 @@ Perl_magic_setpack(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setpos(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2812,6 +3213,7 @@ Perl_magic_setpos(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setregexp(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2820,6 +3222,7 @@ Perl_magic_setregexp(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setsig(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETSIG \ @@ -2827,6 +3230,7 @@ Perl_magic_setsig(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setsigall(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2835,6 +3239,7 @@ Perl_magic_setsigall(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setsubstr(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2843,6 +3248,7 @@ Perl_magic_setsubstr(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_settaint(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2851,6 +3257,7 @@ Perl_magic_settaint(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setutf8(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2859,6 +3266,7 @@ Perl_magic_setutf8(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setuvar(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2867,6 +3275,7 @@ Perl_magic_setuvar(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setvec(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2875,6 +3284,7 @@ Perl_magic_setvec(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV U32 Perl_magic_sizepack(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2883,6 +3293,7 @@ Perl_magic_sizepack(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_wipepack(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2896,13 +3307,15 @@ Perl_malloc(MEM_SIZE nbytes) #define PERL_ARGS_ASSERT_MALLOC PERL_CALLCONV Stack_off_t * -Perl_markstack_grow(pTHX); +Perl_markstack_grow(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_MARKSTACK_GROW #define PERL_ARGS_ASSERT_MBTOWC_ PERL_CALLCONV SV * Perl_mess(pTHX_ const char *pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_MESS \ @@ -2910,6 +3323,7 @@ Perl_mess(pTHX_ const char *pat, ...) PERL_CALLCONV SV * Perl_mess_sv(pTHX_ SV *basemsg, bool consume) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MESS_SV \ assert(basemsg) @@ -2920,12 +3334,14 @@ Perl_mfree(Malloc_t where); PERL_CALLCONV int Perl_mg_clear(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MG_CLEAR \ assert(sv) PERL_CALLCONV int Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_MG_COPY \ @@ -2946,30 +3362,35 @@ Perl_mg_findext(const SV *sv, int type, const MGVTBL *vtbl) PERL_CALLCONV int Perl_mg_free(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MG_FREE \ assert(sv) PERL_CALLCONV void Perl_mg_free_type(pTHX_ SV *sv, int how) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MG_FREE_TYPE \ assert(sv) PERL_CALLCONV void Perl_mg_freeext(pTHX_ SV *sv, int how, const MGVTBL *vtbl) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MG_FREEEXT \ assert(sv) PERL_CALLCONV int Perl_mg_get(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MG_GET \ assert(sv) PERL_CALLCONV void Perl_mg_localize(pTHX_ SV *sv, SV *nsv, bool setmagic) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -2984,12 +3405,14 @@ Perl_mg_magical(SV *sv) PERL_CALLCONV int Perl_mg_set(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MG_SET \ assert(sv) PERL_CALLCONV I32 Perl_mg_size(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MG_SIZE \ assert(sv) @@ -3002,43 +3425,51 @@ Perl_mini_mktime(struct tm *ptm) PERL_CALLCONV int Perl_mode_from_discipline(pTHX_ const char *s, STRLEN len) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MODE_FROM_DISCIPLINE PERL_CALLCONV void * -Perl_more_bodies(pTHX_ const svtype sv_type); +Perl_more_bodies(pTHX_ const svtype sv_type) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_MORE_BODIES PERL_CALLCONV const char * Perl_moreswitches(pTHX_ const char *s) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MORESWITCHES \ assert(s) PERL_CALLCONV void Perl_mortal_destructor_sv(pTHX_ SV *coderef, SV *args) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MORTAL_DESTRUCTOR_SV \ assert(coderef) PERL_CALLCONV void -Perl_mortal_svfunc_x(pTHX_ SVFUNC_t f, SV *p); +Perl_mortal_svfunc_x(pTHX_ SVFUNC_t f, SV *p) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_MORTAL_SVFUNC_X PERL_CALLCONV const struct mro_alg * Perl_mro_get_from_name(pTHX_ SV *name) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MRO_GET_FROM_NAME \ assert(name) PERL_CALLCONV AV * Perl_mro_get_linear_isa(pTHX_ HV *stash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV SV * Perl_mro_get_private_data(pTHX_ struct mro_meta * const smeta, const struct mro_alg * const which) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_MRO_GET_PRIVATE_DATA \ @@ -3046,6 +3477,7 @@ Perl_mro_get_private_data(pTHX_ struct mro_meta * const smeta, const struct mro_ PERL_CALLCONV void Perl_mro_isa_changed_in(pTHX_ HV *stash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN \ @@ -3053,18 +3485,21 @@ Perl_mro_isa_changed_in(pTHX_ HV *stash) PERL_CALLCONV struct mro_meta * Perl_mro_meta_init(pTHX_ HV *stash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MRO_META_INIT \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void Perl_mro_method_changed_in(pTHX_ HV *stash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash, const GV * const gv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_MRO_PACKAGE_MOVED \ assert(!stash || SvTYPE(stash) == SVt_PVHV); \ @@ -3072,12 +3507,14 @@ Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash, const GV * c PERL_CALLCONV void Perl_mro_register(pTHX_ const struct mro_alg *mro) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MRO_REGISTER \ assert(mro) PERL_CALLCONV void Perl_mro_set_mro(pTHX_ struct mro_meta * const meta, SV * const name) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_MRO_SET_MRO \ @@ -3085,6 +3522,7 @@ Perl_mro_set_mro(pTHX_ struct mro_meta * const meta, SV * const name) PERL_CALLCONV SV * Perl_mro_set_private_data(pTHX_ struct mro_meta * const smeta, const struct mro_alg * const which, SV * const data) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -3100,12 +3538,14 @@ Perl_mro_set_private_data(pTHX_ struct mro_meta * const smeta, const struct mro_ PERL_CALLCONV NV Perl_my_atof(pTHX_ const char *s) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_MY_ATOF \ assert(s) PERL_CALLCONV char * Perl_my_atof2(pTHX_ const char *orig, NV *value) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_MY_ATOF2 \ @@ -3113,6 +3553,7 @@ Perl_my_atof2(pTHX_ const char *orig, NV *value) PERL_CALLCONV char * Perl_my_atof3(pTHX_ const char *orig, NV *value, const STRLEN len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_MY_ATOF3 \ @@ -3120,13 +3561,15 @@ Perl_my_atof3(pTHX_ const char *orig, NV *value, const STRLEN len) PERL_CALLCONV OP * Perl_my_attrs(pTHX_ OP *o, OP *attrs) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MY_ATTRS \ assert(o) PERL_CALLCONV void -Perl_my_clearenv(pTHX); +Perl_my_clearenv(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_MY_CLEARENV PERL_CALLCONV int @@ -3135,16 +3578,19 @@ Perl_my_dirfd(DIR *dir); PERL_CALLCONV_NO_RET void Perl_my_exit(pTHX_ U32 status) + Perl_attribute_nonnull_aTHX_ __attribute__noreturn__; #define PERL_ARGS_ASSERT_MY_EXIT PERL_CALLCONV_NO_RET void Perl_my_failure_exit(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__noreturn__; #define PERL_ARGS_ASSERT_MY_FAILURE_EXIT PERL_CALLCONV I32 -Perl_my_fflush_all(pTHX); +Perl_my_fflush_all(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_MY_FFLUSH_ALL PERL_CALLCONV Pid_t @@ -3152,10 +3598,12 @@ Perl_my_fork(void); #define PERL_ARGS_ASSERT_MY_FORK /* PERL_CALLCONV I32 -Perl_my_lstat(pTHX); */ +Perl_my_lstat(pTHX) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV I32 -Perl_my_lstat_flags(pTHX_ const U32 flags); +Perl_my_lstat_flags(pTHX_ const U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_MY_LSTAT_FLAGS PERL_CALLCONV int @@ -3176,13 +3624,15 @@ Perl_my_mkstemp_cloexec(char *templte) PERL_CALLCONV PerlIO * Perl_my_popen_list(pTHX_ const char *mode, int n, SV **args) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_MY_POPEN_LIST \ assert(mode); assert(args) PERL_CALLCONV void -Perl_my_setenv(pTHX_ const char *nam, const char *val); +Perl_my_setenv(pTHX_ const char *nam, const char *val) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_MY_SETENV PERL_CALLCONV int @@ -3198,14 +3648,17 @@ Perl_my_socketpair(int family, int type, int protocol, int fd[2]); #define PERL_ARGS_ASSERT_MY_SOCKETPAIR /* PERL_CALLCONV I32 -Perl_my_stat(pTHX); */ +Perl_my_stat(pTHX) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV I32 -Perl_my_stat_flags(pTHX_ const U32 flags); +Perl_my_stat_flags(pTHX_ const U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_MY_STAT_FLAGS PERL_CALLCONV const char * Perl_my_strerror(pTHX_ const int errnum, utf8ness_t *utf8ness) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MY_STRERROR \ @@ -3213,6 +3666,7 @@ Perl_my_strerror(pTHX_ const int errnum, utf8ness_t *utf8ness) 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) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__format__(__strftime__,pTHX_1,0); #define PERL_ARGS_ASSERT_MY_STRFTIME \ @@ -3227,6 +3681,7 @@ Perl_my_strtod(const char * const s, char **e) PERL_CALLCONV void Perl_my_unexec(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MY_UNEXEC @@ -3238,25 +3693,30 @@ Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap assert(buffer); assert(format) PERL_CALLCONV OP * -Perl_newANONATTRSUB(pTHX_ I32 floor, OP *proto, OP *attrs, OP *block); +Perl_newANONATTRSUB(pTHX_ I32 floor, OP *proto, OP *attrs, OP *block) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_NEWANONATTRSUB PERL_CALLCONV OP * Perl_newANONHASH(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWANONHASH PERL_CALLCONV OP * Perl_newANONLIST(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWANONLIST PERL_CALLCONV OP * -Perl_newANONSUB(pTHX_ I32 floor, OP *proto, OP *block); +Perl_newANONSUB(pTHX_ I32 floor, OP *proto, OP *block) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_NEWANONSUB PERL_CALLCONV OP * Perl_newARGDEFELEMOP(pTHX_ I32 flags, OP *expr, I32 argindex) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWARGDEFELEMOP \ @@ -3264,22 +3724,27 @@ Perl_newARGDEFELEMOP(pTHX_ I32 flags, OP *expr, I32 argindex) PERL_CALLCONV OP * Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWASSIGNOP /* PERL_CALLCONV CV * -Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); */ +Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV CV * -Perl_newATTRSUB_x(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block, bool o_is_gv); +Perl_newATTRSUB_x(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block, bool o_is_gv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_NEWATTRSUB_X /* PERL_CALLCONV AV * Perl_newAV(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ PERL_CALLCONV OP * Perl_newAVREF(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWAVREF \ @@ -3287,57 +3752,68 @@ Perl_newAVREF(pTHX_ OP *o) /* PERL_CALLCONV AV * Perl_newAV_alloc_x(pTHX_ SSize_t size) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ /* PERL_CALLCONV AV * Perl_newAV_alloc_xz(pTHX_ SSize_t size) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ /* PERL_CALLCONV AV * Perl_newAV_mortal(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ PERL_CALLCONV AV * Perl_newAVav(pTHX_ AV *oav) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWAVAV \ assert(!oav || SvTYPE(oav) == SVt_PVAV) PERL_CALLCONV AV * Perl_newAVhv(pTHX_ HV *ohv) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWAVHV \ assert(!ohv || SvTYPE(ohv) == SVt_PVHV) PERL_CALLCONV OP * Perl_newBINOP(pTHX_ I32 type, I32 flags, OP *first, OP *last) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWBINOP PERL_CALLCONV OP * Perl_newCONDOP(pTHX_ I32 flags, OP *first, OP *trueop, OP *falseop) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWCONDOP \ assert(first) PERL_CALLCONV CV * -Perl_newCONSTSUB(pTHX_ HV *stash, const char *name, SV *sv); +Perl_newCONSTSUB(pTHX_ HV *stash, const char *name, SV *sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_NEWCONSTSUB \ assert(!stash || SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV CV * -Perl_newCONSTSUB_flags(pTHX_ HV *stash, const char *name, STRLEN len, U32 flags, SV *sv); +Perl_newCONSTSUB_flags(pTHX_ HV *stash, const char *name, STRLEN len, U32 flags, SV *sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_NEWCONSTSUB_FLAGS \ assert(!stash || SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV OP * Perl_newCVREF(pTHX_ I32 flags, OP *o) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWCVREF PERL_CALLCONV OP * Perl_newDEFEROP(pTHX_ I32 flags, OP *block) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWDEFEROP \ @@ -3345,15 +3821,18 @@ Perl_newDEFEROP(pTHX_ I32 flags, OP *block) PERL_CALLCONV OP * Perl_newDEFSVOP(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWDEFSVOP PERL_CALLCONV void -Perl_newFORM(pTHX_ I32 floor, OP *o, OP *block); +Perl_newFORM(pTHX_ I32 floor, OP *o, OP *block) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_NEWFORM PERL_CALLCONV OP * Perl_newFOROP(pTHX_ I32 flags, OP *sv, OP *expr, OP *block, OP *cont) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWFOROP \ @@ -3361,6 +3840,7 @@ Perl_newFOROP(pTHX_ I32 flags, OP *sv, OP *expr, OP *block, OP *cont) PERL_CALLCONV OP * Perl_newGIVENOP(pTHX_ OP *cond, OP *block, PADOFFSET defsv_off) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -3369,12 +3849,14 @@ Perl_newGIVENOP(pTHX_ OP *cond, OP *block, PADOFFSET defsv_off) PERL_CALLCONV GP * Perl_newGP(pTHX_ GV * const gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_NEWGP \ assert(gv) PERL_CALLCONV OP * Perl_newGVOP(pTHX_ I32 type, I32 flags, GV *gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWGVOP \ @@ -3382,14 +3864,17 @@ Perl_newGVOP(pTHX_ I32 type, I32 flags, GV *gv) PERL_CALLCONV OP * Perl_newGVREF(pTHX_ I32 type, OP *o) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWGVREF /* PERL_CALLCONV GV * -Perl_newGVgen(pTHX_ const char *pack); */ +Perl_newGVgen(pTHX_ const char *pack) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV GV * Perl_newGVgen_flags(pTHX_ const char *pack, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWGVGEN_FLAGS \ @@ -3397,10 +3882,12 @@ Perl_newGVgen_flags(pTHX_ const char *pack, U32 flags) /* PERL_CALLCONV HV * Perl_newHV(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ PERL_CALLCONV OP * Perl_newHVREF(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWHVREF \ @@ -3408,26 +3895,31 @@ Perl_newHVREF(pTHX_ OP *o) PERL_CALLCONV HV * Perl_newHVhv(pTHX_ HV *ohv) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWHVHV \ assert(!ohv || SvTYPE(ohv) == SVt_PVHV) /* PERL_CALLCONV IO * Perl_newIO(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ PERL_CALLCONV OP * Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP *first, OP *last) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWLISTOP PERL_CALLCONV OP * Perl_newLISTOPn(pTHX_ I32 type, I32 flags, ...) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWLISTOPN PERL_CALLCONV OP * Perl_newLOGOP(pTHX_ I32 optype, I32 flags, OP *first, OP *other) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; @@ -3436,6 +3928,7 @@ Perl_newLOGOP(pTHX_ I32 optype, I32 flags, OP *first, OP *other) PERL_CALLCONV OP * Perl_newLOOPEX(pTHX_ I32 type, OP *label) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWLOOPEX \ @@ -3443,6 +3936,7 @@ Perl_newLOOPEX(pTHX_ I32 type, OP *label) PERL_CALLCONV OP * Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP *expr, OP *block) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWLOOPOP \ @@ -3450,6 +3944,7 @@ Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP *expr, OP *block) PERL_CALLCONV OP * Perl_newMETHOP(pTHX_ I32 type, I32 flags, OP *dynamic_meth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWMETHOP \ @@ -3457,6 +3952,7 @@ Perl_newMETHOP(pTHX_ I32 type, I32 flags, OP *dynamic_meth) PERL_CALLCONV OP * Perl_newMETHOP_named(pTHX_ I32 type, I32 flags, SV * const_meth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWMETHOP_NAMED \ @@ -3464,17 +3960,20 @@ Perl_newMETHOP_named(pTHX_ I32 type, I32 flags, SV * const_meth) PERL_CALLCONV CV * Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_NEWMYSUB \ assert(o) PERL_CALLCONV OP * Perl_newNULLLIST(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWNULLLIST PERL_CALLCONV OP * Perl_newOP(pTHX_ I32 optype, I32 flags) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWOP @@ -3499,22 +3998,26 @@ Perl_newPADNAMEpvn(const char *s, STRLEN len) PERL_CALLCONV OP * Perl_newPMOP(pTHX_ I32 type, I32 flags) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWPMOP PERL_CALLCONV void Perl_newPROG(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_NEWPROG \ assert(o) PERL_CALLCONV OP * Perl_newPVOP(pTHX_ I32 type, I32 flags, char *pv) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWPVOP PERL_CALLCONV OP * Perl_newRANGE(pTHX_ I32 flags, OP *left, OP *right) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; @@ -3523,6 +4026,7 @@ Perl_newRANGE(pTHX_ I32 flags, OP *left, OP *right) PERL_CALLCONV SV * Perl_newRV(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWRV \ @@ -3530,31 +4034,37 @@ Perl_newRV(pTHX_ SV * const sv) PERL_CALLCONV OP * Perl_newSLICEOP(pTHX_ I32 flags, OP *subscript, OP *listop) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSLICEOP PERL_CALLCONV OP * Perl_newSTATEOP(pTHX_ I32 flags, char *label, OP *o) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSTATEOP PERL_CALLCONV CV * Perl_newSTUB(pTHX_ GV *gv, bool fake) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_NEWSTUB \ assert(gv) /* PERL_CALLCONV CV * -Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block); */ +Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV SV * Perl_newSV(pTHX_ const STRLEN len) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSV PERL_CALLCONV OP * Perl_newSVOP(pTHX_ I32 type, I32 flags, SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVOP \ @@ -3562,6 +4072,7 @@ Perl_newSVOP(pTHX_ I32 type, I32 flags, SV *sv) PERL_CALLCONV OP * Perl_newSVREF(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVREF \ @@ -3569,16 +4080,19 @@ Perl_newSVREF(pTHX_ OP *o) PERL_CALLCONV SV * Perl_newSV_false(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSV_FALSE PERL_CALLCONV SV * Perl_newSV_true(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSV_TRUE PERL_CALLCONV SV * Perl_newSVavdefelem(pTHX_ AV *av, SSize_t ix, bool extendible) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -3587,41 +4101,49 @@ Perl_newSVavdefelem(pTHX_ AV *av, SSize_t ix, bool extendible) PERL_CALLCONV SV * Perl_newSVbool(pTHX_ const bool bool_val) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVBOOL PERL_CALLCONV SV * Perl_newSVhek(pTHX_ const HEK * const hek) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVHEK PERL_CALLCONV SV * Perl_newSVhek_mortal(pTHX_ const HEK * const hek) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVHEK_MORTAL PERL_CALLCONV SV * Perl_newSViv(pTHX_ const IV i) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVIV PERL_CALLCONV SV * Perl_newSVnv(pTHX_ const NV n) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVNV PERL_CALLCONV SV * Perl_newSVpv(pTHX_ const char * const s, const STRLEN len) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVPV PERL_CALLCONV SV * Perl_newSVpv_share(pTHX_ const char *s, U32 hash) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVPV_SHARE PERL_CALLCONV SV * Perl_newSVpvf(pTHX_ const char * const pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__format__(__printf__,pTHX_1,pTHX_2); @@ -3630,36 +4152,43 @@ Perl_newSVpvf(pTHX_ const char * const pat, ...) PERL_CALLCONV SV * Perl_newSVpvn(pTHX_ const char * const s, const STRLEN len) + Perl_attribute_nonnull_aTHX_ __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) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVPVN_FLAGS PERL_CALLCONV SV * Perl_newSVpvn_share(pTHX_ const char *s, I32 len, U32 hash) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVPVN_SHARE PERL_CALLCONV SV * Perl_newSVpvz(pTHX_ const STRLEN len) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVPVZ PERL_CALLCONV SV * Perl_newSVrv(pTHX_ SV * const rv, const char * const classname) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_NEWSVRV \ assert(rv) /* PERL_CALLCONV SV * Perl_newSVsv(pTHX_ SV * const old) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ PERL_CALLCONV SV * Perl_newSVsv_flags_NN(pTHX_ SV * const old, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVSV_FLAGS_NN \ @@ -3667,15 +4196,18 @@ Perl_newSVsv_flags_NN(pTHX_ SV * const old, I32 flags) /* PERL_CALLCONV SV * Perl_newSVsv_nomg(pTHX_ SV * const old) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ PERL_CALLCONV SV * Perl_newSVuv(pTHX_ const UV u) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVUV PERL_CALLCONV OP * Perl_newTRYCATCHOP(pTHX_ I32 flags, OP *tryblock, OP *catchvar, OP *catchblock) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) @@ -3685,16 +4217,19 @@ Perl_newTRYCATCHOP(pTHX_ I32 flags, OP *tryblock, OP *catchvar, OP *catchblock) PERL_CALLCONV OP * Perl_newUNOP(pTHX_ I32 type, I32 flags, OP *first) + Perl_attribute_nonnull_aTHX_ __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) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWUNOP_AUX PERL_CALLCONV OP * Perl_newWHENOP(pTHX_ OP *cond, OP *block) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWWHENOP \ @@ -3702,11 +4237,13 @@ 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) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWWHILEOP PERL_CALLCONV CV * Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_NEWXS \ @@ -3714,6 +4251,7 @@ Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename) PERL_CALLCONV CV * Perl_newXS_deffile(pTHX_ const char *name, XSUBADDR_t subaddr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_NEWXS_DEFFILE \ @@ -3721,6 +4259,7 @@ Perl_newXS_deffile(pTHX_ const char *name, XSUBADDR_t subaddr) PERL_CALLCONV CV * Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr, const char * const filename, const char * const proto, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_NEWXS_FLAGS \ @@ -3728,6 +4267,7 @@ Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr, const char * const PERL_CALLCONV CV * Perl_newXS_len_flags(pTHX_ const char *name, STRLEN len, XSUBADDR_t subaddr, const char * const filename, const char * const proto, SV ** const_svp, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_NEWXS_LEN_FLAGS \ @@ -3735,16 +4275,19 @@ Perl_newXS_len_flags(pTHX_ const char *name, STRLEN len, XSUBADDR_t subaddr, con PERL_CALLCONV PERL_SI * Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEW_STACKINFO PERL_CALLCONV PERL_SI * Perl_new_stackinfo_flags(pTHX_ I32 stitems, I32 cxitems, UV flags) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEW_STACKINFO_FLAGS PERL_CALLCONV SV * Perl_new_version(pTHX_ SV *ver) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_NEW_VERSION \ assert(ver) @@ -3754,6 +4297,7 @@ Perl_new_version(pTHX_ SV *ver) PERL_CALLCONV PerlIO * Perl_nextargv(pTHX_ GV *gv, bool nomagicopen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_NEXTARGV \ @@ -3772,6 +4316,7 @@ Perl_ninstr(const char *big, const char *bigend, const char *little, const char PERL_CALLCONV void Perl_no_bareword_filehandle(pTHX_ const char *fhname) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_NO_BAREWORD_FILEHANDLE \ @@ -3790,16 +4335,19 @@ Perl_noshutdownhook(void); #define PERL_ARGS_ASSERT_NOSHUTDOWNHOOK PERL_CALLCONV int -Perl_nothreadhook(pTHX); +Perl_nothreadhook(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_NOTHREADHOOK PERL_CALLCONV void Perl_notify_parser_that_encoding_changed(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_NOTIFY_PARSER_THAT_ENCODING_CHANGED PERL_CALLCONV OP * Perl_oopsAV(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -3808,6 +4356,7 @@ Perl_oopsAV(pTHX_ OP *o) PERL_CALLCONV OP * Perl_oopsHV(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -3815,15 +4364,18 @@ Perl_oopsHV(pTHX_ OP *o) assert(o) PERL_CALLCONV OP * -Perl_op_append_elem(pTHX_ I32 optype, OP *first, OP *last); +Perl_op_append_elem(pTHX_ I32 optype, OP *first, OP *last) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_OP_APPEND_ELEM PERL_CALLCONV OP * -Perl_op_append_list(pTHX_ I32 optype, OP *first, OP *last); +Perl_op_append_list(pTHX_ I32 optype, OP *first, OP *last) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_OP_APPEND_LIST PERL_CALLCONV OPclass -Perl_op_class(pTHX_ const OP *o); +Perl_op_class(pTHX_ const OP *o) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_OP_CLASS #define PERL_ARGS_ASSERT_OP_CLEAR \ @@ -3831,44 +4383,53 @@ Perl_op_class(pTHX_ const OP *o); PERL_CALLCONV OP * Perl_op_contextualize(pTHX_ OP *o, I32 context) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_OP_CONTEXTUALIZE \ assert(o) PERL_CALLCONV OP * Perl_op_convert_list(pTHX_ I32 optype, I32 flags, OP *o) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_OP_CONVERT_LIST PERL_CALLCONV void Perl_op_dump(pTHX_ const OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_OP_DUMP \ assert(o) PERL_CALLCONV OP * -Perl_op_force_list(pTHX_ OP *o); +Perl_op_force_list(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_OP_FORCE_LIST PERL_CALLCONV void -Perl_op_free(pTHX_ OP *arg); +Perl_op_free(pTHX_ OP *arg) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_OP_FREE PERL_CALLCONV OP * Perl_op_linklist(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_OP_LINKLIST \ assert(o) /* PERL_CALLCONV OP * -Perl_op_lvalue(pTHX_ OP *o, I32 type); */ +Perl_op_lvalue(pTHX_ OP *o, I32 type) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV OP * -Perl_op_lvalue_flags(pTHX_ OP *o, I32 type, U32 flags); +Perl_op_lvalue_flags(pTHX_ OP *o, I32 type, U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_OP_LVALUE_FLAGS PERL_CALLCONV void Perl_op_null(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_OP_NULL \ assert(o) @@ -3880,32 +4441,39 @@ Perl_op_parent(OP *o) assert(o) PERL_CALLCONV OP * -Perl_op_prepend_elem(pTHX_ I32 optype, OP *first, OP *last); +Perl_op_prepend_elem(pTHX_ I32 optype, OP *first, OP *last) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_OP_PREPEND_ELEM PERL_CALLCONV void -Perl_op_refcnt_lock(pTHX); +Perl_op_refcnt_lock(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_OP_REFCNT_LOCK PERL_CALLCONV void -Perl_op_refcnt_unlock(pTHX); +Perl_op_refcnt_unlock(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_OP_REFCNT_UNLOCK PERL_CALLCONV OP * -Perl_op_scope(pTHX_ OP *o); +Perl_op_scope(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_OP_SCOPE PERL_CALLCONV OP * -Perl_op_sibling_splice(pTHX_ OP *parent, OP *start, int del_count, OP *insert); +Perl_op_sibling_splice(pTHX_ OP *parent, OP *start, int del_count, OP *insert) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_OP_SIBLING_SPLICE PERL_CALLCONV OP * Perl_op_unscope(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_OP_UNSCOPE PERL_CALLCONV OP * Perl_op_wrap_finally(pTHX_ OP *block, OP *finally) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -3914,6 +4482,7 @@ Perl_op_wrap_finally(pTHX_ OP *block, OP *finally) PERL_CALLCONV void Perl_opdump_printf(pTHX_ struct Perl_OpDumpContext *ctx, const char *pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); @@ -3922,6 +4491,7 @@ Perl_opdump_printf(pTHX_ struct Perl_OpDumpContext *ctx, const char *pat, ...) PERL_CALLCONV void Perl_package(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PACKAGE \ @@ -3929,6 +4499,7 @@ Perl_package(pTHX_ OP *o) PERL_CALLCONV void Perl_package_version(pTHX_ OP *v) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PACKAGE_VERSION \ @@ -3936,6 +4507,7 @@ Perl_package_version(pTHX_ OP *v) PERL_CALLCONV void Perl_packlist(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -3947,6 +4519,7 @@ Perl_packlist(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, PERL_CALLCONV PADOFFSET Perl_pad_add_anon(pTHX_ CV *func, I32 optype) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_ADD_ANON \ assert(func); \ @@ -3954,6 +4527,7 @@ Perl_pad_add_anon(pTHX_ CV *func, I32 optype) PERL_CALLCONV PADOFFSET Perl_pad_add_name_pv(pTHX_ const char *name, const U32 flags, HV *typestash, HV *ourstash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PV \ assert(name); assert(!typestash || SvTYPE(typestash) == SVt_PVHV); \ @@ -3961,6 +4535,7 @@ Perl_pad_add_name_pv(pTHX_ const char *name, const U32 flags, HV *typestash, HV PERL_CALLCONV PADOFFSET Perl_pad_add_name_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags, HV *typestash, HV *ourstash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PVN \ assert(namepv); assert(!typestash || SvTYPE(typestash) == SVt_PVHV); \ @@ -3968,6 +4543,7 @@ Perl_pad_add_name_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags, HV *t PERL_CALLCONV PADOFFSET Perl_pad_add_name_sv(pTHX_ SV *name, U32 flags, HV *typestash, HV *ourstash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_ADD_NAME_SV \ assert(name); assert(!typestash || SvTYPE(typestash) == SVt_PVHV); \ @@ -3975,6 +4551,7 @@ Perl_pad_add_name_sv(pTHX_ SV *name, U32 flags, HV *typestash, HV *ourstash) PERL_CALLCONV void Perl_pad_add_weakref(pTHX_ CV *func) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PAD_ADD_WEAKREF \ @@ -3982,34 +4559,40 @@ Perl_pad_add_weakref(pTHX_ CV *func) assert(SvTYPE(func) == SVt_PVCV || SvTYPE(func) == SVt_PVFM) PERL_CALLCONV PADOFFSET -Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype); +Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PAD_ALLOC PERL_CALLCONV void Perl_pad_block_start(pTHX_ int full) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PAD_BLOCK_START PERL_CALLCONV PADOFFSET Perl_pad_findmy_pv(pTHX_ const char *name, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_FINDMY_PV \ assert(name) PERL_CALLCONV PADOFFSET Perl_pad_findmy_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_FINDMY_PVN \ assert(namepv) PERL_CALLCONV PADOFFSET Perl_pad_findmy_sv(pTHX_ SV *name, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_FINDMY_SV \ assert(name) PERL_CALLCONV void Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -4022,36 +4605,43 @@ Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv) PERL_CALLCONV void Perl_pad_free(pTHX_ PADOFFSET po) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PAD_FREE PERL_CALLCONV OP * Perl_pad_leavemy(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PAD_LEAVEMY PERL_CALLCONV PADLIST * Perl_pad_new(pTHX_ int flags) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_PAD_NEW PERL_CALLCONV void Perl_pad_push(pTHX_ PADLIST *padlist, int depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PAD_PUSH \ assert(padlist) PERL_CALLCONV void Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PAD_SWIPE PERL_CALLCONV void -Perl_pad_tidy(pTHX_ padtidy_type type); +Perl_pad_tidy(pTHX_ padtidy_type type) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PAD_TIDY PERL_CALLCONV PAD ** Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PADLIST_STORE \ @@ -4059,6 +4649,7 @@ Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val) PERL_CALLCONV void Perl_padname_free(pTHX_ PADNAME *pn) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PADNAME_FREE \ assert(pn) @@ -4072,58 +4663,71 @@ Perl_padnamelist_fetch(PADNAMELIST *pnl, SSize_t key) PERL_CALLCONV void Perl_padnamelist_free(pTHX_ PADNAMELIST *pnl) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PADNAMELIST_FREE \ assert(pnl) PERL_CALLCONV PADNAME ** Perl_padnamelist_store(pTHX_ PADNAMELIST *pnl, SSize_t key, PADNAME *val) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PADNAMELIST_STORE \ assert(pnl) PERL_CALLCONV OP * -Perl_parse_arithexpr(pTHX_ U32 flags); +Perl_parse_arithexpr(pTHX_ U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PARSE_ARITHEXPR PERL_CALLCONV OP * -Perl_parse_barestmt(pTHX_ U32 flags); +Perl_parse_barestmt(pTHX_ U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PARSE_BARESTMT PERL_CALLCONV OP * -Perl_parse_block(pTHX_ U32 flags); +Perl_parse_block(pTHX_ U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PARSE_BLOCK PERL_CALLCONV OP * -Perl_parse_fullexpr(pTHX_ U32 flags); +Perl_parse_fullexpr(pTHX_ U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PARSE_FULLEXPR PERL_CALLCONV OP * -Perl_parse_fullstmt(pTHX_ U32 flags); +Perl_parse_fullstmt(pTHX_ U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PARSE_FULLSTMT PERL_CALLCONV SV * -Perl_parse_label(pTHX_ U32 flags); +Perl_parse_label(pTHX_ U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PARSE_LABEL PERL_CALLCONV OP * -Perl_parse_listexpr(pTHX_ U32 flags); +Perl_parse_listexpr(pTHX_ U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PARSE_LISTEXPR PERL_CALLCONV OP * -Perl_parse_stmtseq(pTHX_ U32 flags); +Perl_parse_stmtseq(pTHX_ U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PARSE_STMTSEQ PERL_CALLCONV OP * -Perl_parse_subsignature(pTHX_ U32 flags); +Perl_parse_subsignature(pTHX_ U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PARSE_SUBSIGNATURE PERL_CALLCONV OP * -Perl_parse_termexpr(pTHX_ U32 flags); +Perl_parse_termexpr(pTHX_ U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PARSE_TERMEXPR PERL_CALLCONV U32 Perl_parse_unicode_opts(pTHX_ const char **popt) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PARSE_UNICODE_OPTS \ @@ -4131,6 +4735,7 @@ Perl_parse_unicode_opts(pTHX_ const char **popt) PERL_CALLCONV void Perl_parser_free(pTHX_ const yy_parser *parser) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PARSER_FREE \ @@ -4138,6 +4743,7 @@ Perl_parser_free(pTHX_ const yy_parser *parser) PERL_CALLCONV void Perl_peep(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PEEP @@ -4180,14 +4786,17 @@ Perl_perly_sighandler(int sig, Siginfo_t *info, void *uap, bool safe); #define PERL_ARGS_ASSERT_PERLY_SIGHANDLER /* PERL_CALLCONV const char * const -Perl_phase_name(pTHX_ enum perl_phase); */ +Perl_phase_name(pTHX_ enum perl_phase) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void -Perl_pmop_dump(pTHX_ PMOP *pm); +Perl_pmop_dump(pTHX_ PMOP *pm) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PMOP_DUMP PERL_CALLCONV OP * Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl, UV flags, I32 floor) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -4195,11 +4804,13 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl, UV flags, I32 floor) assert(o); assert(expr) PERL_CALLCONV void -Perl_pop_scope(pTHX); +Perl_pop_scope(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_POP_SCOPE PERL_CALLCONV void Perl_populate_isa(pTHX_ const char *name, STRLEN len, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_POPULATE_ISA \ @@ -4207,12 +4818,14 @@ Perl_populate_isa(pTHX_ const char *name, STRLEN len, ...) PERL_CALLCONV REGEXP * Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PREGCOMP \ assert(pattern) PERL_CALLCONV I32 Perl_pregexec(pTHX_ REGEXP * const prog, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *screamer, U32 nosave) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -4223,56 +4836,66 @@ Perl_pregexec(pTHX_ REGEXP * const prog, char *stringarg, char *strend, char *st assert(screamer) PERL_CALLCONV void -Perl_pregfree(pTHX_ REGEXP *r); +Perl_pregfree(pTHX_ REGEXP *r) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PREGFREE PERL_CALLCONV void Perl_pregfree2(pTHX_ REGEXP *rx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PREGFREE2 \ assert(rx) PERL_CALLCONV const char * Perl_prescan_version(pTHX_ const char *s, bool strict, const char **errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PRESCAN_VERSION \ assert(s) PERL_CALLCONV void * Perl_ptr_table_fetch(pTHX_ PTR_TBL_t * const tbl, const void * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_PTR_TABLE_FETCH \ assert(tbl) PERL_CALLCONV void -Perl_ptr_table_free(pTHX_ PTR_TBL_t * const tbl); +Perl_ptr_table_free(pTHX_ PTR_TBL_t * const tbl) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PTR_TABLE_FREE PERL_CALLCONV PTR_TBL_t * Perl_ptr_table_new(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_PTR_TABLE_NEW PERL_CALLCONV void Perl_ptr_table_split(pTHX_ PTR_TBL_t * const tbl) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_PTR_TABLE_SPLIT \ assert(tbl) PERL_CALLCONV void Perl_ptr_table_store(pTHX_ PTR_TBL_t * const tbl, const void * const oldsv, void * const newsv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_PTR_TABLE_STORE \ assert(tbl); assert(newsv) PERL_CALLCONV void -Perl_push_scope(pTHX); +Perl_push_scope(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_PUSH_SCOPE PERL_CALLCONV char * Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_PV_DISPLAY \ @@ -4280,12 +4903,14 @@ Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pv PERL_CALLCONV char * Perl_pv_escape(pTHX_ SV *dsv, char const * const str, const STRLEN count, STRLEN max, STRLEN * const escaped, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_PV_ESCAPE \ assert(str) PERL_CALLCONV char * Perl_pv_pretty(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_PV_PRETTY \ @@ -4293,6 +4918,7 @@ Perl_pv_pretty(pTHX_ SV *dsv, char const * const str, const STRLEN count, const PERL_CALLCONV char * Perl_pv_uni_display(pTHX_ SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_PV_UNI_DISPLAY \ @@ -4301,27 +4927,32 @@ Perl_pv_uni_display(pTHX_ SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV f #define PERL_ARGS_ASSERT_QERROR PERL_CALLCONV char * -Perl_rcpv_copy(pTHX_ char * const pv); +Perl_rcpv_copy(pTHX_ char * const pv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_RCPV_COPY PERL_CALLCONV char * -Perl_rcpv_free(pTHX_ char * const pv); +Perl_rcpv_free(pTHX_ char * const pv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_RCPV_FREE PERL_CALLCONV char * Perl_rcpv_new(pTHX_ const char * const pv, STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ __attribute__malloc__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_RCPV_NEW PERL_CALLCONV REGEXP * Perl_re_compile(pTHX_ SV * const pattern, U32 orig_rx_flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_RE_COMPILE \ assert(pattern) PERL_CALLCONV char * Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV *sv, const char * const strbeg, char *strpos, char *strend, const U32 flags, re_scream_pos_data *data) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) @@ -4331,12 +4962,14 @@ Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV *sv, const char * const strbeg, PERL_CALLCONV SV * Perl_re_intuit_string(pTHX_ REGEXP * const r) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_RE_INTUIT_STRING \ assert(r) PERL_CALLCONV REGEXP * Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, OP *expr, const regexp_engine *eng, REGEXP *old_re, bool *is_bare_re, const U32 rx_flags, const U32 pm_flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_4); #define PERL_ARGS_ASSERT_RE_OP_COMPILE \ assert(eng) @@ -4347,11 +4980,13 @@ Perl_realloc(Malloc_t where, MEM_SIZE nbytes) #define PERL_ARGS_ASSERT_REALLOC PERL_CALLCONV void -Perl_reentrant_free(pTHX); +Perl_reentrant_free(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_REENTRANT_FREE PERL_CALLCONV void -Perl_reentrant_init(pTHX); +Perl_reentrant_init(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_REENTRANT_INIT PERL_CALLCONV void * @@ -4361,53 +4996,63 @@ Perl_reentrant_retry(const char *f, ...) assert(f) PERL_CALLCONV void -Perl_reentrant_size(pTHX); +Perl_reentrant_size(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_REENTRANT_SIZE PERL_CALLCONV HV * -Perl_refcounted_he_chain_2hv(pTHX_ const struct refcounted_he *c, U32 flags); +Perl_refcounted_he_chain_2hv(pTHX_ const struct refcounted_he *c, U32 flags) + Perl_attribute_nonnull_aTHX_; #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) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PV \ assert(key) PERL_CALLCONV SV * Perl_refcounted_he_fetch_pvn(pTHX_ const struct refcounted_he *chain, const char *keypv, STRLEN keylen, U32 hash, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PVN \ assert(keypv) PERL_CALLCONV SV * Perl_refcounted_he_fetch_sv(pTHX_ const struct refcounted_he *chain, SV *key, U32 hash, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_SV \ assert(key) PERL_CALLCONV void -Perl_refcounted_he_free(pTHX_ struct refcounted_he *he); +Perl_refcounted_he_free(pTHX_ struct refcounted_he *he) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FREE PERL_CALLCONV struct refcounted_he * -Perl_refcounted_he_inc(pTHX_ struct refcounted_he *he); +Perl_refcounted_he_inc(pTHX_ struct refcounted_he *he) + Perl_attribute_nonnull_aTHX_; #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) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PV \ assert(key) PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_pvn(pTHX_ struct refcounted_he *parent, const char *keypv, STRLEN keylen, U32 hash, SV *value, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PVN \ assert(keypv) PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_sv(pTHX_ struct refcounted_he *parent, SV *key, U32 hash, SV *value, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_SV \ assert(key) @@ -4417,12 +5062,14 @@ Perl_refcounted_he_new_sv(pTHX_ struct refcounted_he *parent, SV *key, U32 hash, PERL_CALLCONV SV * Perl_reg_named_buff_all(pTHX_ REGEXP * const rx, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ALL \ assert(rx) PERL_CALLCONV bool Perl_reg_named_buff_exists(pTHX_ REGEXP * const rx, SV * const key, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_EXISTS \ @@ -4430,6 +5077,7 @@ Perl_reg_named_buff_exists(pTHX_ REGEXP * const rx, SV * const key, const U32 fl PERL_CALLCONV SV * Perl_reg_named_buff_fetch(pTHX_ REGEXP * const rx, SV * const namesv, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FETCH \ @@ -4437,6 +5085,7 @@ Perl_reg_named_buff_fetch(pTHX_ REGEXP * const rx, SV * const namesv, const U32 PERL_CALLCONV SV * Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const rx, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FIRSTKEY \ assert(rx) @@ -4446,12 +5095,14 @@ Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const rx, const U32 flags) PERL_CALLCONV SV * Perl_reg_named_buff_nextkey(pTHX_ REGEXP * const rx, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_NEXTKEY \ assert(rx) PERL_CALLCONV SV * Perl_reg_named_buff_scalar(pTHX_ REGEXP * const rx, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_SCALAR \ assert(rx) @@ -4476,12 +5127,14 @@ Perl_reg_named_buff_scalar(pTHX_ REGEXP * const rx, const U32 flags) PERL_CALLCONV void Perl_regdump(pTHX_ const regexp *r) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_REGDUMP \ assert(r) PERL_CALLCONV I32 Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *sv, void *data, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -4493,16 +5146,19 @@ Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, char *strend, char PERL_CALLCONV void Perl_regfree_internal(pTHX_ REGEXP * const rx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_REGFREE_INTERNAL \ assert(rx) PERL_CALLCONV void -Perl_reginitcolors(pTHX); +Perl_reginitcolors(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_REGINITCOLORS PERL_CALLCONV void Perl_release_RExC_state(pTHX_ void *vstate) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_RELEASE_REXC_STATE \ @@ -4517,6 +5173,7 @@ Perl_repeatcpy(char *to, const char *from, SSize_t len, IV count) PERL_CALLCONV void Perl_report_evil_fh(pTHX_ const GV *gv) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_REPORT_EVIL_FH @@ -4524,26 +5181,31 @@ Perl_report_evil_fh(pTHX_ const GV *gv) PERL_CALLCONV void Perl_report_wrongway_fh(pTHX_ const GV *gv, const char have) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_REPORT_WRONGWAY_FH PERL_CALLCONV void Perl_require_pv(pTHX_ const char *pv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_REQUIRE_PV \ assert(pv) PERL_CALLCONV void Perl_resume_compcv(pTHX_ struct suspended_compcv *buffer, bool save) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_RESUME_COMPCV \ assert(buffer) /* PERL_CALLCONV void -Perl_resume_compcv_and_save(pTHX_ struct suspended_compcv *buffer); */ +Perl_resume_compcv_and_save(pTHX_ struct suspended_compcv *buffer) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV void -Perl_resume_compcv_final(pTHX_ struct suspended_compcv *buffer); */ +Perl_resume_compcv_final(pTHX_ struct suspended_compcv *buffer) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV char * Perl_rninstr(const char *big, const char *bigend, const char *little, const char *lend) @@ -4558,56 +5220,67 @@ Perl_rninstr(const char *big, const char *bigend, const char *little, const char PERL_CALLCONV void Perl_rpeep(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_RPEEP PERL_CALLCONV void Perl_rpp_free_2_(pTHX_ SV * const sv1, SV * const sv2, const U32 rc1, const U32 rc2) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_RPP_FREE_2_ \ assert(sv1); assert(sv2) PERL_CALLCONV void -Perl_rpp_obliterate_stack_to(pTHX_ I32 ix); +Perl_rpp_obliterate_stack_to(pTHX_ I32 ix) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_RPP_OBLITERATE_STACK_TO PERL_CALLCONV Sighandler_t -Perl_rsignal(pTHX_ int i, Sighandler_t t); +Perl_rsignal(pTHX_ int i, Sighandler_t t) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_RSIGNAL PERL_CALLCONV int Perl_rsignal_restore(pTHX_ int i, Sigsave_t *t) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_RSIGNAL_RESTORE PERL_CALLCONV int Perl_rsignal_save(pTHX_ int i, Sighandler_t t1, Sigsave_t *save) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_RSIGNAL_SAVE \ assert(save) PERL_CALLCONV Sighandler_t -Perl_rsignal_state(pTHX_ int i); +Perl_rsignal_state(pTHX_ int i) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_RSIGNAL_STATE PERL_CALLCONV int -Perl_runops_debug(pTHX); +Perl_runops_debug(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_RUNOPS_DEBUG PERL_CALLCONV int -Perl_runops_standard(pTHX); +Perl_runops_standard(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_RUNOPS_STANDARD PERL_CALLCONV CV * Perl_rv2cv_op_cv(pTHX_ OP *cvop, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_RV2CV_OP_CV \ assert(cvop) PERL_CALLCONV void Perl_rxres_save(pTHX_ void **rsp, REGEXP *rx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -4637,68 +5310,80 @@ Perl_safesysrealloc(Malloc_t where, MEM_SIZE nbytes) PERL_CALLCONV void Perl_save_I16(pTHX_ I16 *intp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_I16 \ assert(intp) PERL_CALLCONV void Perl_save_I32(pTHX_ I32 *intp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_I32 \ assert(intp) PERL_CALLCONV void Perl_save_I8(pTHX_ I8 *bytep) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_I8 \ assert(bytep) PERL_CALLCONV void Perl_save_adelete(pTHX_ AV *av, SSize_t key) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_ADELETE \ assert(av); assert(SvTYPE(av) == SVt_PVAV) /* PERL_CALLCONV void -Perl_save_aelem(pTHX_ AV *av, SSize_t idx, SV **sptr); */ +Perl_save_aelem(pTHX_ AV *av, SSize_t idx, SV **sptr) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_save_aelem_flags(pTHX_ AV *av, SSize_t idx, SV **sptr, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS \ assert(av); assert(SvTYPE(av) == SVt_PVAV); assert(sptr) PERL_CALLCONV SSize_t -Perl_save_alloc(pTHX_ SSize_t size, I32 pad); +Perl_save_alloc(pTHX_ SSize_t size, I32 pad) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SAVE_ALLOC PERL_CALLCONV void Perl_save_aptr(pTHX_ AV **aptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_APTR \ assert(aptr) PERL_CALLCONV AV * Perl_save_ary(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_ARY \ assert(gv) PERL_CALLCONV void Perl_save_bool(pTHX_ bool *boolp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_BOOL \ assert(boolp) PERL_CALLCONV void Perl_save_clearsv(pTHX_ SV **svp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_CLEARSV \ assert(svp) PERL_CALLCONV void Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SAVE_DELETE \ @@ -4706,65 +5391,78 @@ Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen) PERL_CALLCONV void Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void *p) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR \ assert(p) PERL_CALLCONV void -Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void *p); +Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void *p) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR_X /* PERL_CALLCONV void -Perl_save_freeop(pTHX_ OP *o); */ +Perl_save_freeop(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV void -Perl_save_freepv(pTHX_ char *pv); */ +Perl_save_freepv(pTHX_ char *pv) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_save_freercpv(pTHX_ char *rcpv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_FREERCPV \ assert(rcpv) /* PERL_CALLCONV void -Perl_save_freesv(pTHX_ SV *sv); */ +Perl_save_freesv(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_save_generic_pvref(pTHX_ char **str) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF \ assert(str) PERL_CALLCONV void Perl_save_generic_svref(pTHX_ SV **sptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_GENERIC_SVREF \ assert(sptr) PERL_CALLCONV void Perl_save_gp(pTHX_ GV *gv, I32 empty) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_GP \ assert(gv) PERL_CALLCONV HV * Perl_save_hash(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_HASH \ assert(gv) PERL_CALLCONV void Perl_save_hdelete(pTHX_ HV *hv, SV *keysv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SAVE_HDELETE \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(keysv) /* PERL_CALLCONV void -Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr); */ +Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -4772,121 +5470,144 @@ Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags) assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(key); assert(sptr) PERL_CALLCONV void -Perl_save_hints(pTHX); +Perl_save_hints(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SAVE_HINTS PERL_CALLCONV void Perl_save_hptr(pTHX_ HV **hptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_HPTR \ assert(hptr) PERL_CALLCONV void Perl_save_int(pTHX_ int *intp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_INT \ assert(intp) PERL_CALLCONV void Perl_save_item(pTHX_ SV *item) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_ITEM \ assert(item) PERL_CALLCONV void Perl_save_iv(pTHX_ IV *ivp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_IV \ assert(ivp) /* PERL_CALLCONV void -Perl_save_mortalizesv(pTHX_ SV *sv); */ +Perl_save_mortalizesv(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV void -Perl_save_op(pTHX); */ +Perl_save_op(pTHX) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void -Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off); +Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SAVE_PADSV_AND_MORTALIZE PERL_CALLCONV void Perl_save_pptr(pTHX_ char **pptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_PPTR \ assert(pptr) PERL_CALLCONV void -Perl_save_pushi32ptr(pTHX_ const I32 i, void * const ptr, const int type); +Perl_save_pushi32ptr(pTHX_ const I32 i, void * const ptr, const int type) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SAVE_PUSHI32PTR PERL_CALLCONV void -Perl_save_pushptr(pTHX_ void * const ptr, const int type); +Perl_save_pushptr(pTHX_ void * const ptr, const int type) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SAVE_PUSHPTR PERL_CALLCONV void -Perl_save_pushptrptr(pTHX_ void * const ptr1, void * const ptr2, const int type); +Perl_save_pushptrptr(pTHX_ void * const ptr1, void * const ptr2, const int type) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SAVE_PUSHPTRPTR PERL_CALLCONV void Perl_save_rcpv(pTHX_ char **prcpv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_RCPV \ assert(prcpv) PERL_CALLCONV void -Perl_save_re_context(pTHX); +Perl_save_re_context(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SAVE_RE_CONTEXT PERL_CALLCONV SV * Perl_save_scalar(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SCALAR \ assert(gv) PERL_CALLCONV void Perl_save_set_svflags(pTHX_ SV *sv, U32 mask, U32 val) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SET_SVFLAGS \ assert(sv) PERL_CALLCONV void Perl_save_shared_pvref(pTHX_ char **str) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SHARED_PVREF \ assert(str) PERL_CALLCONV void Perl_save_sptr(pTHX_ SV **sptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SPTR \ assert(sptr) PERL_CALLCONV void Perl_save_strlen(pTHX_ STRLEN *ptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_STRLEN \ assert(ptr) PERL_CALLCONV SV * Perl_save_svref(pTHX_ SV **sptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SVREF \ assert(sptr) PERL_CALLCONV void Perl_save_vptr(pTHX_ void *ptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_VPTR \ assert(ptr) PERL_CALLCONV char * Perl_savesharedpv(pTHX_ const char *pv) + Perl_attribute_nonnull_aTHX_ __attribute__malloc__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SAVESHAREDPV PERL_CALLCONV char * Perl_savesharedpvn(pTHX_ const char * const pv, const STRLEN len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__malloc__ __attribute__warn_unused_result__; @@ -4894,29 +5615,35 @@ Perl_savesharedpvn(pTHX_ const char * const pv, const STRLEN len) assert(pv) PERL_CALLCONV void -Perl_savestack_grow(pTHX); +Perl_savestack_grow(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SAVESTACK_GROW PERL_CALLCONV void -Perl_savestack_grow_cnt(pTHX_ I32 need); +Perl_savestack_grow_cnt(pTHX_ I32 need) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SAVESTACK_GROW_CNT PERL_CALLCONV void -Perl_savetmps(pTHX); +Perl_savetmps(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SAVETMPS PERL_CALLCONV OP * Perl_sawparens(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SAWPARENS PERL_CALLCONV OP * Perl_scalar(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SCALAR PERL_CALLCONV OP * Perl_scalarvoid(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SCALARVOID \ @@ -4924,6 +5651,7 @@ Perl_scalarvoid(pTHX_ OP *o) PERL_CALLCONV NV Perl_scan_bin(pTHX_ const char *start, STRLEN len, STRLEN *retlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SCAN_BIN \ @@ -4931,6 +5659,7 @@ Perl_scan_bin(pTHX_ const char *start, STRLEN len, STRLEN *retlen) PERL_CALLCONV NV Perl_scan_hex(pTHX_ const char *start, STRLEN len, STRLEN *retlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SCAN_HEX \ @@ -4938,6 +5667,7 @@ Perl_scan_hex(pTHX_ const char *start, STRLEN len, STRLEN *retlen) PERL_CALLCONV char * Perl_scan_num(pTHX_ const char *s, YYSTYPE *lvalp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SCAN_NUM \ @@ -4945,6 +5675,7 @@ Perl_scan_num(pTHX_ const char *s, YYSTYPE *lvalp) PERL_CALLCONV NV Perl_scan_oct(pTHX_ const char *start, STRLEN len, STRLEN *retlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SCAN_OCT \ @@ -4955,6 +5686,7 @@ Perl_scan_oct(pTHX_ const char *start, STRLEN len, STRLEN *retlen) PERL_CALLCONV const char * Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SCAN_VERSION \ @@ -4962,6 +5694,7 @@ Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv) PERL_CALLCONV char * Perl_scan_vstring(pTHX_ const char *s, const char * const e, SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -4972,11 +5705,13 @@ Perl_scan_vstring(pTHX_ const char *s, const char * const e, SV *sv) assert(s); assert(dest); assert(slp) PERL_CALLCONV U32 -Perl_seed(pTHX); +Perl_seed(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SEED PERL_CALLCONV void -Perl_set_caret_X(pTHX); +Perl_set_caret_X(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SET_CARET_X PERL_CALLCONV void @@ -4987,18 +5722,21 @@ Perl_set_context(void *t) PERL_CALLCONV void Perl_set_numeric_standard(pTHX_ const char *file, const line_t caller_line) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SET_NUMERIC_STANDARD \ assert(file) PERL_CALLCONV void Perl_set_numeric_underlying(pTHX_ const char *file, const line_t caller_line) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SET_NUMERIC_UNDERLYING \ assert(file) PERL_CALLCONV void Perl_setdefout(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SETDEFOUT \ assert(gv) @@ -5010,11 +5748,13 @@ Perl_setfd_cloexec(int fd) PERL_CALLCONV void Perl_setfd_cloexec_for_nonsysfd(pTHX_ int fd) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SETFD_CLOEXEC_FOR_NONSYSFD PERL_CALLCONV void Perl_setfd_cloexec_or_inhexec_by_sysfdness(pTHX_ int fd) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SETFD_CLOEXEC_OR_INHEXEC_BY_SYSFDNESS @@ -5025,11 +5765,13 @@ Perl_setfd_inhexec(int fd) PERL_CALLCONV void Perl_setfd_inhexec_for_sysfd(pTHX_ int fd) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SETFD_INHEXEC_FOR_SYSFD PERL_CALLCONV HEK * Perl_share_hek(pTHX_ const char *str, SSize_t len, U32 hash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SHARE_HEK \ assert(str) @@ -5049,18 +5791,21 @@ Perl_sighandler3(int sig, Siginfo_t *info, void *uap) PERL_CALLCONV void Perl_sortsv(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SORTSV \ assert(cmp) PERL_CALLCONV void Perl_sortsv_flags(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SORTSV_FLAGS \ assert(cmp) PERL_CALLCONV SV ** Perl_stack_grow(pTHX_ SV **sp, SV **p, SSize_t n) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_STACK_GROW \ @@ -5068,6 +5813,7 @@ Perl_stack_grow(pTHX_ SV **sp, SV **p, SSize_t n) PERL_CALLCONV PerlIO * Perl_start_glob(pTHX_ SV *tmpglob, IO *io) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -5075,11 +5821,13 @@ Perl_start_glob(pTHX_ SV *tmpglob, IO *io) assert(tmpglob); assert(io) PERL_CALLCONV I32 -Perl_start_subparse(pTHX_ I32 is_format, U32 flags); +Perl_start_subparse(pTHX_ I32 is_format, U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_START_SUBPARSE PERL_CALLCONV NV Perl_str_to_version(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_STR_TO_VERSION \ @@ -5090,6 +5838,7 @@ Perl_strict_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t PERL_CALLCONV void Perl_sub_crush_depth(pTHX_ CV *cv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SUB_CRUSH_DEPTH \ @@ -5097,6 +5846,7 @@ Perl_sub_crush_depth(pTHX_ CV *cv) PERL_CALLCONV void Perl_subsignature_append_fence_op(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SUBSIGNATURE_APPEND_FENCE_OP \ @@ -5104,41 +5854,49 @@ Perl_subsignature_append_fence_op(pTHX_ OP *o) PERL_CALLCONV void Perl_subsignature_append_positional(pTHX_ PADOFFSET padix, OPCODE defmode, OP *defexpr) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SUBSIGNATURE_APPEND_POSITIONAL PERL_CALLCONV void Perl_subsignature_append_slurpy(pTHX_ I32 sigil, PADOFFSET padix) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SUBSIGNATURE_APPEND_SLURPY PERL_CALLCONV OP * Perl_subsignature_finish(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SUBSIGNATURE_FINISH PERL_CALLCONV void Perl_subsignature_start(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SUBSIGNATURE_START PERL_CALLCONV void Perl_suspend_compcv(pTHX_ struct suspended_compcv *buffer) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SUSPEND_COMPCV \ assert(buffer) /* PERL_CALLCONV bool -Perl_sv_2bool(pTHX_ SV * const sv); */ +Perl_sv_2bool(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV bool Perl_sv_2bool_flags(pTHX_ SV *sv, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2BOOL_FLAGS \ assert(sv) PERL_CALLCONV CV * Perl_sv_2cv(pTHX_ SV *sv, HV ** const st, GV ** const gvp, const I32 lref) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SV_2CV \ @@ -5146,25 +5904,30 @@ Perl_sv_2cv(pTHX_ SV *sv, HV ** const st, GV ** const gvp, const I32 lref) PERL_CALLCONV IO * Perl_sv_2io(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2IO \ assert(sv) /* PERL_CALLCONV IV -Perl_sv_2iv(pTHX_ SV *sv); */ +Perl_sv_2iv(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV IV Perl_sv_2iv_flags(pTHX_ SV * const sv, const I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2IV_FLAGS \ assert(sv) PERL_CALLCONV SV * -Perl_sv_2mortal(pTHX_ SV * const sv); +Perl_sv_2mortal(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_2MORTAL PERL_CALLCONV SV * Perl_sv_2num(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SV_2NUM \ @@ -5172,54 +5935,66 @@ Perl_sv_2num(pTHX_ SV * const sv) PERL_CALLCONV NV Perl_sv_2nv_flags(pTHX_ SV * const sv, const I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2NV_FLAGS \ assert(sv) /* PERL_CALLCONV char * -Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp); */ +Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV char * Perl_sv_2pv_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2PV_FLAGS \ assert(sv) /* PERL_CALLCONV char * Perl_sv_2pv_nolen(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ /* PERL_CALLCONV char * -Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN * const lp); */ +Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN * const lp) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV char * Perl_sv_2pvbyte_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2PVBYTE_FLAGS \ assert(sv) /* PERL_CALLCONV char * Perl_sv_2pvbyte_nolen(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ /* PERL_CALLCONV char * -Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN * const lp); */ +Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN * const lp) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV char * Perl_sv_2pvutf8_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2PVUTF8_FLAGS \ assert(sv) /* PERL_CALLCONV char * Perl_sv_2pvutf8_nolen(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ /* PERL_CALLCONV UV -Perl_sv_2uv(pTHX_ SV *sv); */ +Perl_sv_2uv(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV UV Perl_sv_2uv_flags(pTHX_ SV * const sv, const I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_2UV_FLAGS \ assert(sv) @@ -5232,6 +6007,7 @@ Perl_sv_backoff(SV * const sv) PERL_CALLCONV SV * Perl_sv_bless(pTHX_ SV * const sv, HV * const stash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_BLESS \ @@ -5239,12 +6015,14 @@ Perl_sv_bless(pTHX_ SV * const sv, HV * const stash) PERL_CALLCONV bool Perl_sv_can_swipe_pv_buf(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_CAN_SWIPE_PV_BUF \ assert(sv) PERL_CALLCONV bool Perl_sv_cat_decode(pTHX_ SV *dsv, SV *encoding, SV *ssv, int *offset, char *tstr, int tlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -5255,12 +6033,14 @@ Perl_sv_cat_decode(pTHX_ SV *dsv, SV *encoding, SV *ssv, int *offset, char *tstr PERL_CALLCONV void Perl_sv_catpv(pTHX_ SV * const dsv, const char *sstr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_CATPV \ assert(dsv) PERL_CALLCONV void Perl_sv_catpv_flags(pTHX_ SV * const dsv, const char *sstr, const I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_CATPV_FLAGS \ @@ -5268,12 +6048,14 @@ Perl_sv_catpv_flags(pTHX_ SV * const dsv, const char *sstr, const I32 flags) PERL_CALLCONV void Perl_sv_catpv_mg(pTHX_ SV * const dsv, const char * const sstr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_CATPV_MG \ assert(dsv) PERL_CALLCONV void Perl_sv_catpvf(pTHX_ SV * const sv, const char * const pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); @@ -5282,6 +6064,7 @@ Perl_sv_catpvf(pTHX_ SV * const sv, const char * const pat, ...) PERL_CALLCONV void Perl_sv_catpvf_mg(pTHX_ SV * const sv, const char * const pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); @@ -5289,91 +6072,111 @@ Perl_sv_catpvf_mg(pTHX_ SV * const sv, const char * const pat, ...) assert(sv); assert(pat) /* PERL_CALLCONV void -Perl_sv_catpvn(pTHX_ SV * const dsv, const char *sstr, STRLEN len); */ +Perl_sv_catpvn(pTHX_ SV * const dsv, const char *sstr, STRLEN len) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_sv_catpvn_flags(pTHX_ SV * const dsv, const char *sstr, const STRLEN len, const I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_CATPVN_FLAGS \ assert(dsv); assert(sstr) /* PERL_CALLCONV void -Perl_sv_catpvn_mg(pTHX_ SV * const dsv, const char *sstr, STRLEN len); */ +Perl_sv_catpvn_mg(pTHX_ SV * const dsv, const char *sstr, STRLEN len) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV void -Perl_sv_catsv(pTHX_ SV * const dsv, SV * const sstr); */ +Perl_sv_catsv(pTHX_ SV * const dsv, SV * const sstr) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_sv_catsv_flags(pTHX_ SV * const dsv, SV * const sstr, const I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_CATSV_FLAGS \ assert(dsv) /* PERL_CALLCONV void -Perl_sv_catsv_mg(pTHX_ SV * const dsv, SV * const sstr); */ +Perl_sv_catsv_mg(pTHX_ SV * const dsv, SV * const sstr) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_sv_chop(pTHX_ SV * const sv, const char * const ptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_CHOP \ assert(sv) PERL_CALLCONV SSize_t Perl_sv_clean_all(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SV_CLEAN_ALL PERL_CALLCONV void Perl_sv_clean_objs(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SV_CLEAN_OBJS PERL_CALLCONV void Perl_sv_clear(pTHX_ SV * const orig_sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_CLEAR \ assert(orig_sv) PERL_CALLCONV I32 -Perl_sv_cmp(pTHX_ SV * const sv1, SV * const sv2); +Perl_sv_cmp(pTHX_ SV * const sv1, SV * const sv2) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_CMP PERL_CALLCONV I32 -Perl_sv_cmp_flags(pTHX_ SV * const sv1, SV * const sv2, const U32 flags); +Perl_sv_cmp_flags(pTHX_ SV * const sv1, SV * const sv2, const U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_CMP_FLAGS PERL_CALLCONV I32 -Perl_sv_cmp_locale(pTHX_ SV * const sv1, SV * const sv2); +Perl_sv_cmp_locale(pTHX_ SV * const sv1, SV * const sv2) + Perl_attribute_nonnull_aTHX_; #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); +Perl_sv_cmp_locale_flags(pTHX_ SV * const sv1, SV * const sv2, const U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_CMP_LOCALE_FLAGS /* PERL_CALLCONV void -Perl_sv_copypv(pTHX_ SV * const dsv, SV * const ssv); */ +Perl_sv_copypv(pTHX_ SV * const dsv, SV * const ssv) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_sv_copypv_flags(pTHX_ SV * const dsv, SV * const ssv, const I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #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_sv_copypv_nomg(pTHX_ SV * const dsv, SV * const ssv) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void -Perl_sv_dec(pTHX_ SV * const sv); +Perl_sv_dec(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_DEC PERL_CALLCONV void -Perl_sv_dec_nomg(pTHX_ SV * const sv); +Perl_sv_dec_nomg(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_DEC_NOMG PERL_CALLCONV void Perl_sv_del_backref(pTHX_ SV * const tsv, SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_DEL_BACKREF \ @@ -5381,6 +6184,7 @@ Perl_sv_del_backref(pTHX_ SV * const tsv, SV * const sv) PERL_CALLCONV bool Perl_sv_derived_from(pTHX_ SV *sv, const char * const name) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -5389,6 +6193,7 @@ Perl_sv_derived_from(pTHX_ SV *sv, const char * const name) PERL_CALLCONV bool Perl_sv_derived_from_hv(pTHX_ SV *sv, HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -5397,6 +6202,7 @@ Perl_sv_derived_from_hv(pTHX_ SV *sv, HV *hv) PERL_CALLCONV bool Perl_sv_derived_from_pv(pTHX_ SV *sv, const char * const name, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -5405,6 +6211,7 @@ Perl_sv_derived_from_pv(pTHX_ SV *sv, const char * const name, U32 flags) PERL_CALLCONV bool Perl_sv_derived_from_pvn(pTHX_ SV *sv, const char * const name, const STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -5413,6 +6220,7 @@ Perl_sv_derived_from_pvn(pTHX_ SV *sv, const char * const name, const STRLEN len PERL_CALLCONV bool Perl_sv_derived_from_sv(pTHX_ SV *sv, SV *namesv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -5420,11 +6228,13 @@ 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); +Perl_sv_destroyable(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_DESTROYABLE PERL_CALLCONV bool Perl_sv_does(pTHX_ SV *sv, const char * const name) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -5433,6 +6243,7 @@ Perl_sv_does(pTHX_ SV *sv, const char * const name) PERL_CALLCONV bool Perl_sv_does_pv(pTHX_ SV *sv, const char * const name, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -5441,6 +6252,7 @@ Perl_sv_does_pv(pTHX_ SV *sv, const char * const name, U32 flags) PERL_CALLCONV bool Perl_sv_does_pvn(pTHX_ SV *sv, const char * const name, const STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -5449,6 +6261,7 @@ Perl_sv_does_pvn(pTHX_ SV *sv, const char * const name, const STRLEN len, U32 fl PERL_CALLCONV bool Perl_sv_does_sv(pTHX_ SV *sv, SV *namesv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -5456,41 +6269,50 @@ Perl_sv_does_sv(pTHX_ SV *sv, SV *namesv, U32 flags) assert(sv); assert(namesv) PERL_CALLCONV void -Perl_sv_dump(pTHX_ SV *sv); +Perl_sv_dump(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_DUMP PERL_CALLCONV void -Perl_sv_dump_depth(pTHX_ SV *sv, I32 depth); +Perl_sv_dump_depth(pTHX_ SV *sv, I32 depth) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_DUMP_DEPTH /* PERL_CALLCONV I32 -Perl_sv_eq(pTHX_ SV *sv1, SV *sv2); */ +Perl_sv_eq(pTHX_ SV *sv1, SV *sv2) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV I32 -Perl_sv_eq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags); +Perl_sv_eq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_EQ_FLAGS /* PERL_CALLCONV void -Perl_sv_force_normal(pTHX_ SV *sv); */ +Perl_sv_force_normal(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_sv_force_normal_flags(pTHX_ SV * const sv, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS \ assert(sv) PERL_CALLCONV void -Perl_sv_free(pTHX_ SV * const sv); +Perl_sv_free(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_FREE PERL_CALLCONV void Perl_sv_free2(pTHX_ SV * const sv, const U32 refcnt) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_FREE2 \ assert(sv) PERL_CALLCONV void Perl_sv_free_arenas(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SV_FREE_ARENAS @@ -5502,6 +6324,7 @@ Perl_sv_get_backrefs(SV * const sv) PERL_CALLCONV char * Perl_sv_gets(pTHX_ SV * const sv, PerlIO * const fp, SSize_t append) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_GETS \ @@ -5509,29 +6332,35 @@ Perl_sv_gets(pTHX_ SV * const sv, PerlIO * const fp, SSize_t append) PERL_CALLCONV char * Perl_sv_grow(pTHX_ SV * const sv, STRLEN newlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_GROW \ assert(sv) PERL_CALLCONV char * Perl_sv_grow_fresh(pTHX_ SV * const sv, STRLEN newlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_GROW_FRESH \ assert(sv) PERL_CALLCONV void -Perl_sv_inc(pTHX_ SV * const sv); +Perl_sv_inc(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_INC PERL_CALLCONV void -Perl_sv_inc_nomg(pTHX_ SV * const sv); +Perl_sv_inc_nomg(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_INC_NOMG /* PERL_CALLCONV void -Perl_sv_insert(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char * const little, const STRLEN littlelen); */ +Perl_sv_insert(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char * const little, const STRLEN littlelen) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_sv_insert_flags(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char *little, const STRLEN littlelen, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_4); #define PERL_ARGS_ASSERT_SV_INSERT_FLAGS \ @@ -5539,12 +6368,14 @@ Perl_sv_insert_flags(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN PERL_CALLCONV int Perl_sv_isa(pTHX_ SV *sv, const char * const name) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_ISA \ assert(name) PERL_CALLCONV bool Perl_sv_isa_sv(pTHX_ SV *sv, SV *namesv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -5552,35 +6383,42 @@ Perl_sv_isa_sv(pTHX_ SV *sv, SV *namesv) assert(sv); assert(namesv) PERL_CALLCONV int -Perl_sv_isobject(pTHX_ SV *sv); +Perl_sv_isobject(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_ISOBJECT PERL_CALLCONV SV * -Perl_sv_langinfo(pTHX_ const nl_item item); +Perl_sv_langinfo(pTHX_ const nl_item item) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_LANGINFO PERL_CALLCONV STRLEN -Perl_sv_len(pTHX_ SV * const sv); +Perl_sv_len(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_LEN PERL_CALLCONV STRLEN -Perl_sv_len_utf8(pTHX_ SV * const sv); +Perl_sv_len_utf8(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_LEN_UTF8 PERL_CALLCONV STRLEN Perl_sv_len_utf8_nomg(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_LEN_UTF8_NOMG \ assert(sv) PERL_CALLCONV void Perl_sv_magic(pTHX_ SV * const sv, SV * const obj, const int how, const char * const name, const I32 namlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_MAGIC \ assert(sv) PERL_CALLCONV MAGIC * Perl_sv_magicext(pTHX_ SV * const sv, SV * const obj, const int how, const MGVTBL * const vtbl, const char * const name, const I32 namlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_MAGICEXT \ assert(sv) @@ -5590,96 +6428,116 @@ Perl_sv_magicext(pTHX_ SV * const sv, SV * const obj, const int how, const MGVTB /* PERL_CALLCONV SV * Perl_sv_mortalcopy(pTHX_ SV * const oldsv) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ PERL_CALLCONV SV * Perl_sv_mortalcopy_flags(pTHX_ SV * const oldsv, U32 flags) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_MORTALCOPY_FLAGS PERL_CALLCONV SV * Perl_sv_newmortal(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_NEWMORTAL PERL_CALLCONV SV * -Perl_sv_newref(pTHX_ SV * const sv); +Perl_sv_newref(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_NEWREF PERL_CALLCONV void -Perl_sv_nosharing(pTHX_ SV *sv); +Perl_sv_nosharing(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_NOSHARING /* PERL_CALLCONV bool -Perl_sv_numeq(pTHX_ SV *sv1, SV *sv2); */ +Perl_sv_numeq(pTHX_ SV *sv1, SV *sv2) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV bool -Perl_sv_numeq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags); +Perl_sv_numeq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_NUMEQ_FLAGS PERL_CALLCONV char * -Perl_sv_peek(pTHX_ SV *sv); +Perl_sv_peek(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_PEEK PERL_CALLCONV void Perl_sv_pos_b2u(pTHX_ SV * const sv, I32 * const offsetp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_POS_B2U \ assert(offsetp) PERL_CALLCONV STRLEN Perl_sv_pos_b2u_flags(pTHX_ SV * const sv, STRLEN const offset, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_POS_B2U_FLAGS \ assert(sv) PERL_CALLCONV void Perl_sv_pos_u2b(pTHX_ SV * const sv, I32 * const offsetp, I32 * const lenp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_POS_U2B \ assert(offsetp) PERL_CALLCONV STRLEN Perl_sv_pos_u2b_flags(pTHX_ SV * const sv, STRLEN uoffset, STRLEN * const lenp, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_POS_U2B_FLAGS \ assert(sv) /* PERL_CALLCONV char * Perl_sv_pv(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ /* PERL_CALLCONV char * Perl_sv_pvbyte(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ PERL_CALLCONV char * Perl_sv_pvbyten_force(pTHX_ SV * const sv, STRLEN * const lp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE \ assert(sv) /* PERL_CALLCONV char * -Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp); */ +Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV char * Perl_sv_pvn_force_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS \ assert(sv) /* PERL_CALLCONV char * Perl_sv_pvutf8(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; */ PERL_CALLCONV char * Perl_sv_pvutf8n_force(pTHX_ SV * const sv, STRLEN * const lp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE \ assert(sv) PERL_CALLCONV char * Perl_sv_recode_to_utf8(pTHX_ SV *sv, SV *encoding) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_RECODE_TO_UTF8 \ @@ -5687,12 +6545,14 @@ Perl_sv_recode_to_utf8(pTHX_ SV *sv, SV *encoding) PERL_CALLCONV SV * Perl_sv_ref(pTHX_ SV *dst, const SV * const sv, const int ob) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_REF \ assert(sv) PERL_CALLCONV const char * Perl_sv_reftype(pTHX_ const SV * const sv, const int ob) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_REFTYPE \ @@ -5700,12 +6560,14 @@ Perl_sv_reftype(pTHX_ const SV * const sv, const int ob) PERL_CALLCONV void Perl_sv_regex_global_pos_clear(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_REGEX_GLOBAL_POS_CLEAR \ assert(sv) PERL_CALLCONV bool Perl_sv_regex_global_pos_get(pTHX_ SV *sv, STRLEN *posp, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -5714,118 +6576,138 @@ Perl_sv_regex_global_pos_get(pTHX_ SV *sv, STRLEN *posp, U32 flags) PERL_CALLCONV void Perl_sv_regex_global_pos_set(pTHX_ SV *sv, STRLEN pos, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_REGEX_GLOBAL_POS_SET \ assert(sv) PERL_CALLCONV void Perl_sv_replace(pTHX_ SV * const sv, SV * const nsv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_REPLACE \ assert(sv); assert(nsv) PERL_CALLCONV void -Perl_sv_report_used(pTHX); +Perl_sv_report_used(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_REPORT_USED PERL_CALLCONV void Perl_sv_reset(pTHX_ const char *s, HV * const stash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_RESET \ assert(s); assert(!stash || SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void Perl_sv_resetpvn(pTHX_ const char *s, STRLEN len, HV * const stash) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SV_RESETPVN PERL_CALLCONV SV * Perl_sv_rvunweaken(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_RVUNWEAKEN \ assert(sv) PERL_CALLCONV SV * Perl_sv_rvweaken(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_RVWEAKEN \ assert(sv) PERL_CALLCONV void Perl_sv_set_bool(pTHX_ SV *sv, const bool bool_val) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SET_BOOL \ assert(sv) PERL_CALLCONV void Perl_sv_set_false(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SET_FALSE \ assert(sv) PERL_CALLCONV void Perl_sv_set_true(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SET_TRUE \ assert(sv) PERL_CALLCONV void Perl_sv_set_undef(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SET_UNDEF \ assert(sv) PERL_CALLCONV void Perl_sv_sethek(pTHX_ SV * const sv, const HEK * const hek) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETHEK \ assert(sv) PERL_CALLCONV void Perl_sv_setiv(pTHX_ SV * const sv, const IV num) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETIV \ assert(sv) PERL_CALLCONV void Perl_sv_setiv_mg(pTHX_ SV * const sv, const IV i) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETIV_MG \ assert(sv) PERL_CALLCONV void Perl_sv_setnv(pTHX_ SV * const sv, const NV num) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETNV \ assert(sv) PERL_CALLCONV void Perl_sv_setnv_mg(pTHX_ SV * const sv, const NV num) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETNV_MG \ assert(sv) PERL_CALLCONV void Perl_sv_setpv(pTHX_ SV * const sv, const char * const ptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETPV \ assert(sv) PERL_CALLCONV char * Perl_sv_setpv_bufsize(pTHX_ SV * const sv, const STRLEN cur, const STRLEN len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETPV_BUFSIZE \ assert(sv) PERL_CALLCONV void Perl_sv_setpv_mg(pTHX_ SV * const sv, const char * const ptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETPV_MG \ assert(sv) PERL_CALLCONV void Perl_sv_setpvf(pTHX_ SV * const sv, const char * const pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); @@ -5834,6 +6716,7 @@ Perl_sv_setpvf(pTHX_ SV * const sv, const char * const pat, ...) PERL_CALLCONV void Perl_sv_setpvf_mg(pTHX_ SV * const sv, const char * const pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); @@ -5842,18 +6725,21 @@ Perl_sv_setpvf_mg(pTHX_ SV * const sv, const char * const pat, ...) PERL_CALLCONV void Perl_sv_setpvn(pTHX_ SV * const sv, const char * const ptr, const STRLEN len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETPVN \ assert(sv) PERL_CALLCONV void Perl_sv_setpvn_fresh(pTHX_ SV * const sv, const char * const ptr, const STRLEN len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETPVN_FRESH \ assert(sv) PERL_CALLCONV void Perl_sv_setpvn_mg(pTHX_ SV * const sv, const char * const ptr, const STRLEN len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_SETPVN_MG \ @@ -5861,24 +6747,28 @@ Perl_sv_setpvn_mg(pTHX_ SV * const sv, const char * const ptr, const STRLEN len) PERL_CALLCONV SV * Perl_sv_setref_iv(pTHX_ SV * const rv, const char * const classname, const IV iv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETREF_IV \ assert(rv) PERL_CALLCONV SV * Perl_sv_setref_nv(pTHX_ SV * const rv, const char * const classname, const NV nv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETREF_NV \ assert(rv) PERL_CALLCONV SV * Perl_sv_setref_pv(pTHX_ SV * const rv, const char * const classname, void * const pv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETREF_PV \ assert(rv) PERL_CALLCONV SV * Perl_sv_setref_pvn(pTHX_ SV * const rv, const char * const classname, const char * const pv, const STRLEN n) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_SV_SETREF_PVN \ @@ -5886,12 +6776,14 @@ Perl_sv_setref_pvn(pTHX_ SV * const rv, const char * const classname, const char PERL_CALLCONV SV * Perl_sv_setref_uv(pTHX_ SV * const rv, const char * const classname, const UV uv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETREF_UV \ assert(rv) PERL_CALLCONV void Perl_sv_setrv_inc(pTHX_ SV * const sv, SV * const ref) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_SETRV_INC \ @@ -5899,6 +6791,7 @@ Perl_sv_setrv_inc(pTHX_ SV * const sv, SV * const ref) PERL_CALLCONV void Perl_sv_setrv_inc_mg(pTHX_ SV * const sv, SV * const ref) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_SETRV_INC_MG \ @@ -5906,6 +6799,7 @@ Perl_sv_setrv_inc_mg(pTHX_ SV * const sv, SV * const ref) PERL_CALLCONV void Perl_sv_setrv_noinc(pTHX_ SV * const sv, SV * const ref) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_SETRV_NOINC \ @@ -5913,78 +6807,93 @@ Perl_sv_setrv_noinc(pTHX_ SV * const sv, SV * const ref) PERL_CALLCONV void Perl_sv_setrv_noinc_mg(pTHX_ SV * const sv, SV * const ref) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_SETRV_NOINC_MG \ assert(sv); assert(ref) /* PERL_CALLCONV void -Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv); */ +Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_sv_setsv_flags(pTHX_ SV *dsv, SV *ssv, const I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETSV_FLAGS \ assert(dsv) PERL_CALLCONV void Perl_sv_setsv_mg(pTHX_ SV * const dsv, SV * const ssv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETSV_MG \ assert(dsv) PERL_CALLCONV void Perl_sv_setuv(pTHX_ SV * const sv, const UV num) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETUV \ assert(sv) PERL_CALLCONV void Perl_sv_setuv_mg(pTHX_ SV * const sv, const UV u) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETUV_MG \ assert(sv) /* PERL_CALLCONV bool -Perl_sv_streq(pTHX_ SV *sv1, SV *sv2); */ +Perl_sv_streq(pTHX_ SV *sv1, SV *sv2) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV bool -Perl_sv_streq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags); +Perl_sv_streq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_STREQ_FLAGS PERL_CALLCONV SV * Perl_sv_strftime_ints(pTHX_ SV *fmt, int sec, int min, int hour, int mday, int mon, int year, int isdst) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_STRFTIME_INTS \ assert(fmt) PERL_CALLCONV SV * Perl_sv_strftime_tm(pTHX_ SV *fmt, const struct tm *mytm) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_STRFTIME_TM \ assert(fmt); assert(mytm) PERL_CALLCONV SV * -Perl_sv_string_from_errnum(pTHX_ int errnum, SV *tgtsv); +Perl_sv_string_from_errnum(pTHX_ int errnum, SV *tgtsv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_STRING_FROM_ERRNUM /* PERL_CALLCONV void -Perl_sv_taint(pTHX_ SV *sv); */ +Perl_sv_taint(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV bool Perl_sv_tainted(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_TAINTED \ assert(sv) PERL_CALLCONV I32 -Perl_sv_true(pTHX_ SV * const sv); +Perl_sv_true(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SV_TRUE PERL_CALLCONV char * Perl_sv_uni_display(pTHX_ SV *dsv, SV *ssv, STRLEN pvlim, UV flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -5993,90 +6902,109 @@ Perl_sv_uni_display(pTHX_ SV *dsv, SV *ssv, STRLEN pvlim, UV flags) PERL_CALLCONV int Perl_sv_unmagic(pTHX_ SV * const sv, const int type) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UNMAGIC \ assert(sv) PERL_CALLCONV int Perl_sv_unmagicext(pTHX_ SV * const sv, const int type, const MGVTBL *vtbl) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UNMAGICEXT \ assert(sv) /* PERL_CALLCONV void -Perl_sv_unref(pTHX_ SV *sv); */ +Perl_sv_unref(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_sv_unref_flags(pTHX_ SV * const ref, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UNREF_FLAGS \ assert(ref) PERL_CALLCONV void Perl_sv_untaint(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UNTAINT \ assert(sv) PERL_CALLCONV void Perl_sv_upgrade(pTHX_ SV * const sv, svtype new_type) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UPGRADE \ assert(sv) /* PERL_CALLCONV void -Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len); */ +Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_sv_usepvn_flags(pTHX_ SV * const sv, char *ptr, const STRLEN len, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_USEPVN_FLAGS \ assert(sv) /* PERL_CALLCONV void -Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len); */ +Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV bool Perl_sv_utf8_decode(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UTF8_DECODE \ assert(sv) /* PERL_CALLCONV bool -Perl_sv_utf8_downgrade(pTHX_ SV * const sv, const bool fail_ok); */ +Perl_sv_utf8_downgrade(pTHX_ SV * const sv, const bool fail_ok) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV bool Perl_sv_utf8_downgrade_flags(pTHX_ SV * const sv, const bool fail_ok, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_FLAGS \ assert(sv) /* PERL_CALLCONV bool -Perl_sv_utf8_downgrade_nomg(pTHX_ SV * const sv, const bool fail_ok); */ +Perl_sv_utf8_downgrade_nomg(pTHX_ SV * const sv, const bool fail_ok) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_sv_utf8_encode(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UTF8_ENCODE \ assert(sv) /* PERL_CALLCONV STRLEN -Perl_sv_utf8_upgrade(pTHX_ SV *sv); */ +Perl_sv_utf8_upgrade(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV STRLEN -Perl_sv_utf8_upgrade_flags(pTHX_ SV * const sv, const I32 flags); */ +Perl_sv_utf8_upgrade_flags(pTHX_ SV * const sv, const I32 flags) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV * const sv, const I32 flags, STRLEN extra) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW \ assert(sv) /* PERL_CALLCONV STRLEN -Perl_sv_utf8_upgrade_nomg(pTHX_ SV *sv); */ +Perl_sv_utf8_upgrade_nomg(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV void Perl_sv_vcatpvf(pTHX_ SV * const sv, const char * const pat, va_list * const args) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_VCATPVF \ @@ -6084,6 +7012,7 @@ Perl_sv_vcatpvf(pTHX_ SV * const sv, const char * const pat, va_list * const arg PERL_CALLCONV void Perl_sv_vcatpvf_mg(pTHX_ SV * const sv, const char * const pat, va_list * const args) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_VCATPVF_MG \ @@ -6091,6 +7020,7 @@ Perl_sv_vcatpvf_mg(pTHX_ SV * const sv, const char * const pat, va_list * const PERL_CALLCONV void Perl_sv_vcatpvfn(pTHX_ SV * const sv, const char * const pat, const STRLEN patlen, va_list * const args, SV ** const svargs, const Size_t sv_count, bool * const maybe_tainted) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_VCATPVFN \ @@ -6098,6 +7028,7 @@ Perl_sv_vcatpvfn(pTHX_ SV * const sv, const char * const pat, const STRLEN patle PERL_CALLCONV void Perl_sv_vcatpvfn_flags(pTHX_ SV * const sv, const char * const pat, const STRLEN patlen, va_list * const args, SV ** const svargs, const Size_t sv_count, bool * const maybe_tainted, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_VCATPVFN_FLAGS \ @@ -6105,6 +7036,7 @@ Perl_sv_vcatpvfn_flags(pTHX_ SV * const sv, const char * const pat, const STRLEN PERL_CALLCONV void Perl_sv_vsetpvf(pTHX_ SV * const sv, const char * const pat, va_list * const args) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_VSETPVF \ @@ -6112,6 +7044,7 @@ Perl_sv_vsetpvf(pTHX_ SV * const sv, const char * const pat, va_list * const arg PERL_CALLCONV void Perl_sv_vsetpvf_mg(pTHX_ SV * const sv, const char * const pat, va_list * const args) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_VSETPVF_MG \ @@ -6119,6 +7052,7 @@ Perl_sv_vsetpvf_mg(pTHX_ SV * const sv, const char * const pat, va_list * const PERL_CALLCONV void Perl_sv_vsetpvfn(pTHX_ SV * const sv, const char * const pat, const STRLEN patlen, va_list * const args, SV ** const svargs, const Size_t sv_count, bool * const maybe_tainted) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_SV_VSETPVFN \ @@ -6126,16 +7060,19 @@ Perl_sv_vsetpvfn(pTHX_ SV * const sv, const char * const pat, const STRLEN patle PERL_CALLCONV const char * Perl_sv_vstring_get(pTHX_ SV * const sv, STRLEN *lenp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_SV_VSTRING_GET \ assert(sv) PERL_CALLCONV void -Perl_switch_to_global_locale(pTHX); +Perl_switch_to_global_locale(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SWITCH_TO_GLOBAL_LOCALE PERL_CALLCONV bool -Perl_sync_locale(pTHX); +Perl_sync_locale(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_SYNC_LOCALE PERL_CALLCONV void @@ -6158,17 +7095,20 @@ Perl_sys_term(void); #define PERL_ARGS_ASSERT_SYS_TERM PERL_CALLCONV void -Perl_taint_env(pTHX); +Perl_taint_env(pTHX) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_TAINT_ENV PERL_CALLCONV void Perl_taint_proper(pTHX_ const char *f, const char * const s) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_TAINT_PROPER \ assert(s) PERL_CALLCONV OP * Perl_tied_method(pTHX_ SV *methname, SV **mark, SV * const sv, const MAGIC * const mg, const U32 flags, U32 argc, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -6178,14 +7118,17 @@ Perl_tied_method(pTHX_ SV *methname, SV **mark, SV * const sv, const MAGIC * con assert(methname); assert(mark); assert(sv); assert(mg) PERL_CALLCONV SSize_t -Perl_tmps_grow_p(pTHX_ SSize_t ix); +Perl_tmps_grow_p(pTHX_ SSize_t ix) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_TMPS_GROW_P /* PERL_CALLCONV UV -Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp); */ +Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV UV Perl_to_uni_fold_flags_(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UNI_FOLD_FLAGS_ \ @@ -6193,6 +7136,7 @@ Perl_to_uni_fold_flags_(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags) PERL_CALLCONV UV Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UNI_LOWER \ @@ -6200,6 +7144,7 @@ Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp) PERL_CALLCONV UV Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UNI_TITLE \ @@ -6207,6 +7152,7 @@ Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp) PERL_CALLCONV UV Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UNI_UPPER \ @@ -6214,6 +7160,7 @@ Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp) PERL_CALLCONV UV Perl_to_utf8_fold_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, U8 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UTF8_FOLD_FLAGS_ \ @@ -6221,6 +7168,7 @@ Perl_to_utf8_fold_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp PERL_CALLCONV UV Perl_to_utf8_lower_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UTF8_LOWER_FLAGS_ \ @@ -6228,6 +7176,7 @@ Perl_to_utf8_lower_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *len PERL_CALLCONV UV Perl_to_utf8_title_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UTF8_TITLE_FLAGS_ \ @@ -6235,17 +7184,20 @@ Perl_to_utf8_title_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *len PERL_CALLCONV UV Perl_to_utf8_upper_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_TO_UTF8_UPPER_FLAGS_ \ assert(p); assert(ustrp) PERL_CALLCONV bool -Perl_try_amagic_bin(pTHX_ int method, int flags); +Perl_try_amagic_bin(pTHX_ int method, int flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_TRY_AMAGIC_BIN PERL_CALLCONV bool -Perl_try_amagic_un(pTHX_ int method, int flags); +Perl_try_amagic_un(pTHX_ int method, int flags) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_TRY_AMAGIC_UN PERL_CALLCONV char * @@ -6258,6 +7210,7 @@ Perl_uiv_2buf(char * const buf, const IV iv, UV uv, const int is_uv, char ** con PERL_CALLCONV SSize_t Perl_unpackstring(pTHX_ const char *pat, const char *patend, const char *s, const char *strend, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -6266,15 +7219,18 @@ Perl_unpackstring(pTHX_ const char *pat, const char *patend, const char *s, cons assert(pat); assert(patend); assert(s); assert(strend) PERL_CALLCONV void -Perl_unshare_hek(pTHX_ HEK *hek); +Perl_unshare_hek(pTHX_ HEK *hek) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_UNSHARE_HEK PERL_CALLCONV void -Perl_unsharepvn(pTHX_ const char *sv, I32 len, U32 hash); +Perl_unsharepvn(pTHX_ const char *sv, I32 len, U32 hash) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_UNSHAREPVN PERL_CALLCONV SV * Perl_upg_version(pTHX_ SV *ver, bool qv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_UPG_VERSION \ assert(ver) @@ -6302,6 +7258,7 @@ Perl_utf8_hop_safe(const U8 *s, SSize_t off, const U8 * const start, const U8 * PERL_CALLCONV STRLEN Perl_utf8_length(pTHX_ const U8 *s0, const U8 *e) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -6310,6 +7267,7 @@ Perl_utf8_length(pTHX_ const U8 *s0, const U8 *e) PERL_CALLCONV U8 * Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *lenp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_UTF8_TO_BYTES \ @@ -6317,6 +7275,7 @@ Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *lenp) PERL_CALLCONV bool Perl_utf8_to_bytes_(pTHX_ U8 **s_ptr, STRLEN *lenp, void **free_me, Perl_utf8_to_bytes_arg result_as) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -6351,34 +7310,42 @@ Perl_utf8n_to_uvchr_error(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_4) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_UTILIZE \ assert(idop) /* PERL_CALLCONV U8 * -Perl_uv_to_utf8_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs); */ +Perl_uv_to_utf8_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV U8 * -Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv); */ +Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV U8 * -Perl_uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); */ +Perl_uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV U8 * -Perl_uvchr_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs); */ +Perl_uvchr_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV U8 * -Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); */ +Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV U8 * Perl_uvoffuni_to_utf8_flags_msgs(pTHX_ U8 *d, UV input_uv, const UV flags, HV **msgs) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS_MSGS \ assert(d) PERL_CALLCONV bool Perl_valid_identifier_pve(pTHX_ const char *s, const char *end, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_VALID_IDENTIFIER_PVE \ @@ -6386,12 +7353,14 @@ Perl_valid_identifier_pve(pTHX_ const char *s, const char *end, U32 flags) PERL_CALLCONV bool Perl_valid_identifier_pvn(pTHX_ const char *s, STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VALID_IDENTIFIER_PVN \ assert(s) PERL_CALLCONV bool -Perl_valid_identifier_sv(pTHX_ SV *sv); +Perl_valid_identifier_sv(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_VALID_IDENTIFIER_SV /* PERL_CALLCONV UV @@ -6403,6 +7372,7 @@ Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen) PERL_CALLCONV int Perl_vcmp(pTHX_ SV *lhv, SV *rhv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_VCMP \ @@ -6410,23 +7380,27 @@ Perl_vcmp(pTHX_ SV *lhv, SV *rhv) PERL_CALLCONV_NO_RET void Perl_vcroak(pTHX_ const char *pat, va_list *args) + Perl_attribute_nonnull_aTHX_ __attribute__noreturn__; #define PERL_ARGS_ASSERT_VCROAK PERL_CALLCONV void Perl_vdeb(pTHX_ const char *pat, va_list *args) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VDEB \ assert(pat) PERL_CALLCONV void Perl_vfatal_warner(pTHX_ U32 err, const char *pat, va_list *args) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_VFATAL_WARNER \ assert(pat) PERL_CALLCONV char * Perl_vform(pTHX_ const char *pat, va_list *args) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VFORM \ assert(pat) @@ -6436,6 +7410,7 @@ Perl_vform(pTHX_ const char *pat, va_list *args) PERL_CALLCONV SV * Perl_vivify_ref(pTHX_ SV *sv, U32 to_what) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -6444,18 +7419,21 @@ Perl_vivify_ref(pTHX_ SV *sv, U32 to_what) PERL_CALLCONV void Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_VLOAD_MODULE \ assert(name) PERL_CALLCONV SV * Perl_vmess(pTHX_ const char *pat, va_list *args) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VMESS \ assert(pat) PERL_CALLCONV SV * Perl_vnewSVpvf(pTHX_ const char * const pat, va_list * const args) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_VNEWSVPVF \ @@ -6463,42 +7441,49 @@ Perl_vnewSVpvf(pTHX_ const char * const pat, va_list * const args) PERL_CALLCONV SV * Perl_vnormal(pTHX_ SV *vs) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VNORMAL \ assert(vs) PERL_CALLCONV SV * Perl_vnumify(pTHX_ SV *vs) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VNUMIFY \ assert(vs) PERL_CALLCONV SV * Perl_vstringify(pTHX_ SV *vs) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VSTRINGIFY \ assert(vs) PERL_CALLCONV SV * Perl_vverify(pTHX_ SV *vs) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VVERIFY \ assert(vs) PERL_CALLCONV void Perl_vwarn(pTHX_ const char *pat, va_list *args) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_VWARN \ assert(pat) PERL_CALLCONV void Perl_vwarner(pTHX_ U32 err, const char *pat, va_list *args) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_VWARNER \ assert(pat) PERL_CALLCONV I32 Perl_wait4pid(pTHX_ Pid_t pid, int *statusp, int flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_WAIT4PID \ @@ -6506,6 +7491,7 @@ Perl_wait4pid(pTHX_ Pid_t pid, int *statusp, int flags) PERL_CALLCONV void Perl_warn(pTHX_ const char *pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_WARN \ @@ -6513,12 +7499,14 @@ Perl_warn(pTHX_ const char *pat, ...) PERL_CALLCONV void Perl_warn_sv(pTHX_ SV *baseex) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_WARN_SV \ assert(baseex) PERL_CALLCONV void Perl_warner(pTHX_ U32 err, const char *pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_WARNER \ @@ -6526,39 +7514,46 @@ Perl_warner(pTHX_ U32 err, const char *pat, ...) PERL_CALLCONV I32 Perl_was_lvalue_sub(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_WAS_LVALUE_SUB PERL_CALLCONV void Perl_watch(pTHX_ char **addr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_WATCH \ assert(addr) /* PERL_CALLCONV I32 -Perl_whichsig(pTHX_ const char *sig); */ +Perl_whichsig(pTHX_ const char *sig) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV I32 Perl_whichsig_pv(pTHX_ const char *sig) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_WHICHSIG_PV \ assert(sig) PERL_CALLCONV I32 Perl_whichsig_pvn(pTHX_ const char *sig, STRLEN len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_WHICHSIG_PVN \ assert(sig) PERL_CALLCONV I32 Perl_whichsig_sv(pTHX_ SV *sigsv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); #define PERL_ARGS_ASSERT_WHICHSIG_SV \ assert(sigsv) PERL_CALLCONV void Perl_wrap_infix_plugin(pTHX_ Perl_infix_plugin_t new_plugin, Perl_infix_plugin_t *old_plugin_p) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_WRAP_INFIX_PLUGIN \ @@ -6566,6 +7561,7 @@ Perl_wrap_infix_plugin(pTHX_ Perl_infix_plugin_t new_plugin, Perl_infix_plugin_t PERL_CALLCONV void Perl_wrap_keyword_plugin(pTHX_ Perl_keyword_plugin_t new_plugin, Perl_keyword_plugin_t *old_plugin_p) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); #define PERL_ARGS_ASSERT_WRAP_KEYWORD_PLUGIN \ @@ -6573,6 +7569,7 @@ Perl_wrap_keyword_plugin(pTHX_ Perl_keyword_plugin_t new_plugin, Perl_keyword_pl PERL_CALLCONV void Perl_wrap_op_checker(pTHX_ Optype opcode, Perl_check_t new_checker, Perl_check_t *old_checker_p) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); #define PERL_ARGS_ASSERT_WRAP_OP_CHECKER \ @@ -6580,13 +7577,15 @@ Perl_wrap_op_checker(pTHX_ Optype opcode, Perl_check_t new_checker, Perl_check_t PERL_CALLCONV void Perl_write_to_stderr(pTHX_ SV *msv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_WRITE_TO_STDERR \ assert(msv) PERL_CALLCONV void -Perl_xs_boot_epilog(pTHX_ const SSize_t ax); +Perl_xs_boot_epilog(pTHX_ const SSize_t ax) + Perl_attribute_nonnull_aTHX_; #define PERL_ARGS_ASSERT_XS_BOOT_EPILOG PERL_CALLCONV Stack_off_t @@ -6598,6 +7597,7 @@ Perl_xs_handshake(const U32 key, void *v_my_perl, const char *file, ...) PERL_CALLCONV int Perl_yyerror(pTHX_ const char * const s) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_YYERROR \ @@ -6605,6 +7605,7 @@ Perl_yyerror(pTHX_ const char * const s) PERL_CALLCONV int Perl_yyerror_pv(pTHX_ const char * const s, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_YYERROR_PV \ @@ -6612,6 +7613,7 @@ Perl_yyerror_pv(pTHX_ const char * const s, U32 flags) PERL_CALLCONV int Perl_yyerror_pvn(pTHX_ const char * const s, STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_YYERROR_PVN @@ -6619,22 +7621,26 @@ Perl_yyerror_pvn(pTHX_ const char * const s, STRLEN len, U32 flags) PERL_CALLCONV int Perl_yyparse(pTHX_ int gramtype) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_YYPARSE PERL_CALLCONV void Perl_yyquit(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_YYQUIT PERL_CALLCONV void Perl_yyunlex(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_YYUNLEX #if defined(DEBUGGING) PERL_CALLCONV int Perl_get_debug_opts(pTHX_ const char **s, bool givehelp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -6643,18 +7649,21 @@ Perl_get_debug_opts(pTHX_ const char **s, bool givehelp) PERL_CALLCONV void Perl_hv_assert(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_HV_ASSERT \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_pad_setsv(pTHX_ PADOFFSET po, SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PAD_SETSV \ assert(sv) PERL_CALLCONV SV * -Perl_pad_sv(pTHX_ PADOFFSET po); +Perl_pad_sv(pTHX_ PADOFFSET po) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PAD_SV PERL_CALLCONV void @@ -6667,12 +7676,13 @@ Perl_set_padlist(CV *cv, PADLIST *padlist) #if defined(DEBUG_LEAKING_SCALARS_FORK_DUMP) PERL_CALLCONV void Perl_dump_sv_child(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DUMP_SV_CHILD \ assert(sv) -#endif +#endif /* defined(DEBUG_LEAKING_SCALARS_FORK_DUMP) */ #if !defined(EBCDIC) # if !defined(PERL_NO_INLINE_FUNCTIONS) @@ -6686,6 +7696,7 @@ Perl_variant_byte_number(PERL_UINTMAX_T word) #if defined(F_FREESP) && !defined(HAS_CHSIZE) && !defined(HAS_TRUNCATE) PERL_CALLCONV I32 Perl_my_chsize(pTHX_ int fd, Off_t length) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_MY_CHSIZE @@ -6693,6 +7704,7 @@ Perl_my_chsize(pTHX_ int fd, Off_t length) #if !defined(HAS_GETENV_LEN) PERL_CALLCONV char * Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -6721,6 +7733,7 @@ Perl_my_mkstemp(char *templte) #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) PERL_CALLCONV I32 Perl_do_ipcctl(pTHX_ I32 optype, SV **mark, SV **sp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); @@ -6729,6 +7742,7 @@ Perl_do_ipcctl(pTHX_ I32 optype, SV **mark, SV **sp) PERL_CALLCONV I32 Perl_do_ipcget(pTHX_ I32 optype, SV **mark, SV **sp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); @@ -6737,6 +7751,7 @@ Perl_do_ipcget(pTHX_ I32 optype, SV **mark, SV **sp) PERL_CALLCONV SSize_t Perl_do_msgrcv(pTHX_ SV **mark, SV **sp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -6745,6 +7760,7 @@ Perl_do_msgrcv(pTHX_ SV **mark, SV **sp) PERL_CALLCONV I32 Perl_do_msgsnd(pTHX_ SV **mark, SV **sp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -6753,6 +7769,7 @@ Perl_do_msgsnd(pTHX_ SV **mark, SV **sp) PERL_CALLCONV I32 Perl_do_semop(pTHX_ SV **mark, SV **sp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -6761,6 +7778,7 @@ Perl_do_semop(pTHX_ SV **mark, SV **sp) PERL_CALLCONV I32 Perl_do_shmio(pTHX_ I32 optype, SV **mark, SV **sp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); @@ -6771,6 +7789,7 @@ Perl_do_shmio(pTHX_ I32 optype, SV **mark, SV **sp) #if defined(HAS_PIPE) PERL_CALLCONV int Perl_PerlProc_pipe_cloexec(pTHX_ int *pipefd) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -6781,6 +7800,7 @@ Perl_PerlProc_pipe_cloexec(pTHX_ int *pipefd) #if !defined(HAS_RENAME) PERL_CALLCONV I32 Perl_same_dirent(pTHX_ const char *a, const char *b) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -6799,12 +7819,14 @@ Perl_signbit(NV f) #if defined(HAS_SOCKET) PERL_CALLCONV int Perl_PerlSock_accept_cloexec(pTHX_ int listenfd, struct sockaddr *addr, Sock_size_t *addrlen) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_PERLSOCK_ACCEPT_CLOEXEC PERL_CALLCONV int Perl_PerlSock_socket_cloexec(pTHX_ int domain, int type, int protocol) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_PERLSOCK_SOCKET_CLOEXEC @@ -6815,6 +7837,7 @@ Perl_PerlSock_socket_cloexec(pTHX_ int domain, int type, int protocol) defined(SOCK_DGRAM) ) PERL_CALLCONV int Perl_PerlSock_socketpair_cloexec(pTHX_ int domain, int type, int protocol, int *pairfd) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -6843,26 +7866,30 @@ Perl_my_strnlen(const char *str, Size_t maxlen) #endif /* !defined(HAS_STRNLEN) */ #if defined(HAVE_INTERP_INTERN) PERL_CALLCONV void -Perl_sys_intern_clear(pTHX); +Perl_sys_intern_clear(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_SYS_INTERN_CLEAR PERL_CALLCONV void -Perl_sys_intern_init(pTHX); +Perl_sys_intern_init(pTHX) + Perl_attribute_nonnull_aTHX_; # 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) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SYS_INTERN_DUP \ assert(src); assert(dst) -# endif +# endif /* defined(USE_ITHREADS) */ #endif /* defined(HAVE_INTERP_INTERN) */ #if defined(_MSC_VER) PERL_CALLCONV int Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -6872,6 +7899,7 @@ Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg) #else /* if !defined(_MSC_VER) */ PERL_CALLCONV_NO_RET int Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__noreturn__ @@ -6922,6 +7950,7 @@ Perl_mess_nocontext(const char *pat, ...) PERL_CALLCONV void * Perl_my_cxt_init(pTHX_ int *indexp, size_t size) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_MY_CXT_INIT \ assert(indexp) @@ -6983,12 +8012,14 @@ Perl_warner_nocontext(U32 err, const char *pat, ...) #if defined(MYMALLOC) PERL_CALLCONV void Perl_dump_mstats(pTHX_ const char *s) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DUMP_MSTATS \ assert(s) PERL_CALLCONV int Perl_get_mstats(pTHX_ perl_mstats_t *buf, int buflen, int level) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GET_MSTATS \ assert(buf) @@ -7015,6 +8046,7 @@ Perl_load_mathoms(void); PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__deprecated__; # define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \ @@ -7022,6 +8054,7 @@ Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) PERL_CALLCONV UV Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__deprecated__; # define PERL_ARGS_ASSERT_UTF8_TO_UVUNI \ @@ -7029,6 +8062,7 @@ Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) PERL_CALLCONV UV Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__deprecated__; # define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI \ @@ -7036,6 +8070,7 @@ Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) PERL_CALLCONV U8 * Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__deprecated__; # define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \ @@ -7044,7 +8079,8 @@ Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv) # if defined(PERL_IN_MATHOMS_C) || defined(PERL_IN_OP_C) || \ defined(PERL_IN_PERLY_C) || defined(PERL_IN_TOKE_C) PERL_CALLCONV OP * -Perl_ref(pTHX_ OP *o, I32 type); +Perl_ref(pTHX_ OP *o, I32 type) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_REF # endif @@ -7056,12 +8092,14 @@ Perl_ref(pTHX_ OP *o, I32 type); # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV SV * Perl_sv_setsv_cow(pTHX_ SV *dsv, SV *ssv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # endif #endif /* defined(PERL_ANY_COW) */ #if defined(PERL_CORE) PERL_CALLCONV void Perl_opslab_force_free(pTHX_ OPSLAB *slab) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OPSLAB_FORCE_FREE \ @@ -7069,6 +8107,7 @@ Perl_opslab_force_free(pTHX_ OPSLAB *slab) PERL_CALLCONV void Perl_opslab_free(pTHX_ OPSLAB *slab) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OPSLAB_FREE \ @@ -7076,6 +8115,7 @@ Perl_opslab_free(pTHX_ OPSLAB *slab) PERL_CALLCONV void Perl_opslab_free_nopad(pTHX_ OPSLAB *slab) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OPSLAB_FREE_NOPAD \ @@ -7083,6 +8123,7 @@ Perl_opslab_free_nopad(pTHX_ OPSLAB *slab) PERL_CALLCONV void Perl_parser_free_nexttoke_ops(pTHX_ yy_parser *parser, OPSLAB *slab) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -7092,12 +8133,14 @@ Perl_parser_free_nexttoke_ops(pTHX_ yy_parser *parser, OPSLAB *slab) # if defined(PERL_DEBUG_READONLY_OPS) PERL_CALLCONV void Perl_Slab_to_ro(pTHX_ OPSLAB *slab) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SLAB_TO_RO \ assert(slab) PERL_CALLCONV void Perl_Slab_to_rw(pTHX_ OPSLAB * const slab) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SLAB_TO_RW \ assert(slab) @@ -7116,16 +8159,20 @@ S_should_warn_nl(const char *pv) #if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV void Perl_av_reify(pTHX_ AV *av) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV const char * -Perl_byte_dump_string_(pTHX_ const U8 * const start, const STRLEN len, const bool format); +Perl_byte_dump_string_(pTHX_ const U8 * const start, const STRLEN len, const bool format) + Perl_attribute_nonnull_aTHX_; PERL_CALLCONV const char * Perl_cntrl_to_mnemonic(const U8 c) __attribute__warn_unused_result__; PERL_CALLCONV regexp_engine const * -Perl_current_re_engine(pTHX); +Perl_current_re_engine(pTHX) + Perl_attribute_nonnull_aTHX_; PERL_CALLCONV void Perl_cv_ckproto_len_flags(pTHX_ const CV *cv, const GV *gv, const char *p, const STRLEN len, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV char * Perl_delimcpy_no_escape(char *to, const char *to_end, const char *from, const char *from_end, const int delim, I32 *retlen) @@ -7139,9 +8186,11 @@ Perl_do_uniprop_match(const char * const key, const U16 key_len) Perl_attribute_nonnull_(1) __attribute__warn_unused_result__; PERL_CALLCONV char * -Perl_dup_warnings(pTHX_ char *warnings); +Perl_dup_warnings(pTHX_ char *warnings) + Perl_attribute_nonnull_aTHX_; PERL_CALLCONV void Perl_emulate_cop_io(pTHX_ const COP * const c, SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); PERL_CALLCONV Size_t @@ -7149,6 +8198,7 @@ Perl_expected_size(UV size) __attribute__visibility__("hidden"); PERL_CALLCONV SV * Perl_get_and_check_backslash_N_name(pTHX_ const char *s, const char *e, const bool is_utf8, const char **error_msg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_4) @@ -7158,115 +8208,146 @@ Perl_get_deprecated_property_msg(const Size_t warning_offset) __attribute__warn_unused_result__; PERL_CALLCONV SV * Perl_get_prop_definition(pTHX_ const int table_index) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; PERL_CALLCONV const char * const * Perl_get_prop_values(const int table_index) __attribute__warn_unused_result__; PERL_CALLCONV Size_t Perl_inverse_folds_(pTHX_ const UV cp, U32 *first_folds_to, const U32 **remaining_folds_to) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; PERL_CALLCONV HV * Perl_load_charnames(pTHX_ SV *char_name, const char *context, const STRLEN context_len, const char **error_msg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; PERL_CALLCONV int -Perl_mbtowc_(pTHX_ const wchar_t *pwc, const char *s, const Size_t len); +Perl_mbtowc_(pTHX_ const wchar_t *pwc, const char *s, const Size_t len) + Perl_attribute_nonnull_aTHX_; PERL_CALLCONV MAGIC * Perl_mg_find_mglob(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; PERL_CALLCONV SV * Perl_multiconcat_stringify(pTHX_ const OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV SV * Perl_multideref_stringify(pTHX_ const OP *o, CV *cv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV char * Perl_new_warnings_bitfield(pTHX_ char *buffer, const char * const bits, STRLEN size) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; PERL_CALLCONV void Perl_op_clear(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void -Perl_qerror(pTHX_ SV *err); +Perl_qerror(pTHX_ SV *err) + Perl_attribute_nonnull_aTHX_; PERL_CALLCONV SV * Perl_reg_named_buff(pTHX_ REGEXP * const rx, SV * const key, SV * const value, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV SV * Perl_reg_named_buff_iter(pTHX_ REGEXP * const rx, const SV * const lastkey, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void Perl_reg_numbered_buff_fetch(pTHX_ REGEXP * const re, const I32 paren, SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void Perl_reg_numbered_buff_fetch_flags(pTHX_ REGEXP * const re, const I32 paren, SV * const sv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV I32 Perl_reg_numbered_buff_length(pTHX_ REGEXP * const rx, const SV * const sv, const I32 paren) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); PERL_CALLCONV void Perl_reg_numbered_buff_store(pTHX_ REGEXP * const rx, const I32 paren, SV const * const value) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV SV * Perl_reg_qr_package(pTHX_ REGEXP * const rx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV REGEXP * Perl_reg_temp_copy(pTHX_ REGEXP *dsv, REGEXP *ssv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); PERL_CALLCONV void -Perl_report_uninit(pTHX_ const SV *uninit_sv); +Perl_report_uninit(pTHX_ const SV *uninit_sv) + Perl_attribute_nonnull_aTHX_; PERL_CALLCONV char * Perl_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, char **delimp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; PERL_CALLCONV char * Perl_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_5); PERL_CALLCONV char * Perl_skipspace_flags(pTHX_ char *s, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; PERL_CALLCONV MAGIC * Perl_sv_magicext_mglob(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV U8 * Perl_utf16_to_utf8(pTHX_ U8 *p, U8 *d, Size_t bytelen, Size_t *newlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_4); PERL_CALLCONV U8 * Perl_utf16_to_utf8_base(pTHX_ U8 *p, U8 *d, Size_t bytelen, Size_t *newlen, const bool high, const bool low) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_4); PERL_CALLCONV U8 * Perl_utf16_to_utf8_reversed(pTHX_ U8 *p, U8 *d, Size_t bytelen, Size_t *newlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_4); PERL_CALLCONV U8 * Perl_utf8_to_utf16_base(pTHX_ U8 *s, U8 *d, Size_t bytelen, Size_t *newlen, const bool high, const bool low) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_4); PERL_CALLCONV bool Perl_validate_proto(pTHX_ SV *name, SV *proto, bool warn, bool curstash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void Perl_vivify_defelem(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV int -Perl_yylex(pTHX); +Perl_yylex(pTHX) + Perl_attribute_nonnull_aTHX_; PERL_CALLCONV bool Perl_isSCRIPT_RUN(pTHX_ const U8 *s, const U8 *send, const bool utf8_target) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -7289,23 +8370,29 @@ Perl__invlist_search(SV * const invlist, const UV cp) defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_UTF8_C) PERL_CALLCONV SV * Perl__add_range_to_invlist(pTHX_ SV *invlist, UV start, UV end) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; PERL_CALLCONV void Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV * const a, SV * const b, const bool complement_b, SV **i) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_4); PERL_CALLCONV void Perl__invlist_invert(pTHX_ SV * const invlist) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void Perl__invlist_union_maybe_complement_2nd(pTHX_ SV * const a, SV * const b, const bool complement_b, SV **output) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_4); PERL_CALLCONV SV * Perl__new_invlist(pTHX_ IV initial_size) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; PERL_CALLCONV SV * Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV **other_elements_ptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; # endif /* defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || @@ -7314,16 +8401,19 @@ Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV **othe defined(PERL_IN_TOKE_C) PERL_CALLCONV const char * Perl_form_alien_digit_msg(pTHX_ const U8 which, const STRLEN valids_len, const char * const first_bad, const char * const send, const bool UTF, const bool braced) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_grok_bslash_c(pTHX_ const char source, U8 *result, const char **message, U32 *packed_warn) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_grok_bslash_o(pTHX_ char **s, const char * const send, UV *uv, const char **message, U32 *packed_warn, const bool strict, const bool allow_UV_MAX, const bool utf8) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -7331,6 +8421,7 @@ Perl_grok_bslash_o(pTHX_ char **s, const char * const send, UV *uv, const char * __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_grok_bslash_x(pTHX_ char **s, const char * const send, UV *uv, const char **message, U32 *packed_warn, const bool strict, const bool allow_UV_MAX, const bool utf8) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -7342,12 +8433,14 @@ Perl_grok_bslash_x(pTHX_ char **s, const char * const send, UV *uv, const char * defined(PERL_IN_TOKE_C) || defined(PERL_IN_UTF8_C) PERL_CALLCONV const char * Perl_form_cp_too_large_msg(pTHX_ const U8 which, const char *string, const Size_t len, const UV cp) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # endif # if defined(PERL_IN_DUMP_C) || defined(PERL_IN_OP_C) || \ defined(PERL_IN_REGCOMP_ANY) PERL_CALLCONV void Perl__invlist_dump(pTHX_ PerlIO *file, I32 level, const char * const indent, SV * const invlist) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4); @@ -7356,17 +8449,21 @@ Perl__invlist_dump(pTHX_ PerlIO *file, I32 level, const char * const indent, SV defined(PERL_IN_UTF8_C) PERL_CALLCONV bool Perl__invlistEQ(pTHX_ SV * const a, SV * const b, const bool complement_b) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); PERL_CALLCONV SV * Perl__new_invlist_C_array(pTHX_ const UV * const list) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; -# endif +# endif /* defined(PERL_IN_PERL_C) || defined(PERL_IN_REGCOMP_ANY) || + defined(PERL_IN_UTF8_C) */ # if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || \ defined(PERL_IN_TOKE_C) PERL_CALLCONV bool Perl_is_grapheme(pTHX_ const U8 *strbeg, const U8 *s, const U8 *strend, const UV cp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -7383,35 +8480,44 @@ Perl_to_fold_latin1_(const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags) # if defined(PERL_IN_REGCOMP_DEBUG_C) && defined(DEBUGGING) STATIC U8 S_put_charclass_bitmap_innards(pTHX_ SV *sv, char *bitmap, SV *nonbitmap_invlist, SV *only_utf8_locale_invlist, const regnode * const node, const U8 flags, const bool force_as_is_display) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC SV * S_put_charclass_bitmap_innards_common(pTHX_ SV *invlist, SV *posixes, SV *only_utf8, SV *not_utf8, SV *only_utf8_locale, const bool invert) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC void S_put_charclass_bitmap_innards_invlist(pTHX_ SV *sv, SV *invlist) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); STATIC void S_put_code_point(pTHX_ SV *sv, UV c) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC void S_put_range(pTHX_ SV *sv, UV start, const UV end, const bool allow_literals) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC void -S_regdump_extflags(pTHX_ const char *lead, const U32 flags); +S_regdump_extflags(pTHX_ const char *lead, const U32 flags) + Perl_attribute_nonnull_aTHX_; STATIC void -S_regdump_intflags(pTHX_ const char *lead, const U32 flags); +S_regdump_intflags(pTHX_ const char *lead, const U32 flags) + Perl_attribute_nonnull_aTHX_; # endif /* defined(PERL_IN_REGCOMP_DEBUG_C) && defined(DEBUGGING) */ #endif /* defined(PERL_CORE) || defined(PERL_EXT) */ #if defined(PERL_CORE) || defined(PERL_USE_VOLATILE_API) PERL_CALLCONV void Perl_finalize_optree(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FINALIZE_OPTREE \ assert(o) PERL_CALLCONV void Perl_optimize_optree(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_OPTIMIZE_OPTREE \ assert(o) @@ -7420,44 +8526,50 @@ Perl_optimize_optree(pTHX_ OP *o) #if defined(PERL_DEBUG_READONLY_COW) PERL_CALLCONV void Perl_sv_buf_to_ro(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_SV_BUF_TO_RO \ assert(sv) -#endif +#endif /* defined(PERL_DEBUG_READONLY_COW) */ #if defined(PERL_DEBUG_READONLY_OPS) PERL_CALLCONV PADOFFSET Perl_op_refcnt_dec(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_OP_REFCNT_DEC \ assert(o) PERL_CALLCONV OP * -Perl_op_refcnt_inc(pTHX_ OP *o); +Perl_op_refcnt_inc(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_OP_REFCNT_INC #endif /* defined(PERL_DEBUG_READONLY_OPS) */ #if defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION) PERL_CALLCONV bool Perl_do_exec(pTHX_ const char *cmd) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_EXEC \ assert(cmd) -#else +#else /* if !defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION) */ PERL_CALLCONV bool Perl_do_exec(pTHX_ const char *cmd) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_EXEC \ assert(cmd) -#endif +#endif /* !defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION) */ #if defined(PERL_DONT_CREATE_GVSV) /* PERL_CALLCONV GV * -Perl_gv_SVadd(pTHX_ GV *gv); */ +Perl_gv_SVadd(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_; */ #endif #if defined(PERL_IMPLICIT_SYS) @@ -7496,11 +8608,13 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags, const struct IPerlMem ** # endif /* defined(USE_ITHREADS) */ #else /* if !defined(PERL_IMPLICIT_SYS) */ PERL_CALLCONV I32 -Perl_my_pclose(pTHX_ PerlIO *ptr); +Perl_my_pclose(pTHX_ PerlIO *ptr) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_MY_PCLOSE PERL_CALLCONV PerlIO * Perl_my_popen(pTHX_ const char *cmd, const char *mode) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_MY_POPEN \ @@ -7511,6 +8625,7 @@ Perl_my_popen(pTHX_ const char *cmd, const char *mode) # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE bool S_PerlEnv_putenv(pTHX_ char *str) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_PERLENV_PUTENV \ assert(str) @@ -7521,6 +8636,7 @@ S_PerlEnv_putenv(pTHX_ char *str) #if defined(PERL_IN_AV_C) STATIC MAGIC * S_get_aux_mg(pTHX_ AV *av) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GET_AUX_MG \ assert(av); assert(SvTYPE(av) == SVt_PVAV) @@ -7529,6 +8645,7 @@ S_get_aux_mg(pTHX_ AV *av) #if defined(PERL_IN_BUILTIN_C) || defined(PERL_IN_OP_C) PERL_CALLCONV void Perl_XS_builtin_indexed(pTHX_ CV *cv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_XS_BUILTIN_INDEXED \ @@ -7536,16 +8653,19 @@ Perl_XS_builtin_indexed(pTHX_ CV *cv) PERL_CALLCONV void Perl_finish_export_lexical(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_FINISH_EXPORT_LEXICAL PERL_CALLCONV void Perl_import_builtin_bundle(pTHX_ U16 ver) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_IMPORT_BUILTIN_BUNDLE PERL_CALLCONV void Perl_prepare_export_lexical(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_PREPARE_EXPORT_LEXICAL @@ -7553,6 +8673,7 @@ Perl_prepare_export_lexical(pTHX) #if defined(PERL_IN_CLASS_C) STATIC void S_class_cleanup_definition(pTHX_ HV *stash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLASS_CLEANUP_DEFINITION \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) @@ -7562,6 +8683,7 @@ S_class_cleanup_definition(pTHX_ HV *stash) defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) PERL_CALLCONV OP * Perl_ck_anoncode(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7570,6 +8692,7 @@ Perl_ck_anoncode(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_backtick(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7578,6 +8701,7 @@ Perl_ck_backtick(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_bitop(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7586,6 +8710,7 @@ Perl_ck_bitop(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_classname(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7594,6 +8719,7 @@ Perl_ck_classname(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_cmp(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7602,6 +8728,7 @@ Perl_ck_cmp(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_concat(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7610,6 +8737,7 @@ Perl_ck_concat(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_defined(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7618,6 +8746,7 @@ Perl_ck_defined(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_delete(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7626,6 +8755,7 @@ Perl_ck_delete(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_each(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7634,6 +8764,7 @@ Perl_ck_each(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_eof(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7642,6 +8773,7 @@ Perl_ck_eof(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_eval(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7650,6 +8782,7 @@ Perl_ck_eval(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_exec(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7658,6 +8791,7 @@ Perl_ck_exec(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_exists(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7666,6 +8800,7 @@ Perl_ck_exists(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_ftst(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7674,6 +8809,7 @@ Perl_ck_ftst(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_fun(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7682,6 +8818,7 @@ Perl_ck_fun(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_glob(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7690,6 +8827,7 @@ Perl_ck_glob(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_grep(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7698,6 +8836,7 @@ Perl_ck_grep(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_helemexistsor(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7706,6 +8845,7 @@ Perl_ck_helemexistsor(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_index(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7714,6 +8854,7 @@ Perl_ck_index(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_isa(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7722,6 +8863,7 @@ Perl_ck_isa(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_join(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7730,6 +8872,7 @@ Perl_ck_join(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_length(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7738,6 +8881,7 @@ Perl_ck_length(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_lfun(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7746,6 +8890,7 @@ Perl_ck_lfun(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_listiob(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7754,6 +8899,7 @@ Perl_ck_listiob(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_match(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7762,6 +8908,7 @@ Perl_ck_match(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_method(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7770,6 +8917,7 @@ Perl_ck_method(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_null(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7778,6 +8926,7 @@ Perl_ck_null(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_open(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7786,6 +8935,7 @@ Perl_ck_open(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_prototype(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7794,6 +8944,7 @@ Perl_ck_prototype(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_readline(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7802,6 +8953,7 @@ Perl_ck_readline(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_refassign(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7810,6 +8962,7 @@ Perl_ck_refassign(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_repeat(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7818,6 +8971,7 @@ Perl_ck_repeat(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_require(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7826,6 +8980,7 @@ Perl_ck_require(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_return(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7834,6 +8989,7 @@ Perl_ck_return(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_rfun(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7842,6 +8998,7 @@ Perl_ck_rfun(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_rvconst(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7850,6 +9007,7 @@ Perl_ck_rvconst(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_sassign(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7858,6 +9016,7 @@ Perl_ck_sassign(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_scmp(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7866,6 +9025,7 @@ Perl_ck_scmp(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_select(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7874,6 +9034,7 @@ Perl_ck_select(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_shift(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7882,6 +9043,7 @@ Perl_ck_shift(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_smartmatch(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7890,6 +9052,7 @@ Perl_ck_smartmatch(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_sort(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7898,6 +9061,7 @@ Perl_ck_sort(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_spair(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7906,6 +9070,7 @@ Perl_ck_spair(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_split(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7914,6 +9079,7 @@ Perl_ck_split(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_stringify(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7922,6 +9088,7 @@ Perl_ck_stringify(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_subr(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7930,6 +9097,7 @@ Perl_ck_subr(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_substr(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7938,6 +9106,7 @@ Perl_ck_substr(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_svconst(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7946,6 +9115,7 @@ Perl_ck_svconst(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_tell(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7954,6 +9124,7 @@ Perl_ck_tell(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_trunc(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7962,6 +9133,7 @@ Perl_ck_trunc(pTHX_ OP *o) PERL_CALLCONV OP * Perl_ck_trycatch(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -7975,6 +9147,7 @@ Perl_ck_trycatch(pTHX_ OP *o) defined(PERL_IN_TOKE_C) PERL_CALLCONV void Perl_class_add_ADJUST(pTHX_ HV *stash, CV *cv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CLASS_ADD_ADJUST \ @@ -7983,6 +9156,7 @@ Perl_class_add_ADJUST(pTHX_ HV *stash, CV *cv) PERL_CALLCONV void Perl_class_add_field(pTHX_ HV *stash, PADNAME *pn) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CLASS_ADD_FIELD \ @@ -7990,34 +9164,40 @@ Perl_class_add_field(pTHX_ HV *stash, PADNAME *pn) PERL_CALLCONV void Perl_class_apply_attributes(pTHX_ HV *stash, OP *attrlist) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLASS_APPLY_ATTRIBUTES \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void Perl_class_apply_field_attributes(pTHX_ PADNAME *pn, OP *attrlist) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLASS_APPLY_FIELD_ATTRIBUTES \ assert(pn) PERL_CALLCONV void -Perl_class_prepare_initfield_parse(pTHX); +Perl_class_prepare_initfield_parse(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_CLASS_PREPARE_INITFIELD_PARSE PERL_CALLCONV void Perl_class_prepare_method_parse(pTHX_ CV *cv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLASS_PREPARE_METHOD_PARSE \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_class_seal_stash(pTHX_ HV *stash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLASS_SEAL_STASH \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void Perl_class_set_field_defop(pTHX_ PADNAME *pn, OPCODE defmode, OP *defop) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_CLASS_SET_FIELD_DEFOP \ @@ -8025,16 +9205,19 @@ Perl_class_set_field_defop(pTHX_ PADNAME *pn, OPCODE defmode, OP *defop) PERL_CALLCONV void Perl_class_setup_stash(pTHX_ HV *stash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLASS_SETUP_STASH \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV OP * -Perl_class_wrap_method_body(pTHX_ OP *o); +Perl_class_wrap_method_body(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_CLASS_WRAP_METHOD_BODY PERL_CALLCONV void Perl_croak_kw_unless_class(pTHX_ const char *kw) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CROAK_KW_UNLESS_CLASS \ assert(kw) @@ -8045,6 +9228,7 @@ Perl_croak_kw_unless_class(pTHX_ const char *kw) #if defined(PERL_IN_DEB_C) STATIC void S_deb_stack_n(pTHX_ SV **stack_base, SSize_t stack_min, SSize_t stack_max, SSize_t mark_min, SSize_t mark_max, SSize_t nonrc_base) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DEB_STACK_N \ assert(stack_base) @@ -8053,6 +9237,7 @@ S_deb_stack_n(pTHX_ SV **stack_base, SSize_t stack_min, SSize_t stack_max, SSize #if defined(PERL_IN_DOIO_C) STATIC bool S_argvout_final(pTHX_ MAGIC *mg, IO *io, bool is_explicit) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_ARGVOUT_FINAL \ @@ -8060,6 +9245,7 @@ S_argvout_final(pTHX_ MAGIC *mg, IO *io, bool is_explicit) STATIC void S_exec_failed(pTHX_ const char *cmd, int fd, int do_report) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_EXEC_FAILED \ assert(cmd) @@ -8072,6 +9258,7 @@ S_is_fork_open(const char *name) 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) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_4) @@ -8081,6 +9268,7 @@ S_openn_cleanup(pTHX_ GV *gv, IO *io, PerlIO *fp, char *mode, const char *oname, STATIC IO * S_openn_setup(pTHX_ GV *gv, char *mode, PerlIO **saveifp, PerlIO **saveofp, int *savefd, char *savetype) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -8094,6 +9282,7 @@ S_openn_setup(pTHX_ GV *gv, char *mode, PerlIO **saveifp, PerlIO **saveofp, int # if !defined(DOSISH) STATIC bool S_ingroup(pTHX_ Gid_t testgid, bool effective) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_INGROUP @@ -8102,6 +9291,7 @@ S_ingroup(pTHX_ Gid_t testgid, bool effective) #if defined(PERL_IN_DOOP_C) STATIC Size_t S_do_trans_complex(pTHX_ SV * const sv, const OPtrans_map * const tbl) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -8110,6 +9300,7 @@ S_do_trans_complex(pTHX_ SV * const sv, const OPtrans_map * const tbl) STATIC Size_t S_do_trans_count(pTHX_ SV * const sv, const OPtrans_map * const tbl) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -8118,6 +9309,7 @@ S_do_trans_count(pTHX_ SV * const sv, const OPtrans_map * const tbl) STATIC Size_t S_do_trans_count_invmap(pTHX_ SV * const sv, AV * const invmap) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -8126,6 +9318,7 @@ S_do_trans_count_invmap(pTHX_ SV * const sv, AV * const invmap) STATIC Size_t S_do_trans_invmap(pTHX_ SV * const sv, AV * const invmap) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -8134,6 +9327,7 @@ S_do_trans_invmap(pTHX_ SV * const sv, AV * const invmap) STATIC Size_t S_do_trans_simple(pTHX_ SV * const sv, const OPtrans_map * const tbl) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -8162,7 +9356,8 @@ S_do_trans_simple(pTHX_ SV * const sv, const OPtrans_map * const tbl) # define PERL_ARGS_ASSERT__ADD_RANGE_TO_INVLIST /* PERL_CALLCONV void -_invlist_intersection(pTHX_ SV * const a, SV * const b, SV **i); */ +_invlist_intersection(pTHX_ SV * const a, SV * const b, SV **i) + Perl_attribute_nonnull_aTHX_; */ # define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND \ assert(b); assert(i) @@ -8171,10 +9366,12 @@ _invlist_intersection(pTHX_ SV * const a, SV * const b, SV **i); */ assert(invlist) /* PERL_CALLCONV void -_invlist_subtract(pTHX_ SV * const a, SV * const b, SV **result); */ +_invlist_subtract(pTHX_ SV * const a, SV * const b, SV **result) + Perl_attribute_nonnull_aTHX_; */ /* PERL_CALLCONV void -_invlist_union(pTHX_ SV * const a, SV * const b, SV **output); */ +_invlist_union(pTHX_ SV * const a, SV * const b, SV **output) + Perl_attribute_nonnull_aTHX_; */ # define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND \ assert(b); assert(output) @@ -8209,30 +9406,35 @@ _invlist_union(pTHX_ SV * const a, SV * const b, SV **output); */ #endif #if defined(PERL_IN_DUMP_C) STATIC CV * -S_deb_curcv(pTHX_ I32 ix); +S_deb_curcv(pTHX_ I32 ix) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_DEB_CURCV STATIC void S_debprof(pTHX_ const OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DEBPROF \ assert(o) STATIC SV * S_pm_description(pTHX_ const PMOP *pm) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_PM_DESCRIPTION \ assert(pm) STATIC char * S_pv_display_flags(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim, I32 pretty_flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PV_DISPLAY_FLAGS \ assert(dsv); assert(pv) STATIC UV -S_sequence_num(pTHX_ const OP *o); +S_sequence_num(pTHX_ const OP *o) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_SEQUENCE_NUM #endif /* defined(PERL_IN_DUMP_C) */ @@ -8240,12 +9442,14 @@ S_sequence_num(pTHX_ const OP *o); defined(PERL_IN_SCOPE_C) || defined(PERL_IN_SV_C) PERL_CALLCONV void Perl_hv_kill_backrefs(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_HV_KILL_BACKREFS \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) -#endif +#endif /* defined(PERL_IN_DUMP_C) || defined(PERL_IN_HV_C) || + defined(PERL_IN_SCOPE_C) || defined(PERL_IN_SV_C) */ #if defined(PERL_IN_DUMP_C) || defined(PERL_IN_OP_C) || \ defined(PERL_IN_REGCOMP_ANY) # define PERL_ARGS_ASSERT__INVLIST_DUMP \ @@ -8255,6 +9459,7 @@ Perl_hv_kill_backrefs(pTHX_ HV *hv) #if defined(PERL_IN_GV_C) STATIC bool S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len, const U32 is_utf8, const I32 add, const svtype sv_type) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_FIND_DEFAULT_STASH \ @@ -8262,18 +9467,21 @@ S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len, const U32 i STATIC void S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GV_INIT_SVTYPE \ assert(gv) STATIC bool S_gv_is_in_main(pTHX_ const char *name, STRLEN len, const U32 is_utf8) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GV_IS_IN_MAIN \ assert(name) STATIC bool S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, const svtype sv_type) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -8283,12 +9491,14 @@ S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, const svt STATIC void S_gv_magicalize_isa(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA \ assert(gv) STATIC void S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_MAYBE_MULTIMAGIC_GV \ @@ -8296,6 +9506,7 @@ S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type) STATIC bool S_parse_gv_stash_name(pTHX_ HV **stash, GV **gv, const char **name, STRLEN *len, const char *nambeg, STRLEN full_len, const U32 is_utf8, const I32 add) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -8306,6 +9517,7 @@ S_parse_gv_stash_name(pTHX_ HV **stash, GV **gv, const char **name, STRLEN *len, STATIC void S_require_tie_mod(pTHX_ GV *gv, const char varname, const char *name, STRLEN len, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_REQUIRE_TIE_MOD \ @@ -8313,12 +9525,14 @@ S_require_tie_mod(pTHX_ GV *gv, const char varname, const char *name, STRLEN len # if !defined(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); +S_gv_fetchmeth_internal(pTHX_ HV *stash, SV *meth, const char *name, STRLEN len, I32 level, U32 flags) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_GV_FETCHMETH_INTERNAL \ assert(!stash || SvTYPE(stash) == SVt_PVHV) PERL_STATIC_INLINE HV * S_gv_stashpvn_internal(pTHX_ const char *name, U32 namelen, I32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GV_STASHPVN_INTERNAL \ assert(name) @@ -8329,6 +9543,7 @@ S_gv_stashpvn_internal(pTHX_ const char *name, U32 namelen, I32 flags) defined(PERL_IN_PAD_C) || defined(PERL_IN_SV_C) PERL_CALLCONV void Perl_sv_add_backref(pTHX_ SV * const tsv, SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -8344,41 +9559,48 @@ Perl_sv_add_backref(pTHX_ SV * const tsv, SV * const sv) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV HV * Perl_gv_stashsvpvn_cached(pTHX_ SV *namesv, const char *name, U32 namelen, I32 flags) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); # endif #endif /* defined(PERL_IN_GV_C) || defined(PERL_IN_UNIVERSAL_C) */ #if defined(PERL_IN_HV_C) STATIC void S_clear_placeholders(pTHX_ HV *hv, U32 items) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLEAR_PLACEHOLDERS \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) STATIC void S_hsplit(pTHX_ HV *hv, STRLEN const oldsize, STRLEN newsize) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_HSPLIT \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) STATIC struct xpvhv_aux * S_hv_auxinit(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_HV_AUXINIT \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) STATIC SV * -S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash); +S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_HV_DELETE_COMMON \ assert(!hv || SvTYPE(hv) == SVt_PVHV) STATIC SV * S_hv_free_ent_ret(pTHX_ HE *entry) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_HV_FREE_ENT_RET \ assert(entry) STATIC void S_hv_free_entries(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_HV_FREE_ENTRIES \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) @@ -8394,6 +9616,7 @@ S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store) PERL_STATIC_NO_RET void S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_4) __attribute__noreturn__; @@ -8402,6 +9625,7 @@ S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg) STATIC SV * S_refcounted_he_value(pTHX_ const struct refcounted_he *he) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE \ assert(he) @@ -8416,18 +9640,21 @@ S_save_hek_flags(const char *str, I32 len, U32 hash, int flags) STATIC HEK * S_share_hek_flags(pTHX_ const char *str, STRLEN len, U32 hash, int flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SHARE_HEK_FLAGS \ assert(str) STATIC void -S_unshare_hek_or_pvn(pTHX_ const HEK *hek, const char *str, I32 len, U32 hash); +S_unshare_hek_or_pvn(pTHX_ const HEK *hek, const char *str, I32 len, U32 hash) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_UNSHARE_HEK_OR_PVN # if !defined(PURIFY) STATIC HE * S_new_he(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NEW_HE @@ -8436,15 +9663,18 @@ S_new_he(pTHX) #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) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_SV_KILL_BACKREFS \ assert(sv) -#endif +#endif /* defined(PERL_IN_HV_C) || defined(PERL_IN_MG_C) || + defined(PERL_IN_SV_C) */ #if defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) PERL_CALLCONV SV * Perl_hfree_next_entry(pTHX_ HV *hv, STRLEN *indexp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -8454,11 +9684,13 @@ Perl_hfree_next_entry(pTHX_ HV *hv, STRLEN *indexp) #endif /* defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) */ #if defined(PERL_IN_LOCALE_C) STATIC utf8ness_t -S_get_locale_string_utf8ness_i(pTHX_ const char *string, const locale_utf8ness_t known_utf8, const char *locale, const locale_category_index cat_index); +S_get_locale_string_utf8ness_i(pTHX_ const char *string, const locale_utf8ness_t known_utf8, const char *locale, const locale_category_index cat_index) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_GET_LOCALE_STRING_UTF8NESS_I STATIC void S_ints_to_tm(pTHX_ struct tm *my_tm, const char *locale, int sec, int min, int hour, int mday, int mon, int year, int isdst) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_INTS_TO_TM \ @@ -8466,16 +9698,19 @@ S_ints_to_tm(pTHX_ struct tm *my_tm, const char *locale, int sec, int min, int h STATIC bool S_is_locale_utf8(pTHX_ const char *locale) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_IS_LOCALE_UTF8 \ assert(locale) STATIC HV * -S_my_localeconv(pTHX_ const int item); +S_my_localeconv(pTHX_ const int item) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_MY_LOCALECONV STATIC void S_populate_hash_from_C_localeconv(pTHX_ HV *hv, const char *locale, const U32 which_mask, const lconv_offset_t *strings[2], const lconv_offset_t *integers[2]) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_4) @@ -8486,6 +9721,7 @@ S_populate_hash_from_C_localeconv(pTHX_ HV *hv, const char *locale, const U32 wh STATIC bool S_strftime8(pTHX_ const char *fmt, SV *sv, const char *locale, const struct tm *mytm, const utf8ness_t fmt_utf8ness, utf8ness_t *result_utf8ness, const bool called_externally) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -8497,6 +9733,7 @@ S_strftime8(pTHX_ const char *fmt, SV *sv, const char *locale, const struct tm * STATIC bool S_strftime_tm(pTHX_ const char *fmt, SV *sv, const char *locale, const struct tm *mytm) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -8507,6 +9744,7 @@ S_strftime_tm(pTHX_ const char *fmt, SV *sv, const char *locale, const struct tm STATIC SV * S_sv_strftime_common(pTHX_ SV *fmt, const char *locale, const struct tm *mytm) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -8516,63 +9754,75 @@ S_sv_strftime_common(pTHX_ SV *fmt, const char *locale, const struct tm *mytm) # if defined(HAS_MISSING_LANGINFO_ITEM_) || !defined(HAS_NL_LANGINFO) STATIC const char * S_emulate_langinfo(pTHX_ const PERL_INTMAX_T item, const char *locale, SV *sv, utf8ness_t *utf8ness) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_EMULATE_LANGINFO \ assert(locale); assert(sv) -# endif +# endif /* defined(HAS_MISSING_LANGINFO_ITEM_) || !defined(HAS_NL_LANGINFO) */ # if defined(USE_LOCALE) STATIC const char * -S_calculate_LC_ALL_string(pTHX_ const char **category_locales_list, const calc_LC_ALL_format format, const calc_LC_ALL_return returning, const line_t caller_line); +S_calculate_LC_ALL_string(pTHX_ const char **category_locales_list, const calc_LC_ALL_format format, const calc_LC_ALL_return returning, const line_t caller_line) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_CALCULATE_LC_ALL_STRING STATIC const char * S_external_call_langinfo(pTHX_ const nl_item item, SV *sv, utf8ness_t *utf8ness) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_EXTERNAL_CALL_LANGINFO \ assert(sv) STATIC locale_category_index S_get_category_index_helper(pTHX_ const int category, bool *success, const line_t caller_line) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_GET_CATEGORY_INDEX_HELPER STATIC const char * -S_native_querylocale_i(pTHX_ const locale_category_index cat_index); +S_native_querylocale_i(pTHX_ const locale_category_index cat_index) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_NATIVE_QUERYLOCALE_I STATIC void S_new_LC_ALL(pTHX_ const char *lc_all, bool force) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_NEW_LC_ALL \ assert(lc_all) STATIC void -S_output_check_environment_warning(pTHX_ const char * const language, const char * const lc_all, const char * const lang); +S_output_check_environment_warning(pTHX_ const char * const language, const char * const lc_all, const char * const lang) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_OUTPUT_CHECK_ENVIRONMENT_WARNING STATIC parse_LC_ALL_string_return S_parse_LC_ALL_string(pTHX_ const char *string, const char **output, const parse_LC_ALL_STRING_action, bool always_use_full_array, const bool panic_on_error, const line_t caller_line) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PARSE_LC_ALL_STRING \ assert(string); assert(output) STATIC void -S_restore_toggled_locale_i(pTHX_ const locale_category_index cat_index, const char *original_locale, const line_t caller_line); +S_restore_toggled_locale_i(pTHX_ const locale_category_index cat_index, const char *original_locale, const line_t caller_line) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_RESTORE_TOGGLED_LOCALE_I STATIC const char * -S_save_to_buffer(pTHX_ const char *string, char **buf, Size_t *buf_size); +S_save_to_buffer(pTHX_ const char *string, char **buf, Size_t *buf_size) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_SAVE_TO_BUFFER STATIC void -S_set_save_buffer_min_size(pTHX_ const Size_t min_len, char **buf, Size_t *buf_size); +S_set_save_buffer_min_size(pTHX_ const Size_t min_len, char **buf, Size_t *buf_size) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_SET_SAVE_BUFFER_MIN_SIZE PERL_STATIC_NO_RET void S_setlocale_failure_panic_via_i(pTHX_ const locale_category_index cat_index, const char *current, const char *failed, const line_t proxy_caller_line, const line_t immediate_caller_line, const char *higher_caller_file, const line_t higher_caller_line) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_6) __attribute__noreturn__; @@ -8581,6 +9831,7 @@ S_setlocale_failure_panic_via_i(pTHX_ const locale_category_index cat_index, con STATIC const char * S_toggle_locale_i(pTHX_ const locale_category_index cat_index, const char *new_locale, const line_t caller_line) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_TOGGLE_LOCALE_I \ assert(new_locale) @@ -8588,6 +9839,7 @@ S_toggle_locale_i(pTHX_ const locale_category_index cat_index, const char *new_l # if defined(DEBUGGING) STATIC char * S_my_setlocale_debug_string_i(pTHX_ const locale_category_index cat_index, const char *locale, const char *retval, const line_t line) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_MY_SETLOCALE_DEBUG_STRING_I @@ -8596,6 +9848,7 @@ S_my_setlocale_debug_string_i(pTHX_ const locale_category_index cat_index, const ( defined(USE_LOCALE_MONETARY) || defined(USE_LOCALE_NUMERIC) ) STATIC void S_populate_hash_from_localeconv(pTHX_ HV *hv, const char *locale, const U32 which_mask, const lconv_offset_t *strings[2], const lconv_offset_t *integers[2]) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_4) @@ -8610,15 +9863,17 @@ S_populate_hash_from_localeconv(pTHX_ HV *hv, const char *locale, const U32 whic # if defined(HAS_NL_LANGINFO) STATIC const char * S_langinfo_sv_i(pTHX_ const nl_item item, locale_category_index cat_index, const char *locale, SV *sv, utf8ness_t *utf8ness) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_LANGINFO_SV_I \ assert(locale); assert(sv) -# endif +# endif /* defined(HAS_NL_LANGINFO) */ # if defined(LC_ALL) STATIC void S_give_perl_locale_control(pTHX_ const char *lc_all_string, const line_t caller_line) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GIVE_PERL_LOCALE_CONTROL \ assert(lc_all_string) @@ -8626,6 +9881,7 @@ S_give_perl_locale_control(pTHX_ const char *lc_all_string, const line_t caller_ # else STATIC void S_give_perl_locale_control(pTHX_ const char **curlocales, const line_t caller_line) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GIVE_PERL_LOCALE_CONTROL \ assert(curlocales) @@ -8634,6 +9890,7 @@ S_give_perl_locale_control(pTHX_ const char **curlocales, const line_t caller_li # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE const char * S_mortalized_pv_copy(pTHX_ const char * const pv) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_MORTALIZED_PV_COPY @@ -8641,6 +9898,7 @@ S_mortalized_pv_copy(pTHX_ const char * const pv) # if defined(USE_LOCALE_COLLATE) STATIC void S_new_collate(pTHX_ const char *newcoll, bool force) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_NEW_COLLATE \ assert(newcoll) @@ -8648,12 +9906,13 @@ S_new_collate(pTHX_ const char *newcoll, bool force) # if defined(DEBUGGING) STATIC void S_print_collxfrm_input_and_return(pTHX_ const char *s, const char *e, const char *xbuf, const STRLEN xlen, const bool is_utf8) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PRINT_COLLXFRM_INPUT_AND_RETURN \ assert(s); assert(e) -# endif +# endif /* defined(DEBUGGING) */ # endif /* defined(USE_LOCALE_COLLATE) */ # if defined(USE_LOCALE_CTYPE) STATIC bool @@ -8664,6 +9923,7 @@ S_is_codeset_name_UTF8(const char *name) STATIC void S_new_ctype(pTHX_ const char *newctype, bool force) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_NEW_CTYPE \ assert(newctype) @@ -8672,6 +9932,7 @@ S_new_ctype(pTHX_ const char *newctype, bool force) # if defined(USE_LOCALE_NUMERIC) STATIC void S_new_numeric(pTHX_ const char *newnum, bool force) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_NEW_NUMERIC \ assert(newnum) @@ -8679,28 +9940,33 @@ S_new_numeric(pTHX_ const char *newnum, bool force) # endif # if defined(USE_PERL_SWITCH_LOCALE_CONTEXT) || defined(DEBUGGING) STATIC const char * -S_get_LC_ALL_display(pTHX); +S_get_LC_ALL_display(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_GET_LC_ALL_DISPLAY # endif # if defined(USE_POSIX_2008_LOCALE) STATIC bool S_bool_setlocale_2008_i(pTHX_ const locale_category_index index, const char *new_locale, const line_t caller_line) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_BOOL_SETLOCALE_2008_I \ assert(new_locale) STATIC const char * -S_querylocale_2008_i(pTHX_ const locale_category_index index, const line_t line); +S_querylocale_2008_i(pTHX_ const locale_category_index index, const line_t line) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_QUERYLOCALE_2008_I STATIC locale_t -S_use_curlocale_scratch(pTHX); +S_use_curlocale_scratch(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_USE_CURLOCALE_SCRATCH # if !defined(USE_QUERYLOCALE) STATIC void S_update_PL_curlocales_i(pTHX_ const locale_category_index index, const char *new_locale, const line_t caller_line) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_UPDATE_PL_CURLOCALES_I \ assert(new_locale) @@ -8712,12 +9978,14 @@ S_update_PL_curlocales_i(pTHX_ const locale_category_index index, const char *ne !defined(USE_POSIX_2008_LOCALE) */ STATIC bool S_less_dicey_bool_setlocale_r(pTHX_ const int cat, const char *locale) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_LESS_DICEY_BOOL_SETLOCALE_R \ assert(locale) STATIC const char * -S_less_dicey_setlocale_r(pTHX_ const int category, const char *locale); +S_less_dicey_setlocale_r(pTHX_ const int category, const char *locale) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_LESS_DICEY_SETLOCALE_R # endif /* defined(USE_LOCALE_THREADS) && @@ -8734,18 +10002,21 @@ S_Win_wstring_to_byte_string(const UINT code_page, const wchar_t *wstring); # define PERL_ARGS_ASSERT_WIN_WSTRING_TO_BYTE_STRING STATIC const char * -S_win32_setlocale(pTHX_ int category, const char *locale); +S_win32_setlocale(pTHX_ int category, const char *locale) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_WIN32_SETLOCALE STATIC const char * -S_wrap_wsetlocale(pTHX_ const int category, const char *locale); +S_wrap_wsetlocale(pTHX_ const int category, const char *locale) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_WRAP_WSETLOCALE # endif /* defined(WIN32) || defined(WIN32_USE_FAKE_OLD_MINGW_LOCALES) */ # if defined(WIN32) || defined(WIN32_USE_FAKE_OLD_MINGW_LOCALES) || \ ( defined(USE_POSIX_2008_LOCALE) && !defined(USE_QUERYLOCALE) ) STATIC const char * -S_find_locale_from_environment(pTHX_ const locale_category_index index); +S_find_locale_from_environment(pTHX_ const locale_category_index index) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_FIND_LOCALE_FROM_ENVIRONMENT # endif @@ -8753,12 +10024,13 @@ S_find_locale_from_environment(pTHX_ const locale_category_index index); # if defined(USE_LOCALE) || defined(DEBUGGING) STATIC const char * S_get_displayable_string(pTHX_ const char * const s, const char * const e, const bool is_utf8) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_GET_DISPLAYABLE_STRING \ assert(s); assert(e) -# endif +# endif /* defined(USE_LOCALE) || defined(DEBUGGING) */ #endif /* defined(PERL_IN_LOCALE_C) */ #if defined(PERL_IN_MALLOC_C) STATIC int @@ -8767,16 +10039,22 @@ S_adjust_size_and_find_bucket(size_t *nbytes_p) # define PERL_ARGS_ASSERT_ADJUST_SIZE_AND_FIND_BUCKET \ assert(nbytes_p) +#endif +#if defined(PERL_IN_MATHOMS_C) || defined(PERL_IN_OP_C) || \ + defined(PERL_IN_PERLY_C) || defined(PERL_IN_TOKE_C) + #endif #if defined(PERL_IN_MG_C) STATIC void S_fixup_errno_string(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FIXUP_ERRNO_STRING \ assert(sv) STATIC SV * S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, int n, SV *val) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -8785,6 +10063,7 @@ S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, int n, SV STATIC int S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -8792,17 +10071,20 @@ S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth) assert(sv); assert(mg); assert(meth) STATIC void -S_restore_magic(pTHX_ void *p); +S_restore_magic(pTHX_ void *p) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_RESTORE_MAGIC STATIC void S_save_magic_flags(pTHX_ SSize_t mgs_ix, SV *sv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS \ assert(sv) STATIC void -S_unwind_handler_stack(pTHX_ void *p); +S_unwind_handler_stack(pTHX_ void *p) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_UNWIND_HANDLER_STACK #endif /* defined(PERL_IN_MG_C) */ @@ -8819,6 +10101,7 @@ Perl_translate_substr_offsets(STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len #if defined(PERL_IN_MRO_C) STATIC void S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN len, HV * const exceptions, U32 hash, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV \ @@ -8827,6 +10110,7 @@ S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN l STATIC void S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes, HV *stash, HV *oldstash, SV *namesv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_5); @@ -8838,6 +10122,7 @@ S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes, HV *s STATIC AV * S_mro_get_linear_isa_dfs(pTHX_ HV *stash, U32 level) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV) @@ -8845,13 +10130,15 @@ S_mro_get_linear_isa_dfs(pTHX_ HV *stash, U32 level) #endif /* defined(PERL_IN_MRO_C) */ #if defined(PERL_IN_NUMERIC_C) STATIC void -S_output_non_portable(pTHX_ const U8 shift); +S_output_non_portable(pTHX_ const U8 shift) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_OUTPUT_NON_PORTABLE #endif #if defined(PERL_IN_OP_C) STATIC void S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_APPLY_ATTRS \ @@ -8859,6 +10146,7 @@ S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs) STATIC void S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_4); @@ -8868,11 +10156,13 @@ S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp) STATIC I32 S_assignment_type(pTHX_ const OP *o) + Perl_attribute_nonnull_aTHX_ __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) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4); @@ -8881,6 +10171,7 @@ S_bad_type_gv(pTHX_ I32 n, GV *gv, const OP *kid, const char *t) STATIC void S_bad_type_pv(pTHX_ I32 n, const char *t, const OP *o, const OP *kid) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4); @@ -8889,6 +10180,7 @@ S_bad_type_pv(pTHX_ I32 n, const char *t, const OP *o, const OP *kid) STATIC void S_clear_special_blocks(pTHX_ const char * const fullname, GV * const gv, CV * const cv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -8898,44 +10190,52 @@ S_clear_special_blocks(pTHX_ const char * const fullname, GV * const gv, CV * co STATIC void S_cop_free(pTHX_ COP *cop) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_COP_FREE \ assert(cop) STATIC OP * S_dup_attrlist(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DUP_ATTRLIST \ assert(o) STATIC void S_find_and_forget_pmops(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS \ assert(o) STATIC OP * S_fold_constants(pTHX_ OP * const o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FOLD_CONSTANTS \ assert(o) STATIC OP * -S_force_list(pTHX_ OP *arg, bool nullit); +S_force_list(pTHX_ OP *arg, bool nullit) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_FORCE_LIST STATIC void S_forget_pmop(pTHX_ PMOP * const o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FORGET_PMOP \ assert(o) STATIC void -S_gen_constant_list(pTHX_ OP *o); +S_gen_constant_list(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_GEN_CONSTANT_LIST STATIC void S_inplace_aassign(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_INPLACE_AASSIGN \ assert(o) @@ -8948,21 +10248,25 @@ S_is_handle_constructor(const OP *o, I32 numargs) assert(o) STATIC OP * -S_listkids(pTHX_ OP *o); +S_listkids(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_LISTKIDS STATIC bool S_looks_like_bool(pTHX_ const OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_LOOKS_LIKE_BOOL \ assert(o) STATIC OP * -S_modkids(pTHX_ OP *o, I32 type); +S_modkids(pTHX_ OP *o, I32 type) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_MODKIDS STATIC void S_move_proto_attr(pTHX_ OP **proto, OP **attrs, const GV *name, bool curstash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -8971,18 +10275,21 @@ S_move_proto_attr(pTHX_ OP **proto, OP **attrs, const GV *name, bool curstash) STATIC OP * S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_MY_KID \ assert(imopsp) STATIC OP * S_newGIVWHENOP(pTHX_ OP *cond, OP *block, I32 enter_opcode, I32 leave_opcode, PADOFFSET entertarg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_NEWGIVWHENOP \ assert(block) STATIC OP * S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; @@ -8991,6 +10298,7 @@ S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp) STATIC OP * S_no_fh_allowed(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NO_FH_ALLOWED \ @@ -8998,6 +10306,7 @@ S_no_fh_allowed(pTHX_ OP *o) STATIC OP * S_pmtrans(pTHX_ OP *o, OP *expr, OP *repl) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -9006,6 +10315,7 @@ S_pmtrans(pTHX_ OP *o, OP *expr, OP *repl) STATIC bool S_process_special_blocks(pTHX_ I32 floor, const char * const fullname, GV * const gv, CV * const cv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4); @@ -9014,11 +10324,13 @@ S_process_special_blocks(pTHX_ I32 floor, const char * const fullname, GV * cons assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) STATIC OP * -S_ref_array_or_hash(pTHX_ OP *cond); +S_ref_array_or_hash(pTHX_ OP *cond) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_REF_ARRAY_OR_HASH STATIC OP * -S_refkids(pTHX_ OP *o, I32 type); +S_refkids(pTHX_ OP *o, I32 type) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_REFKIDS STATIC bool @@ -9028,16 +10340,19 @@ S_scalar_mod_type(const OP *o, I32 type) STATIC OP * S_scalarboolean(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SCALARBOOLEAN \ assert(o) STATIC OP * -S_scalarkids(pTHX_ OP *o); +S_scalarkids(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_SCALARKIDS STATIC OP * S_search_const(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SEARCH_CONST \ @@ -9045,12 +10360,14 @@ S_search_const(pTHX_ OP *o) STATIC void S_simplify_sort(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SIMPLIFY_SORT \ assert(o) STATIC OP * S_too_few_arguments_pv(pTHX_ OP *o, const char *name, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -9059,18 +10376,21 @@ S_too_few_arguments_pv(pTHX_ OP *o, const char *name, U32 flags) STATIC OP * S_too_many_arguments_pv(pTHX_ OP *o, const char *name, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_PV \ assert(o); assert(name) STATIC OP * -S_voidnonfinal(pTHX_ OP *o); +S_voidnonfinal(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_VOIDNONFINAL # if defined(DEBUGGING) STATIC const char * S_get_displayable_tr_operand(pTHX_ const U8 *s, STRLEN len, bool is_utf8) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GET_DISPLAYABLE_TR_OPERAND \ assert(s) @@ -9084,17 +10404,20 @@ S_is_standard_filehandle_name(const char *fhname) assert(fhname) PERL_STATIC_INLINE OP * -S_newMETHOP_internal(pTHX_ I32 type, I32 flags, OP *dynamic_meth, SV * const_meth); +S_newMETHOP_internal(pTHX_ I32 type, I32 flags, OP *dynamic_meth, SV * const_meth) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_NEWMETHOP_INTERNAL PERL_STATIC_INLINE OP * S_op_integerize(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_OP_INTEGERIZE \ assert(o) PERL_STATIC_INLINE OP * S_op_std_init(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_OP_STD_INIT \ assert(o) @@ -9118,11 +10441,13 @@ S_size_to_psize(size_t size); #if defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) PERL_CALLCONV void Perl_check_hash_fields_and_hekify(pTHX_ UNOP *rop, SVOP *key_op, int real) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CHECK_HASH_FIELDS_AND_HEKIFY PERL_CALLCONV void Perl_no_bareword_allowed(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_NO_BAREWORD_ALLOWED \ @@ -9137,6 +10462,7 @@ Perl_op_prune_chain_head(OP **op_p) PERL_CALLCONV SV * Perl_op_varname(pTHX_ const OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OP_VARNAME \ @@ -9144,6 +10470,7 @@ Perl_op_varname(pTHX_ const OP *o) PERL_CALLCONV void Perl_warn_elem_scalar_context(pTHX_ const OP *o, SV *name, bool is_hash, bool is_slice) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -9157,6 +10484,7 @@ Perl_warn_elem_scalar_context(pTHX_ const OP *o, SV *name, bool is_hash, bool is #if defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C) PERL_CALLCONV void Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_cv, SV * const *new_const_svp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -9165,6 +10493,7 @@ Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_cv, SV * const *new 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) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_VARNAME @@ -9173,18 +10502,21 @@ Perl_varname(pTHX_ const GV * const gv, const char gvtype, PADOFFSET targ, const #if defined(PERL_IN_PAD_C) STATIC PADOFFSET S_pad_alloc_name(pTHX_ PADNAME *name, U32 flags, HV *typestash, HV *ourstash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_PAD_ALLOC_NAME \ assert(name); assert(!ourstash || SvTYPE(ourstash) == SVt_PVHV) STATIC void S_pad_check_dup(pTHX_ PADNAME *name, U32 flags, const HV *ourstash) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_PAD_CHECK_DUP \ assert(name) STATIC PADOFFSET S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV *cv, U32 seq, int warn, SV **out_capture, PADNAME **out_name, int *out_flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_4) Perl_attribute_nonnull_(pTHX_8) @@ -9193,34 +10525,39 @@ S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV *cv, assert(namepv); assert(cv); assert(out_name); assert(out_flags) STATIC void -S_pad_reset(pTHX); +S_pad_reset(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PAD_RESET # if defined(DEBUGGING) STATIC void S_cv_dump(pTHX_ const CV *cv, const char *title) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CV_DUMP \ assert(cv); assert(title) -# endif +# endif /* defined(DEBUGGING) */ #endif /* defined(PERL_IN_PAD_C) */ #if defined(PERL_IN_PEEP_C) STATIC void S_finalize_op(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FINALIZE_OP \ assert(o) STATIC void S_optimize_op(pTHX_ OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_OPTIMIZE_OP \ assert(o) STATIC OP * S_traverse_op_tree(pTHX_ OP *top, OP *o) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_TRAVERSE_OP_TREE \ @@ -9230,97 +10567,116 @@ S_traverse_op_tree(pTHX_ OP *top, OP *o) #if defined(PERL_IN_PERL_C) STATIC void S_find_beginning(pTHX_ SV *linestr_sv, PerlIO *rsfp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_FIND_BEGINNING \ assert(linestr_sv); assert(rsfp) STATIC void -S_forbid_setid(pTHX_ const char flag, const bool suidscript); +S_forbid_setid(pTHX_ const char flag, const bool suidscript) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_FORBID_SETID STATIC void S_incpush(pTHX_ const char * const dir, STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_INCPUSH \ assert(dir) STATIC void S_incpush_use_sep(pTHX_ const char *p, STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_INCPUSH_USE_SEP \ assert(p) STATIC void -S_init_ids(pTHX); +S_init_ids(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_INIT_IDS STATIC void -S_init_interp(pTHX); +S_init_interp(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_INIT_INTERP STATIC void -S_init_main_stash(pTHX); +S_init_main_stash(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_INIT_MAIN_STASH STATIC void -S_init_perllib(pTHX); +S_init_perllib(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_INIT_PERLLIB STATIC void S_init_postdump_symbols(pTHX_ int argc, char **argv, char **env) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_INIT_POSTDUMP_SYMBOLS \ assert(argv) STATIC void -S_init_predump_symbols(pTHX); +S_init_predump_symbols(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_INIT_PREDUMP_SYMBOLS STATIC SV * S_mayberelocate(pTHX_ const char * const dir, STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_MAYBERELOCATE \ assert(dir) PERL_STATIC_NO_RET void S_minus_v(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__noreturn__; # define PERL_ARGS_ASSERT_MINUS_V PERL_STATIC_NO_RET void S_my_exit_jump(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__noreturn__; # define PERL_ARGS_ASSERT_MY_EXIT_JUMP STATIC void -S_nuke_stacks(pTHX); +S_nuke_stacks(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_NUKE_STACKS STATIC PerlIO * S_open_script(pTHX_ const char *scriptname, bool dosearch, bool *suidscript) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_OPEN_SCRIPT \ assert(scriptname); assert(suidscript) STATIC void * -S_parse_body(pTHX_ char **env, XSINIT_t xsinit); +S_parse_body(pTHX_ char **env, XSINIT_t xsinit) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PARSE_BODY PERL_STATIC_NO_RET void S_run_body(pTHX_ I32 oldscope) + Perl_attribute_nonnull_aTHX_ __attribute__noreturn__; # define PERL_ARGS_ASSERT_RUN_BODY PERL_STATIC_NO_RET void S_usage(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__noreturn__; # define PERL_ARGS_ASSERT_USAGE # if !defined(PERL_IS_MINIPERL) STATIC SV * S_incpush_if_exists(pTHX_ AV * const av, SV *dir, SV * const stem) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -9331,6 +10687,7 @@ S_incpush_if_exists(pTHX_ AV * const av, SV *dir, SV * const stem) # if !defined(SETUID_SCRIPTS_ARE_SECURE_NOW) STATIC void S_validate_suid(pTHX_ PerlIO *rsfp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_VALIDATE_SUID \ assert(rsfp) @@ -9349,17 +10706,20 @@ S_validate_suid(pTHX_ PerlIO *rsfp) #if defined(PERL_IN_PP_C) STATIC size_t S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_DO_CHOMP \ assert(retval); assert(sv) STATIC OP * -S_do_delete_local(pTHX); +S_do_delete_local(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_DO_DELETE_LOCAL STATIC SV * S_refto(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_REFTO \ @@ -9370,6 +10730,7 @@ S_refto(pTHX_ SV *sv) PERL_CALLCONV GV * Perl_softref2xv(pTHX_ SV * const sv, const char * const what, const svtype type) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -9384,6 +10745,7 @@ Perl_softref2xv(pTHX_ SV * const sv, const char * const what, const svtype type) #if defined(PERL_IN_PP_C) || defined(PERL_IN_UTF8_C) PERL_CALLCONV UV Perl_to_upper_title_latin1_(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_or_s) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); @@ -9394,6 +10756,7 @@ Perl_to_upper_title_latin1_(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_ #if defined(PERL_IN_PP_CTL_C) STATIC PerlIO * S_check_type_and_open(pTHX_ SV *name) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_CHECK_TYPE_AND_OPEN \ @@ -9401,29 +10764,34 @@ S_check_type_and_open(pTHX_ SV *name) STATIC void S_destroy_matcher(pTHX_ PMOP *matcher) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DESTROY_MATCHER \ assert(matcher) STATIC OP * -S_do_smartmatch(pTHX_ HV *seen_this, HV *seen_other, const bool copied); +S_do_smartmatch(pTHX_ HV *seen_this, HV *seen_other, const bool copied) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_DO_SMARTMATCH \ assert(!seen_this || SvTYPE(seen_this) == SVt_PVHV); \ assert(!seen_other || SvTYPE(seen_other) == SVt_PVHV) STATIC OP * S_docatch(pTHX_ Perl_ppaddr_t firstpp) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOCATCH STATIC bool -S_doeval_compile(pTHX_ U8 gimme, CV *outside, U32 seq, HV *hh); +S_doeval_compile(pTHX_ U8 gimme, CV *outside, U32 seq, HV *hh) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_DOEVAL_COMPILE \ assert(!outside || SvTYPE(outside) == SVt_PVCV || SvTYPE(outside) == SVt_PVFM); \ assert(!hh || SvTYPE(hh) == SVt_PVHV) STATIC OP * S_dofindlabel(pTHX_ OP *o, const char *label, STRLEN len, U32 flags, OP **opstack, OP **oplimit) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_5) @@ -9434,22 +10802,26 @@ S_dofindlabel(pTHX_ OP *o, const char *label, STRLEN len, U32 flags, OP **opstac STATIC MAGIC * S_doparseform(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DOPARSEFORM \ assert(sv) STATIC I32 S_dopoptoeval(pTHX_ I32 startingblock) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOPOPTOEVAL STATIC I32 S_dopoptogivenfor(pTHX_ I32 startingblock) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOPOPTOGIVENFOR STATIC I32 S_dopoptolabel(pTHX_ const char *label, STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOPOPTOLABEL \ @@ -9457,11 +10829,13 @@ S_dopoptolabel(pTHX_ const char *label, STRLEN len, U32 flags) STATIC I32 S_dopoptoloop(pTHX_ I32 startingblock) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOPOPTOLOOP STATIC I32 S_dopoptosub_at(pTHX_ const PERL_CONTEXT *cxstk, I32 startingblock) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOPOPTOSUB_AT \ @@ -9469,11 +10843,13 @@ S_dopoptosub_at(pTHX_ const PERL_CONTEXT *cxstk, I32 startingblock) STATIC I32 S_dopoptowhen(pTHX_ I32 startingblock) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOPOPTOWHEN STATIC PMOP * S_make_matcher(pTHX_ REGEXP *re) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_MAKE_MATCHER \ @@ -9481,6 +10857,7 @@ S_make_matcher(pTHX_ REGEXP *re) STATIC bool S_matcher_matches_sv(pTHX_ PMOP *matcher, SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -9494,6 +10871,7 @@ S_num_overflow(NV value, I32 fldsize, I32 frcsize) STATIC I32 S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_RUN_USER_FILTER \ @@ -9501,12 +10879,14 @@ S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen) STATIC void S_rxres_free(pTHX_ void **rsp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RXRES_FREE \ assert(rsp) STATIC void S_rxres_restore(pTHX_ void **rsp, REGEXP *rx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_RXRES_RESTORE \ @@ -9514,6 +10894,7 @@ S_rxres_restore(pTHX_ void **rsp, REGEXP *rx) STATIC void S_save_lines(pTHX_ AV *array, SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SAVE_LINES \ assert(!array || SvTYPE(array) == SVt_PVAV); assert(sv) @@ -9521,12 +10902,13 @@ S_save_lines(pTHX_ AV *array, SV *sv) # if !defined(PERL_DISABLE_PMC) STATIC PerlIO * S_doopen_pm(pTHX_ SV *name) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOOPEN_PM \ assert(name) -# endif +# endif /* !defined(PERL_DISABLE_PMC) */ # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE bool S_path_is_searchable(const char *name) @@ -9540,6 +10922,7 @@ S_path_is_searchable(const char *name) #if defined(PERL_IN_PP_CTL_C) || defined(PERL_IN_UTIL_C) PERL_CALLCONV bool Perl_invoke_exception_hook(pTHX_ SV *ex, bool warn) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_INVOKE_EXCEPTION_HOOK @@ -9547,6 +10930,7 @@ Perl_invoke_exception_hook(pTHX_ SV *ex, bool warn) #if defined(PERL_IN_PP_HOT_C) STATIC void S_do_oddball(pTHX_ SV **oddkey, SV **firstkey) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_DO_ODDBALL \ @@ -9555,12 +10939,14 @@ S_do_oddball(pTHX_ SV **oddkey, SV **firstkey) # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE HV * S_opmethod_stash(pTHX_ SV *meth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_OPMETHOD_STASH \ assert(meth) PERL_STATIC_FORCE_INLINE bool S_should_we_output_Debug_r(pTHX_ regexp *prog) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__always_inline__; @@ -9572,6 +10958,7 @@ S_should_we_output_Debug_r(pTHX_ regexp *prog) #if defined(PERL_IN_PP_PACK_C) STATIC int S_div128(pTHX_ SV *pnum, bool *done) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_DIV128 \ @@ -9586,6 +10973,7 @@ S_first_symbol(const char *pat, const char *patend) STATIC const char * S_get_num(pTHX_ const char *patptr, SSize_t *lenptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -9594,6 +10982,7 @@ S_get_num(pTHX_ const char *patptr, SSize_t *lenptr) STATIC const char * S_group_end(pTHX_ const char *patptr, const char *patend, char ender) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_GROUP_END \ @@ -9601,6 +10990,7 @@ S_group_end(pTHX_ const char *patptr, const char *patend, char ender) STATIC SV * S_is_an_int(pTHX_ const char *s, STRLEN l) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_AN_INT \ @@ -9608,12 +10998,14 @@ S_is_an_int(pTHX_ const char *s, STRLEN l) STATIC SSize_t S_measure_struct(pTHX_ struct tempsym *symptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_MEASURE_STRUCT \ assert(symptr) STATIC SV * S_mul128(pTHX_ SV *sv, U8 m) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_MUL128 \ assert(sv) @@ -9635,12 +11027,14 @@ S_need_utf8(const char *pat, const char *patend) STATIC bool S_next_symbol(pTHX_ struct tempsym *symptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_NEXT_SYMBOL \ assert(symptr) STATIC SV ** S_pack_rec(pTHX_ SV *cat, struct tempsym *symptr, SV **beglist, SV **endlist) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -9650,6 +11044,7 @@ S_pack_rec(pTHX_ SV *cat, struct tempsym *symptr, SV **beglist, SV **endlist) STATIC char * S_sv_exp_grow(pTHX_ SV *sv, STRLEN needed) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SV_EXP_GROW \ @@ -9657,6 +11052,7 @@ S_sv_exp_grow(pTHX_ SV *sv, STRLEN needed) STATIC SSize_t S_unpack_rec(pTHX_ struct tempsym *symptr, const char *s, const char *strbeg, const char *strend, const char **new_s) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -9669,6 +11065,7 @@ S_unpack_rec(pTHX_ struct tempsym *symptr, const char *s, const char *strbeg, co STATIC I32 S_sortcv(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SORTCV \ @@ -9676,6 +11073,7 @@ S_sortcv(pTHX_ SV * const a, SV * const b) STATIC I32 S_sortcv_stacked(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SORTCV_STACKED \ @@ -9683,6 +11081,7 @@ S_sortcv_stacked(pTHX_ SV * const a, SV * const b) STATIC I32 S_sortcv_xsub(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SORTCV_XSUB \ @@ -9691,6 +11090,7 @@ S_sortcv_xsub(pTHX_ SV * const a, SV * const b) # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE I32 S_amagic_cmp(pTHX_ SV * const str1, SV * const str2) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_CMP \ @@ -9698,6 +11098,7 @@ S_amagic_cmp(pTHX_ SV * const str1, SV * const str2) PERL_STATIC_INLINE I32 S_amagic_cmp_desc(pTHX_ SV * const str1, SV * const str2) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_CMP_DESC \ @@ -9705,6 +11106,7 @@ S_amagic_cmp_desc(pTHX_ SV * const str1, SV * const str2) PERL_STATIC_INLINE I32 S_amagic_i_ncmp(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_I_NCMP \ @@ -9712,6 +11114,7 @@ S_amagic_i_ncmp(pTHX_ SV * const a, SV * const b) PERL_STATIC_INLINE I32 S_amagic_i_ncmp_desc(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_I_NCMP_DESC \ @@ -9719,6 +11122,7 @@ S_amagic_i_ncmp_desc(pTHX_ SV * const a, SV * const b) PERL_STATIC_INLINE I32 S_amagic_ncmp(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_NCMP \ @@ -9726,6 +11130,7 @@ S_amagic_ncmp(pTHX_ SV * const a, SV * const b) PERL_STATIC_INLINE I32 S_amagic_ncmp_desc(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_NCMP_DESC \ @@ -9733,6 +11138,7 @@ S_amagic_ncmp_desc(pTHX_ SV * const a, SV * const b) PERL_STATIC_INLINE I32 S_cmp_desc(pTHX_ SV * const str1, SV * const str2) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CMP_DESC \ @@ -9740,6 +11146,7 @@ S_cmp_desc(pTHX_ SV * const str1, SV * const str2) PERL_STATIC_FORCE_INLINE void S_sortsv_flags_impl(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) __attribute__always_inline__; # define PERL_ARGS_ASSERT_SORTSV_FLAGS_IMPL \ @@ -9747,6 +11154,7 @@ S_sortsv_flags_impl(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp, U32 flag PERL_STATIC_INLINE I32 S_sv_i_ncmp(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SV_I_NCMP \ @@ -9754,6 +11162,7 @@ S_sv_i_ncmp(pTHX_ SV * const a, SV * const b) PERL_STATIC_INLINE I32 S_sv_i_ncmp_desc(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SV_I_NCMP_DESC \ @@ -9761,6 +11170,7 @@ S_sv_i_ncmp_desc(pTHX_ SV * const a, SV * const b) PERL_STATIC_INLINE I32 S_sv_ncmp(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SV_NCMP \ @@ -9768,6 +11178,7 @@ S_sv_ncmp(pTHX_ SV * const a, SV * const b) PERL_STATIC_INLINE I32 S_sv_ncmp_desc(pTHX_ SV * const a, SV * const b) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SV_NCMP_DESC \ @@ -9776,6 +11187,7 @@ S_sv_ncmp_desc(pTHX_ SV * const a, SV * const b) # if defined(USE_LOCALE_COLLATE) PERL_STATIC_INLINE I32 S_amagic_cmp_locale(pTHX_ SV * const str1, SV * const str2) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \ @@ -9783,6 +11195,7 @@ S_amagic_cmp_locale(pTHX_ SV * const str1, SV * const str2) PERL_STATIC_INLINE I32 S_amagic_cmp_locale_desc(pTHX_ SV * const str1, SV * const str2) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE_DESC \ @@ -9790,6 +11203,7 @@ S_amagic_cmp_locale_desc(pTHX_ SV * const str1, SV * const str2) PERL_STATIC_INLINE I32 S_cmp_locale_desc(pTHX_ SV * const str1, SV * const str2) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CMP_LOCALE_DESC \ @@ -9804,6 +11218,7 @@ S_cmp_locale_desc(pTHX_ SV * const str1, SV * const str2) #if defined(PERL_IN_PP_SYS_C) STATIC OP * S_doform(pTHX_ CV *cv, GV *gv, OP *retop) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_DOFORM \ @@ -9811,11 +11226,13 @@ S_doform(pTHX_ CV *cv, GV *gv, OP *retop) assert(gv) STATIC SV * -S_space_join_names_mortal(pTHX_ char * const *array); +S_space_join_names_mortal(pTHX_ char * const *array) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL STATIC void S_warn_not_dirhandle(pTHX_ GV *gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_WARN_NOT_DIRHANDLE \ assert(gv) @@ -9823,6 +11240,7 @@ S_warn_not_dirhandle(pTHX_ GV *gv) # if !defined(HAS_MKDIR) || !defined(HAS_RMDIR) STATIC int S_dooneliner(pTHX_ const char *cmd, const char *filename) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -9874,26 +11292,31 @@ S_dooneliner(pTHX_ const char *cmd, const char *filename) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV void Perl_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV **invlist) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); PERL_CALLCONV regnode * Perl_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *source, U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); PERL_CALLCONV SV * Perl_get_ANYOFHbbm_contents(pTHX_ const regnode *n) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); PERL_CALLCONV SV * Perl_get_ANYOFM_contents(pTHX_ const regnode *n) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); PERL_CALLCONV U32 Perl_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, UV *min_subtract, bool *unfolded_multi_char, U32 flags, regnode *val, U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -9901,6 +11324,7 @@ Perl_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, UV *min_subtract __attribute__visibility__("hidden"); PERL_CALLCONV I32 Perl_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *first, regnode *last, regnode *tail, U32 word_count, U32 flags, U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -9909,6 +11333,7 @@ Perl_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *f __attribute__visibility__("hidden"); PERL_CALLCONV void Perl_populate_anyof_bitmap_from_invlist(pTHX_ regnode *node, SV **invlist_ptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -9920,22 +11345,26 @@ Perl_reg_add_data(RExC_state_t * const pRExC_state, const char * const s, const __attribute__visibility__("hidden"); PERL_CALLCONV void Perl_scan_commit(pTHX_ const RExC_state_t *pRExC_state, struct scan_data_t *data, SSize_t *minlenp, int is_inf) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); PERL_CALLCONV void Perl_set_ANYOF_arg(pTHX_ RExC_state_t * const pRExC_state, regnode * const node, SV * const cp_list, SV * const runtime_defns, SV * const only_utf8_locale_list) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); PERL_CALLCONV void Perl_ssc_init(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); PERL_CALLCONV SSize_t Perl_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, SSize_t *minlenp, SSize_t *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U32 recursed_depth, regnode_ssc *and_withp, U32 flags, U32 depth, bool was_mutate_ok) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -9945,14 +11374,17 @@ Perl_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, SSize_t *minl # if defined(PERL_IN_REGCOMP_TRIE_C) && defined(DEBUGGING) STATIC void S_dump_trie(pTHX_ const struct reg_trie_data_ *trie, HV *widecharmap, AV *revcharmap, U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); STATIC void S_dump_trie_interim_list(pTHX_ const struct reg_trie_data_ *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); STATIC void S_dump_trie_interim_table(pTHX_ const struct reg_trie_data_ *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); # endif /* defined(PERL_IN_REGCOMP_TRIE_C) && defined(DEBUGGING) */ @@ -9987,6 +11419,7 @@ S_dump_trie_interim_table(pTHX_ const struct reg_trie_data_ *trie, HV *widecharm # if defined(PERL_CORE) || defined(PERL_EXT) PERL_STATIC_INLINE SV * S_invlist_contents(pTHX_ SV * const invlist, const bool traditional_style) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; PERL_STATIC_INLINE UV @@ -10011,6 +11444,7 @@ S_invlist_lowest(SV * const invlist) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV SV * Perl_invlist_clone(pTHX_ SV * const invlist, SV *newlist) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # endif #endif /* defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_SV_C) */ @@ -10078,6 +11512,7 @@ Perl_invlist_clone(pTHX_ SV * const invlist, SV *newlist) PERL_STATIC_NO_RET void S_re_croak(pTHX_ bool utf8, const char *pat, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__noreturn__ __attribute__format__(__printf__,pTHX_2,pTHX_3); @@ -10157,12 +11592,15 @@ S_re_croak(pTHX_ bool utf8, const char *pat, ...) # if defined(PERL_CORE) || defined(PERL_EXT) STATIC AV * S_add_multi_match(pTHX_ AV *multi_char_matches, SV *multi_string, const STRLEN cp_count) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); STATIC void S_change_engine_size(pTHX_ RExC_state_t *pRExC_state, const ptrdiff_t size) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC REGEXP * S_compile_wildcard(pTHX_ const char *subpattern, const STRLEN len, const bool ignore_case) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; STATIC U8 @@ -10175,6 +11613,7 @@ S_edit_distance(const UV *src, const UV *tgt, const STRLEN x, const STRLEN y, co __attribute__warn_unused_result__; STATIC I32 S_execute_wildcard(pTHX_ REGEXP * const prog, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *screamer, U32 nosave) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -10182,33 +11621,40 @@ S_execute_wildcard(pTHX_ REGEXP * const prog, char *stringarg, char *strend, cha Perl_attribute_nonnull_(pTHX_6); STATIC U32 S_get_quantifier_value(pTHX_ RExC_state_t *pRExC_state, const char *start, const char *end) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); STATIC bool S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode_offset *nodep, UV *code_point_p, int *cp_count, I32 *flagp, const bool strict, const U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_5); STATIC regnode_offset S_handle_named_backref(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, char *backref_parse_start, char ch) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); STATIC bool S_handle_names_wildcard(pTHX_ const char *wname, const STRLEN wname_len, SV **prop_definition, AV **strings) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4); STATIC int S_handle_possible_posix(pTHX_ RExC_state_t *pRExC_state, const char * const s, char **updated_parse_ptr, AV **posix_warnings, const bool check_only) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); STATIC regnode_offset S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV **return_invlist, I32 *flagp, U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); STATIC SV * S_handle_user_defined_property(pTHX_ const char *name, const STRLEN name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, SV *contents, bool *user_defined_ptr, SV *msg, const STRLEN level) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_7) Perl_attribute_nonnull_(pTHX_8) @@ -10219,9 +11665,11 @@ S_is_ssc_worth_it(const RExC_state_t *pRExC_state, const regnode_ssc *ssc) Perl_attribute_nonnull_(2); STATIC void S_nextchar(pTHX_ RExC_state_t *pRExC_state) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC U8 S_optimize_regclass(pTHX_ RExC_state_t *pRExC_state, SV *cp_list, SV *only_utf8_locale_list, SV *upper_latin1_only_utf8_matches, const U32 has_runtime_dependency, const U32 posixl, U8 *anyof_flags, bool *invert, regnode_offset *ret, I32 *flagp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_7) Perl_attribute_nonnull_(pTHX_8) @@ -10229,50 +11677,63 @@ S_optimize_regclass(pTHX_ RExC_state_t *pRExC_state, SV *cp_list, SV *only_utf8_ Perl_attribute_nonnull_(pTHX_10); STATIC void S_output_posix_warnings(pTHX_ RExC_state_t *pRExC_state, AV *posix_warnings) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); STATIC void S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC SV * S_parse_uniprop_string(pTHX_ const char * const name, Size_t name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, AV **strings, bool *user_defined_ptr, SV *msg, const STRLEN level) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_8) Perl_attribute_nonnull_(pTHX_9); STATIC regnode_offset S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); STATIC regnode_offset S_reg1node(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC regnode_offset S_reg2node(pTHX_ RExC_state_t *pRExC_state, const U8 op, const U32 arg1, const I32 arg2) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC regnode_offset S_reg_la_NOTHING(pTHX_ RExC_state_t *pRExC_state, U32 flags, const char *type) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); STATIC regnode_offset S_reg_la_OPFAIL(pTHX_ RExC_state_t *pRExC_state, U32 flags, const char *type) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); STATIC regnode_offset S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC SV * S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC regnode_offset S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); STATIC regnode_offset S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); STATIC regnode_offset S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, const bool strict, bool optimizable, SV **ret_invlist) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); STATIC unsigned int @@ -10280,40 +11741,50 @@ S_regex_set_precedence(const U8 my_operator) __attribute__warn_unused_result__; STATIC void S_reginsert(pTHX_ RExC_state_t *pRExC_state, const U8 op, const regnode_offset operand, const U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC regnode_offset S_regnode_guts(pTHX_ RExC_state_t *pRExC_state, const STRLEN extra_len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC regnode_offset S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); STATIC regnode_offset S_regpnode(pTHX_ RExC_state_t *pRExC_state, U8 op, SV *arg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); STATIC bool S_regtail(pTHX_ RExC_state_t *pRExC_state, const regnode_offset p, const regnode_offset val, const U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; STATIC void S_set_regex_pv(pTHX_ RExC_state_t *pRExC_state, REGEXP *Rx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); STATIC void S_skip_to_be_ignored_text(pTHX_ RExC_state_t *pRExC_state, char **p, const bool force_to_xmod) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); STATIC void S_ssc_finalize(pTHX_ RExC_state_t *pRExC_state, regnode_ssc *ssc) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # if defined(DEBUGGING) STATIC regnode_offset S_regnode_guts_debug(pTHX_ RExC_state_t *pRExC_state, const U8 op, const STRLEN extra_len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC bool S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode_offset p, const regnode_offset val, U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -10321,6 +11792,7 @@ S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode_offset p, const regnode # if defined(ENABLE_REGEX_SETS_DEBUGGING) STATIC void S_dump_regex_sets_structures(pTHX_ RExC_state_t *pRExC_state, AV *stack, const IV fence, AV *fence_stack) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_4); @@ -10356,11 +11828,13 @@ S_reg_skipcomment(RExC_state_t *pRExC_state, char *p) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV void Perl_populate_bitmap_from_invlist(pTHX_ SV *invlist, const UV offset, const U8 *bitmap, const Size_t len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); PERL_CALLCONV void Perl_populate_invlist_from_bitmap(pTHX_ const U8 *bitmap, const Size_t bitmap_len, SV **invlist, const UV offset) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); @@ -10417,6 +11891,7 @@ Perl_regcurly(const char *s, const char *e, const char *result[5]) STATIC void S_initialize_invlist_guts(pTHX_ SV *invlist, const Size_t initial_size) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_INITIALIZE_INVLIST_GUTS \ assert(invlist) @@ -10427,12 +11902,14 @@ S_initialize_invlist_guts(pTHX_ SV *invlist, const Size_t initial_size) # if defined(PERL_CORE) || defined(PERL_EXT) STATIC void S__append_range_to_invlist(pTHX_ SV * const invlist, const UV start, const UV end) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC void S_invlist_replace_list_destroys_src(pTHX_ SV *dest, SV *src) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); -# endif +# endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # if !defined(PERL_NO_INLINE_FUNCTIONS) # define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT \ assert(invlist) @@ -10466,6 +11943,7 @@ S_get_invlist_previous_index_addr(SV *invlist) __attribute__warn_unused_result__; PERL_STATIC_INLINE void S_invlist_clear(pTHX_ SV *invlist) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_STATIC_INLINE UV S_invlist_max(const SV * const invlist) @@ -10530,35 +12008,43 @@ S_invlist_trim(SV *invlist) # if defined(PERL_CORE) || defined(PERL_EXT) STATIC SV * S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, const regnode_charclass * const node) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); STATIC SV * S_make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC void S_rck_elide_nothing(pTHX_ regnode *node) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC void S_ssc_add_range(pTHX_ regnode_ssc *ssc, UV const start, UV const end) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC void S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *and_with) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); STATIC void S_ssc_anything(pTHX_ regnode_ssc *ssc) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC void S_ssc_clear_locale(regnode_ssc *ssc) Perl_attribute_nonnull_(1); STATIC void S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC void S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV * const invlist, const bool invert_2nd) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); STATIC int @@ -10572,15 +12058,18 @@ S_ssc_is_cp_posixl_init(const RExC_state_t *pRExC_state, const regnode_ssc *ssc) __attribute__warn_unused_result__; STATIC void S_ssc_or(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *or_with) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); STATIC void S_ssc_union(pTHX_ regnode_ssc *ssc, SV * const invlist, const bool invert_2nd) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); STATIC void S_unwind_scan_frames(pTHX_ void *p) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ #endif /* defined(PERL_IN_REGCOMP_STUDY_C) */ @@ -10687,42 +12176,50 @@ S_unwind_scan_frames(pTHX_ void *p) # if defined(PERL_CORE) || defined(PERL_EXT) STATIC LB_enum S_advance_one_LB(pTHX_ U8 **curpos, const U8 * const strend, const bool utf8_target) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC SB_enum S_advance_one_SB(pTHX_ U8 **curpos, const U8 * const strend, const bool utf8_target) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC WB_enum S_advance_one_WB_(pTHX_ U8 **curpos, const U8 * const strend, const bool utf8_target, const bool skip_Extend_Format) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC GCB_enum S_backup_one_GCB(pTHX_ const U8 * const strbeg, U8 **curpos, const bool utf8_target) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC LB_enum S_backup_one_LB_(pTHX_ const U8 * const strbeg, U8 **curpos, const bool utf8_target, bool skip_CM_ZWJ) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC SB_enum S_backup_one_SB(pTHX_ const U8 * const strbeg, U8 **curpos, const bool utf8_target) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC WB_enum S_backup_one_WB_but_over_Extend_FO(pTHX_ WB_enum *previous, const U8 * const strbeg, U8 **curpos, const bool utf8_target) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; STATIC char * S_find_byclass(pTHX_ regexp *prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -10745,31 +12242,37 @@ S_find_span_end_mask(U8 *s, const U8 *send, const U8 span_byte, const U8 mask) __attribute__warn_unused_result__; STATIC bool S_isFOO_lc(pTHX_ const U8 classnum, const U8 character) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; STATIC bool S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8 *character, const U8 *e) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; STATIC bool S_isGCB(pTHX_ const GCB_enum before, const GCB_enum after, const U8 * const strbeg, const U8 * const curpos, const bool utf8_target) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; STATIC bool S_isLB(pTHX_ LB_enum before, LB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) Perl_attribute_nonnull_(pTHX_5) __attribute__warn_unused_result__; STATIC bool S_isSB(pTHX_ SB_enum before, SB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) Perl_attribute_nonnull_(pTHX_5) __attribute__warn_unused_result__; STATIC bool S_isWB(pTHX_ WB_enum previous, WB_enum before, WB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_4) Perl_attribute_nonnull_(pTHX_5) Perl_attribute_nonnull_(pTHX_6) @@ -10781,14 +12284,17 @@ S_reg_check_named_buff_matched(const regexp *rex, const regnode *scan) __attribute__warn_unused_result__; STATIC void S_regcp_restore(pTHX_ regexp *rex, I32 ix, U32 *maxopenparen_p comma_pDEPTH) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); STATIC void S_regcppop(pTHX_ regexp *rex, U32 *maxopenparen_p comma_pDEPTH) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); STATIC CHECKPOINT S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen comma_pDEPTH) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC U8 * S_reghop3(U8 *s, SSize_t off, const U8 *lim) @@ -10802,18 +12308,21 @@ S_reghopmaybe3(U8 *s, SSize_t off, const U8 * const lim) __attribute__warn_unused_result__; STATIC bool S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8 * const p, const U8 * const p_end, bool const utf8_target) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; STATIC SSize_t S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; STATIC I32 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, char *loceol, regmatch_info * const reginfo, I32 max comma_pDEPTH) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -10822,24 +12331,29 @@ S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, char *loceol __attribute__warn_unused_result__; STATIC bool S_regtry(pTHX_ regmatch_info *reginfo, char **startposp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; STATIC bool S_to_byte_substr(pTHX_ regexp *prog) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); STATIC void S_to_utf8_substr(pTHX_ regexp *prog) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # if defined(DEBUGGING) STATIC void S_debug_start_match(pTHX_ const REGEXP *prog, const bool do_utf8, const char *start, const char *end, const char *blurb) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) Perl_attribute_nonnull_(pTHX_5); STATIC void S_dump_exec_pos(pTHX_ const char *locinput, const regnode *scan, const char *loc_regeol, const char *loc_bostr, const char *loc_reg_starttry, const bool do_utf8, const U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -10847,6 +12361,7 @@ S_dump_exec_pos(pTHX_ const char *locinput, const regnode *scan, const char *loc Perl_attribute_nonnull_(pTHX_5); PERL_CALLCONV int Perl_re_exec_indentf(pTHX_ const char *fmt, U32 depth, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # endif /* defined(DEBUGGING) */ @@ -10864,14 +12379,17 @@ Perl_re_exec_indentf(pTHX_ const char *fmt, U32 depth, ...) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_STATIC_INLINE void S_capture_clear(pTHX_ regexp *rex, U16 from_ix, U16 to_ix, const char *str comma_pDEPTH) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_4); PERL_STATIC_INLINE I32 S_foldEQ_latin1_s2_folded(pTHX_ const char *a, const char *b, I32 len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); PERL_STATIC_INLINE void S_unwind_paren(pTHX_ regexp *rex, U32 lp, U32 lcp comma_pDEPTH) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ @@ -10903,20 +12421,24 @@ S_unwind_paren(pTHX_ regexp *rex, U32 lp, U32 lcp comma_pDEPTH) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV void Perl_debug_peep(pTHX_ const char *str, const RExC_state_t *pRExC_state, regnode *scan, U32 depth, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); PERL_CALLCONV void Perl_debug_show_study_flags(pTHX_ U32 flags, const char *open_str, const char *close_str) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); PERL_CALLCONV void Perl_debug_studydata(pTHX_ const char *where, scan_data_t *data, U32 depth, int is_inf, SSize_t min, SSize_t stopmin, SSize_t delta) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); PERL_CALLCONV const regnode * Perl_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node, const regnode *last, const regnode *plast, SV *sv, I32 indent, U32 depth) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -10924,15 +12446,18 @@ Perl_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node, __attribute__visibility__("hidden"); PERL_CALLCONV int Perl_re_indentf(pTHX_ const char *fmt, U32 depth, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); PERL_CALLCONV int Perl_re_printf(pTHX_ const char *fmt, ...) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden") __attribute__format__(__printf__,pTHX_1,pTHX_2); PERL_CALLCONV void Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_info *reginfo, const RExC_state_t *pRExC_state) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); @@ -10945,6 +12470,7 @@ Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_ # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV SV * Perl_get_re_gclass_aux_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV **output_invlist) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # endif @@ -10955,6 +12481,7 @@ Perl_get_re_gclass_aux_data(pTHX_ const regexp *prog, const struct regnode *node # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV SV * Perl_get_regclass_aux_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV **output_invlist) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); # endif @@ -10962,16 +12489,19 @@ Perl_get_regclass_aux_data(pTHX_ const regexp *prog, const struct regnode *node, # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE bool Perl_check_regnode_after(pTHX_ const regnode *p, const STRLEN extra) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_CHECK_REGNODE_AFTER PERL_STATIC_INLINE regnode * Perl_regnext(pTHX_ const regnode *p) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_REGNEXT PERL_STATIC_INLINE regnode * Perl_regnode_after(pTHX_ const regnode *p, bool varies) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_REGNODE_AFTER @@ -10979,11 +12509,13 @@ Perl_regnode_after(pTHX_ const regnode *p, bool varies) #endif /* defined(PERL_IN_REGEX_ENGINE) */ #if defined(PERL_IN_SCOPE_C) STATIC void -S_save_pushptri32ptr(pTHX_ void * const ptr1, const I32 i, void * const ptr2, const int type); +S_save_pushptri32ptr(pTHX_ void * const ptr1, const I32 i, void * const ptr2, const int type) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_SAVE_PUSHPTRI32PTR STATIC SV * S_save_scalar_at(pTHX_ SV **sptr, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SAVE_SCALAR_AT \ assert(sptr) @@ -10999,6 +12531,7 @@ S_F0convert(NV nv, char * const endbuf, STRLEN * const len) STATIC void S_anonymise_cv_maybe(pTHX_ GV *gv, CV *cv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_ANONYMISE_CV_MAYBE \ @@ -11007,6 +12540,7 @@ S_anonymise_cv_maybe(pTHX_ GV *gv, CV *cv) STATIC void S_assert_uft8_cache_coherent(pTHX_ const char * const func, STRLEN from_cache, STRLEN real, SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_ASSERT_UFT8_CACHE_COHERENT \ @@ -11014,6 +12548,7 @@ S_assert_uft8_cache_coherent(pTHX_ const char * const func, STRLEN from_cache, S STATIC void S_croak_sv_setsv_flags(pTHX_ SV * const dsv, SV * const ssv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CROAK_SV_SETSV_FLAGS \ @@ -11021,12 +12556,14 @@ S_croak_sv_setsv_flags(pTHX_ SV * const dsv, SV * const ssv) STATIC bool S_curse(pTHX_ SV * const sv, const bool check_refcnt) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CURSE \ assert(sv) STATIC STRLEN S_expect_number(pTHX_ const char ** const pattern) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_EXPECT_NUMBER \ @@ -11034,47 +12571,55 @@ S_expect_number(pTHX_ const char ** const pattern) STATIC SSize_t S_find_array_subscript(pTHX_ const AV * const av, const SV * const val) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_FIND_ARRAY_SUBSCRIPT \ assert(val) STATIC SV * S_find_hash_subscript(pTHX_ const HV * const hv, const SV * const val) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_FIND_HASH_SUBSCRIPT \ assert(val) STATIC SV * S_find_uninit_var(pTHX_ const OP * const obase, const SV * const uninit_sv, bool match, const char **desc_p) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_FIND_UNINIT_VAR \ assert(desc_p) STATIC bool S_glob_2number(pTHX_ GV * const gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_GLOB_2NUMBER \ assert(gv) STATIC void S_glob_assign_glob(pTHX_ SV * const dsv, SV * const ssv, const int dtype) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB \ assert(dsv); assert(ssv) PERL_CALLCONV SV * -Perl_more_sv(pTHX); +Perl_more_sv(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_MORE_SV STATIC void S_not_a_number(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_NOT_A_NUMBER \ assert(sv) STATIC void S_not_incrementable(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_NOT_INCREMENTABLE \ assert(sv) @@ -11088,18 +12633,21 @@ S_ptr_table_find(PTR_TBL_t * const tbl, const void * const sv) STATIC bool S_sv_2iuv_common(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_2IUV_COMMON \ assert(sv) STATIC void S_sv_add_arena(pTHX_ char * const ptr, const U32 size, const U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_ADD_ARENA \ assert(ptr) STATIC const char * S_sv_display(pTHX_ SV * const sv, char *tmpbuf, STRLEN tmpbuf_size) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SV_DISPLAY \ @@ -11107,6 +12655,7 @@ S_sv_display(pTHX_ SV * const sv, char *tmpbuf, STRLEN tmpbuf_size) STATIC STRLEN S_sv_pos_b2u_midway(pTHX_ const U8 * const s, const U8 * const target, const U8 *end, STRLEN endu) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -11115,6 +12664,7 @@ S_sv_pos_b2u_midway(pTHX_ const U8 * const s, const U8 * const target, const U8 STATIC STRLEN S_sv_pos_u2b_cached(pTHX_ SV * const sv, MAGIC ** const mgp, const U8 * const start, const U8 * const send, STRLEN uoffset, STRLEN uoffset0, STRLEN boffset0) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -11142,6 +12692,7 @@ S_sv_pos_u2b_midway(const U8 * const start, const U8 *send, STRLEN uoffset, cons STATIC void S_utf8_mg_len_cache_update(pTHX_ SV * const sv, MAGIC ** const mgp, const STRLEN ulen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_UTF8_MG_LEN_CACHE_UPDATE \ @@ -11149,6 +12700,7 @@ S_utf8_mg_len_cache_update(pTHX_ SV * const sv, MAGIC ** const mgp, const STRLEN STATIC void S_utf8_mg_pos_cache_update(pTHX_ SV * const sv, MAGIC ** const mgp, const STRLEN byte, const STRLEN utf8, const STRLEN blen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_UTF8_MG_POS_CACHE_UPDATE \ @@ -11156,6 +12708,7 @@ S_utf8_mg_pos_cache_update(pTHX_ SV * const sv, MAGIC ** const mgp, const STRLEN STATIC SSize_t S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_VISIT \ assert(f) @@ -11163,17 +12716,20 @@ S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask) # if defined(DEBUGGING) STATIC void S_del_sv(pTHX_ SV *p) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DEL_SV \ assert(p) PERL_CALLCONV void Perl_sv_mark_arenas(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_SV_MARK_ARENAS PERL_CALLCONV void Perl_sv_sweep_arenas(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_SV_SWEEP_ARENAS @@ -11182,6 +12738,7 @@ Perl_sv_sweep_arenas(pTHX) # if defined(DEBUGGING) STATIC int S_sv_2iuv_non_preserve(pTHX_ SV * const sv, I32 numtype) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ assert(sv) @@ -11189,6 +12746,7 @@ S_sv_2iuv_non_preserve(pTHX_ SV * const sv, I32 numtype) # else STATIC int S_sv_2iuv_non_preserve(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ assert(sv) @@ -11198,6 +12756,7 @@ S_sv_2iuv_non_preserve(pTHX_ SV * const sv) # if defined(PERL_DEBUG_READONLY_COW) STATIC void S_sv_buf_to_rw(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_BUF_TO_RW \ assert(sv) @@ -11206,6 +12765,7 @@ S_sv_buf_to_rw(pTHX_ SV *sv) # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE void S_sv_unglob(pTHX_ SV * const sv, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_UNGLOB \ assert(sv) @@ -11214,6 +12774,7 @@ S_sv_unglob(pTHX_ SV * const sv, U32 flags) # if defined(USE_ITHREADS) STATIC SV * S_sv_dup_common(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -11222,6 +12783,7 @@ S_sv_dup_common(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) STATIC void S_sv_dup_hvaux(pTHX_ const SV * const ssv, SV *dsv, CLONE_PARAMS * const param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -11230,6 +12792,7 @@ S_sv_dup_hvaux(pTHX_ const SV * const ssv, SV *dsv, CLONE_PARAMS * const param) STATIC SV ** S_sv_dup_inc_multiple(pTHX_ SV * const *source, SV **dest, SSize_t items, CLONE_PARAMS * const param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_4); @@ -11238,6 +12801,7 @@ S_sv_dup_inc_multiple(pTHX_ SV * const *source, SV **dest, SSize_t items, CLONE_ STATIC void S_unreferenced_to_tmp_stack(pTHX_ AV * const unreferenced) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_UNREFERENCED_TO_TMP_STACK \ assert(unreferenced); assert(SvTYPE(unreferenced) == SVt_PVAV) @@ -11246,15 +12810,18 @@ S_unreferenced_to_tmp_stack(pTHX_ AV * const unreferenced) #endif /* defined(PERL_IN_SV_C) */ #if defined(PERL_IN_TOKE_C) STATIC int -S_ao(pTHX_ int toketype); +S_ao(pTHX_ int toketype) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_AO STATIC void -S_check_uni(pTHX); +S_check_uni(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_CHECK_UNI STATIC void S_checkcomma(pTHX_ const char *s, const char *name, const char *what) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -11263,6 +12830,7 @@ S_checkcomma(pTHX_ const char *s, const char *name, const char *what) STATIC char * S_filter_gets(pTHX_ SV *sv, STRLEN append) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_FILTER_GETS \ @@ -11270,6 +12838,7 @@ S_filter_gets(pTHX_ SV *sv, STRLEN append) STATIC HV * S_find_in_my_stash(pTHX_ const char *pkgname, STRLEN len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_FIND_IN_MY_STASH \ @@ -11277,38 +12846,45 @@ S_find_in_my_stash(pTHX_ const char *pkgname, STRLEN len) STATIC void S_force_ident(pTHX_ const char *s, int kind) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FORCE_IDENT \ assert(s) STATIC void -S_force_ident_maybe_lex(pTHX_ char pit); +S_force_ident_maybe_lex(pTHX_ char pit) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_FORCE_IDENT_MAYBE_LEX STATIC void -S_force_next(pTHX_ I32 type); +S_force_next(pTHX_ I32 type) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_FORCE_NEXT STATIC char * S_force_strict_version(pTHX_ char *s) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FORCE_STRICT_VERSION \ assert(s) STATIC char * S_force_version(pTHX_ char *s, int guessing) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FORCE_VERSION \ assert(s) STATIC char * S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_FORCE_WORD \ assert(start) STATIC SV * S_get_and_check_backslash_N_name_wrapper(pTHX_ const char *s, const char * const e) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -11317,6 +12893,7 @@ S_get_and_check_backslash_N_name_wrapper(pTHX_ const char *s, const char * const STATIC void S_incline(pTHX_ const char *s, const char *end) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_INCLINE \ @@ -11324,12 +12901,14 @@ S_incline(pTHX_ const char *s, const char *end) STATIC int S_intuit_method(pTHX_ char *start, SV *ioname, CV *cv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_INTUIT_METHOD \ assert(start) STATIC int S_intuit_more(pTHX_ char *s, char *e) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_INTUIT_MORE \ @@ -11337,17 +12916,20 @@ S_intuit_more(pTHX_ char *s, char *e) STATIC I32 S_lop(pTHX_ enum yytokentype t, I32 f, U8 x, char *s) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_4); # define PERL_ARGS_ASSERT_LOP \ assert(s) PERL_STATIC_NO_RET void S_missingterm(pTHX_ char *s, STRLEN len) + Perl_attribute_nonnull_aTHX_ __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) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_5); # define PERL_ARGS_ASSERT_NEW_CONSTANT \ @@ -11355,6 +12937,7 @@ S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, STRLEN keylen, STATIC void S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_package, bool is_utf8, bool check_dollar) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -11362,11 +12945,13 @@ S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_package, bool assert(s); assert(d); assert(e) STATIC int -S_pending_ident(pTHX); +S_pending_ident(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PENDING_IDENT STATIC char * S_scan_const(pTHX_ char *start) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_CONST \ @@ -11374,6 +12959,7 @@ S_scan_const(pTHX_ char *start) STATIC char * S_scan_formline(pTHX_ char *s) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_FORMLINE \ @@ -11381,6 +12967,7 @@ S_scan_formline(pTHX_ char *s) STATIC char * S_scan_heredoc(pTHX_ char *s) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_HEREDOC \ @@ -11388,6 +12975,7 @@ S_scan_heredoc(pTHX_ char *s) STATIC char * S_scan_ident(pTHX_ char *s, char *dest, STRLEN destlen, I32 ck_uni) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SCAN_IDENT \ @@ -11395,6 +12983,7 @@ S_scan_ident(pTHX_ char *s, char *dest, STRLEN destlen, I32 ck_uni) STATIC char * S_scan_inputsymbol(pTHX_ char *start) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_INPUTSYMBOL \ @@ -11402,6 +12991,7 @@ S_scan_inputsymbol(pTHX_ char *start) STATIC char * S_scan_pat(pTHX_ char *start, I32 type) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_PAT \ @@ -11409,6 +12999,7 @@ S_scan_pat(pTHX_ char *start, I32 type) STATIC char * S_scan_subst(pTHX_ char *start) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_SUBST \ @@ -11416,6 +13007,7 @@ S_scan_subst(pTHX_ char *start) STATIC char * S_scan_trans(pTHX_ char *start) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_TRANS \ @@ -11423,21 +13015,25 @@ S_scan_trans(pTHX_ char *start) STATIC I32 S_sublex_done(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SUBLEX_DONE STATIC I32 S_sublex_push(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SUBLEX_PUSH STATIC I32 S_sublex_start(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SUBLEX_START STATIC char * S_swallow_bom(pTHX_ U8 *s) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SWALLOW_BOM \ @@ -11445,6 +13041,7 @@ S_swallow_bom(pTHX_ U8 *s) STATIC char * S_tokenize_use(pTHX_ int is_use, char *s) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_TOKENIZE_USE \ @@ -11452,28 +13049,33 @@ S_tokenize_use(pTHX_ int is_use, char *s) STATIC SV * S_tokeq(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_TOKEQ \ assert(sv) STATIC void -S_update_debugger_info(pTHX_ SV *orig_sv, const char * const buf, STRLEN len); +S_update_debugger_info(pTHX_ SV *orig_sv, const char * const buf, STRLEN len) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_UPDATE_DEBUGGER_INFO STATIC void S_warn_expect_operator(pTHX_ const char * const what, char *s, I32 pop_oldbufptr) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_WARN_EXPECT_OPERATOR \ assert(what) STATIC void S_yyerror_non_ascii_message(pTHX_ const U8 * const s) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_YYERROR_NON_ASCII_MESSAGE \ assert(s) STATIC int S_yywarn(pTHX_ const char * const s, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_YYWARN \ assert(s) @@ -11481,6 +13083,7 @@ S_yywarn(pTHX_ const char * const s, U32 flags) # if defined(DEBUGGING) STATIC void S_printbuf(pTHX_ const char * const fmt, const char * const s) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__format__(__printf__,pTHX_1,0); @@ -11489,6 +13092,7 @@ S_printbuf(pTHX_ const char * const fmt, const char * const s) STATIC int S_tokereport(pTHX_ I32 rv, const YYSTYPE *lvalp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_TOKEREPORT \ assert(lvalp) @@ -11497,12 +13101,14 @@ S_tokereport(pTHX_ I32 rv, const YYSTYPE *lvalp) # if !defined(PERL_NO_UTF16_FILTER) STATIC U8 * S_add_utf16_textfilter(pTHX_ U8 * const s, bool reversed) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_ADD_UTF16_TEXTFILTER \ assert(s) STATIC I32 S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_UTF16_TEXTFILTER \ assert(sv) @@ -11512,12 +13118,14 @@ S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen) #if defined(PERL_IN_UNIVERSAL_C) STATIC bool S_isa_lookup(pTHX_ HV *stash, SV *namesv, const char *name, STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_ISA_LOOKUP \ assert(stash); assert(SvTYPE(stash) == SVt_PVHV); assert(namesv || name) STATIC bool S_sv_derived_from_svpvn(pTHX_ SV *sv, SV *namesv, const char *name, const STRLEN len, U32 flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_DERIVED_FROM_SVPVN \ assert(sv); assert(namesv || name) @@ -11526,6 +13134,7 @@ S_sv_derived_from_svpvn(pTHX_ SV *sv, SV *namesv, const char *name, const STRLEN #if defined(PERL_IN_UTF8_C) STATIC UV S_check_locale_boundary_crossing(pTHX_ const U8 * const p, const UV result, U8 * const ustrp, STRLEN *lenp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) @@ -11535,6 +13144,7 @@ S_check_locale_boundary_crossing(pTHX_ const U8 * const p, const UV result, U8 * STATIC HV * S_new_msg_hv(pTHX_ const char * const message, U32 categories, U32 flag) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NEW_MSG_HV \ @@ -11542,6 +13152,7 @@ S_new_msg_hv(pTHX_ const char * const message, U32 categories, U32 flag) STATIC UV S_to_case_cp_list(pTHX_ const UV original, const U32 ** const remaining_list, Size_t *remaining_count, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_4) Perl_attribute_nonnull_(pTHX_5) Perl_attribute_nonnull_(pTHX_8); @@ -11555,6 +13166,7 @@ S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp, const char dummy) STATIC UV S_to_utf8_case_(pTHX_ const UV original, const U8 *p, U8 *ustrp, STRLEN *lenp, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) Perl_attribute_nonnull_(pTHX_5) @@ -11566,6 +13178,7 @@ S_to_utf8_case_(pTHX_ const UV original, const U8 *p, U8 *ustrp, STRLEN *lenp, S STATIC UV S_turkic_fc(pTHX_ const U8 * const p, const U8 * const e, U8 *ustrp, STRLEN *lenp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -11575,6 +13188,7 @@ S_turkic_fc(pTHX_ const U8 * const p, const U8 * const e, U8 *ustrp, STRLEN *len STATIC UV S_turkic_lc(pTHX_ const U8 * const p0, const U8 * const e, U8 *ustrp, STRLEN *lenp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -11584,6 +13198,7 @@ S_turkic_lc(pTHX_ const U8 * const p0, const U8 * const e, U8 *ustrp, STRLEN *le STATIC UV S_turkic_uc(pTHX_ const U8 * const p, const U8 * const e, U8 *ustrp, STRLEN *lenp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) @@ -11593,6 +13208,7 @@ S_turkic_uc(pTHX_ const U8 * const p, const U8 * const e, U8 *ustrp, STRLEN *len STATIC char * S_unexpected_non_continuation_text(pTHX_ const U8 * const s, STRLEN print_len, const STRLEN non_cont_byte_pos, const STRLEN expect_len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_UNEXPECTED_NON_CONTINUATION_TEXT \ @@ -11601,6 +13217,7 @@ S_unexpected_non_continuation_text(pTHX_ const U8 * const s, STRLEN print_len, c # if 0 STATIC void S_warn_on_first_deprecated_use(pTHX_ U32 category, const char * const name, const char * const alternative, const bool use_locale, const char * const file, const unsigned line) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_5); @@ -11635,21 +13252,25 @@ S_is_utf8_overlong(const U8 * const s, const STRLEN len) #endif /* defined(PERL_IN_UTF8_C) */ #if defined(PERL_IN_UTIL_C) STATIC bool -S_ckwarn_common(pTHX_ U32 w); +S_ckwarn_common(pTHX_ U32 w) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_CKWARN_COMMON STATIC SV * -S_mess_alloc(pTHX); +S_mess_alloc(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_MESS_ALLOC STATIC SV * S_with_queued_errors(pTHX_ SV *ex) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS \ assert(ex) STATIC void S_xs_version_bootcheck(pTHX_ SSize_t items, SSize_t ax, const char *xs_p, STRLEN xs_len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_XS_VERSION_BOOTCHECK \ assert(xs_p) @@ -11672,7 +13293,8 @@ S_ptr_hash(PTRV u); # endif # if defined(PERL_USES_PL_PIDSTATUS) STATIC void -S_pidgone(pTHX_ Pid_t pid, int status); +S_pidgone(pTHX_ Pid_t pid, int status) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PIDGONE # endif @@ -11721,6 +13343,7 @@ Perl_mem_log_realloc(const UV n, const UV typesize, const char *type_name, Mallo #if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE SSize_t Perl_AvFILL_(pTHX_ AV *av) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_AVFILL_ \ @@ -11734,12 +13357,14 @@ Perl_CvDEPTH(const CV * const sv) PERL_STATIC_INLINE GV * Perl_CvGV(pTHX_ CV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CVGV \ assert(sv); assert(SvTYPE(sv) == SVt_PVCV || SvTYPE(sv) == SVt_PVFM) PERL_STATIC_INLINE Stack_off_t -Perl_POPMARK(pTHX); +Perl_POPMARK(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_POPMARK PERL_STATIC_INLINE struct regexp * @@ -11762,36 +13387,42 @@ Perl_SvAMAGIC_on(SV *sv) PERL_STATIC_INLINE void Perl_SvGETMAGIC(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVGETMAGIC \ assert(sv) PERL_STATIC_INLINE IV Perl_SvIV(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVIV \ assert(sv) PERL_STATIC_INLINE IV Perl_SvIV_nomg(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVIV_NOMG \ assert(sv) PERL_STATIC_INLINE NV Perl_SvNV(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVNV \ assert(sv) PERL_STATIC_INLINE NV Perl_SvNV_nomg(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVNV_NOMG \ assert(sv) PERL_STATIC_FORCE_INLINE bool Perl_SvPVXtrue(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__always_inline__; # define PERL_ARGS_ASSERT_SVPVXTRUE \ @@ -11799,6 +13430,7 @@ Perl_SvPVXtrue(pTHX_ SV *sv) PERL_STATIC_FORCE_INLINE char * Perl_SvPV_helper(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags, const PL_SvPVtype type, Perl_SvPV_helper_non_trivial_t non_trivial, const bool or_null, const U32 return_flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_5) __attribute__always_inline__; @@ -11806,17 +13438,20 @@ Perl_SvPV_helper(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags, const assert(sv); assert(non_trivial) PERL_STATIC_INLINE void -Perl_SvREFCNT_dec(pTHX_ SV *sv); +Perl_SvREFCNT_dec(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_SVREFCNT_DEC PERL_STATIC_INLINE void Perl_SvREFCNT_dec_NN(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVREFCNT_DEC_NN \ assert(sv) PERL_STATIC_INLINE SV * -Perl_SvREFCNT_dec_ret_NULL(pTHX_ SV *sv); +Perl_SvREFCNT_dec_ret_NULL(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_SVREFCNT_DEC_RET_NULL PERL_STATIC_INLINE SV * @@ -11834,39 +13469,46 @@ Perl_SvREFCNT_inc_void(SV *sv); # define PERL_ARGS_ASSERT_SVREFCNT_INC_VOID PERL_STATIC_INLINE bool -Perl_SvTRUE(pTHX_ SV *sv); +Perl_SvTRUE(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_SVTRUE PERL_STATIC_INLINE bool Perl_SvTRUE_NN(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVTRUE_NN \ assert(sv) PERL_STATIC_INLINE bool Perl_SvTRUE_common(pTHX_ SV *sv, const bool sv_2bool_is_fallback) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVTRUE_COMMON \ assert(sv) PERL_STATIC_INLINE bool -Perl_SvTRUE_nomg(pTHX_ SV *sv); +Perl_SvTRUE_nomg(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_SVTRUE_NOMG PERL_STATIC_INLINE UV Perl_SvUV(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVUV \ assert(sv) PERL_STATIC_INLINE UV Perl_SvUV_nomg(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SVUV_NOMG \ assert(sv) PERL_STATIC_INLINE Stack_off_t -Perl_TOPMARK(pTHX); +Perl_TOPMARK(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_TOPMARK # define PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE \ @@ -11874,6 +13516,7 @@ Perl_TOPMARK(pTHX); PERL_STATIC_INLINE Size_t Perl_av_count(pTHX_ AV *av) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_AV_COUNT \ @@ -11881,6 +13524,7 @@ Perl_av_count(pTHX_ AV *av) PERL_STATIC_INLINE SV ** Perl_av_fetch_simple(pTHX_ AV *av, SSize_t key, I32 lval) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_AV_FETCH_SIMPLE \ @@ -11888,12 +13532,14 @@ Perl_av_fetch_simple(pTHX_ AV *av, SSize_t key, I32 lval) PERL_STATIC_INLINE AV * Perl_av_new_alloc(pTHX_ SSize_t size, bool zeroflag) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_AV_NEW_ALLOC \ assert(size > 0) PERL_STATIC_INLINE void Perl_av_push_simple(pTHX_ AV *av, SV *val) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_AV_PUSH_SIMPLE \ @@ -11901,18 +13547,21 @@ Perl_av_push_simple(pTHX_ AV *av, SV *val) PERL_STATIC_INLINE void Perl_av_remove_offset(pTHX_ AV *av) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_AV_REMOVE_OFFSET \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_STATIC_INLINE SV ** Perl_av_store_simple(pTHX_ AV *av, SSize_t key, SV *val) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_AV_STORE_SIMPLE \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_STATIC_INLINE U8 * Perl_bytes_to_utf8(pTHX_ const U8 *s, STRLEN *lenp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_BYTES_TO_UTF8 \ @@ -11920,6 +13569,7 @@ Perl_bytes_to_utf8(pTHX_ const U8 *s, STRLEN *lenp) PERL_STATIC_INLINE U8 * Perl_bytes_to_utf8_temp_pv(pTHX_ const U8 *s, STRLEN *lenp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_BYTES_TO_UTF8_TEMP_PV \ @@ -11927,12 +13577,14 @@ Perl_bytes_to_utf8_temp_pv(pTHX_ const U8 *s, STRLEN *lenp) PERL_STATIC_INLINE void Perl_clear_defarray_simple(pTHX_ AV *av) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CLEAR_DEFARRAY_SIMPLE \ assert(av); assert(SvTYPE(av) == SVt_PVAV) PERL_STATIC_INLINE I32 Perl_foldEQ(pTHX_ const char *a, const char *b, I32 len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_FOLDEQ \ @@ -11940,6 +13592,7 @@ Perl_foldEQ(pTHX_ const char *a, const char *b, I32 len) PERL_STATIC_INLINE I32 Perl_foldEQ_latin1(pTHX_ const char *a, const char *b, I32 len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_FOLDEQ_LATIN1 \ @@ -11947,6 +13600,7 @@ Perl_foldEQ_latin1(pTHX_ const char *a, const char *b, I32 len) PERL_STATIC_INLINE I32 Perl_foldEQ_locale(pTHX_ const char *a, const char *b, I32 len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_FOLDEQ_LOCALE \ @@ -11954,6 +13608,7 @@ Perl_foldEQ_locale(pTHX_ const char *a, const char *b, I32 len) PERL_STATIC_INLINE MGVTBL * Perl_get_vtbl(pTHX_ int vtbl_id) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_GET_VTBL @@ -11997,6 +13652,7 @@ Perl_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRL PERL_STATIC_INLINE bool Perl_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3) Perl_attribute_nonnull_(pTHX_4) @@ -12069,11 +13725,13 @@ Perl_msbit_pos32(U32 word) PERL_STATIC_INLINE OP * Perl_newPADxVOP(pTHX_ I32 type, I32 flags, PADOFFSET padix) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NEWPADXVOP PERL_STATIC_INLINE SV * Perl_newRV_noinc(pTHX_ SV * const tmpRef) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NEWRV_NOINC \ @@ -12081,103 +13739,123 @@ Perl_newRV_noinc(pTHX_ SV * const tmpRef) PERL_STATIC_INLINE SV * Perl_newSV_type(pTHX_ const svtype type) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NEWSV_TYPE PERL_STATIC_FORCE_INLINE SV * Perl_newSV_type_mortal(pTHX_ const svtype type) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__ __attribute__always_inline__; # define PERL_ARGS_ASSERT_NEWSV_TYPE_MORTAL PERL_STATIC_INLINE SV * Perl_newSVsv_flags(pTHX_ SV * const old, I32 flags) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NEWSVSV_FLAGS PERL_STATIC_INLINE SV * Perl_new_sv(pTHX_ const char *file, int line, const char *func) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_NEW_SV \ assert(file); assert(func) PERL_STATIC_INLINE void -Perl_pop_stackinfo(pTHX); +Perl_pop_stackinfo(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_POP_STACKINFO PERL_STATIC_INLINE void -Perl_push_stackinfo(pTHX_ I32 type, UV flags); +Perl_push_stackinfo(pTHX_ I32 type, UV flags) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PUSH_STACKINFO PERL_STATIC_INLINE void Perl_rpp_context(pTHX_ SV **mark, U8 gimme, SSize_t extra) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_CONTEXT \ assert(mark) PERL_STATIC_INLINE void -Perl_rpp_extend(pTHX_ SSize_t n); +Perl_rpp_extend(pTHX_ SSize_t n) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_RPP_EXTEND PERL_STATIC_INLINE void Perl_rpp_invoke_xs(pTHX_ CV *cv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_INVOKE_XS \ assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_STATIC_INLINE bool Perl_rpp_is_lone(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_IS_LONE \ assert(sv) PERL_STATIC_INLINE SV * -Perl_rpp_pop_1_norc(pTHX); +Perl_rpp_pop_1_norc(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_RPP_POP_1_NORC PERL_STATIC_INLINE void -Perl_rpp_popfree_1(pTHX); +Perl_rpp_popfree_1(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_RPP_POPFREE_1 PERL_STATIC_INLINE void -Perl_rpp_popfree_1_NN(pTHX); +Perl_rpp_popfree_1_NN(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_RPP_POPFREE_1_NN PERL_STATIC_INLINE void -Perl_rpp_popfree_2(pTHX); +Perl_rpp_popfree_2(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_RPP_POPFREE_2 PERL_STATIC_INLINE void -Perl_rpp_popfree_2_NN(pTHX); +Perl_rpp_popfree_2_NN(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_RPP_POPFREE_2_NN PERL_STATIC_INLINE void Perl_rpp_popfree_to(pTHX_ SV **sp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_POPFREE_TO \ assert(sp) PERL_STATIC_INLINE void Perl_rpp_popfree_to_NN(pTHX_ SV **sp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_POPFREE_TO_NN \ assert(sp) PERL_STATIC_INLINE void Perl_rpp_push_1(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_PUSH_1 \ assert(sv) PERL_STATIC_INLINE void Perl_rpp_push_1_norc(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_PUSH_1_NORC \ assert(sv) PERL_STATIC_INLINE void Perl_rpp_push_2(pTHX_ SV *sv1, SV *sv2) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_RPP_PUSH_2 \ @@ -12185,54 +13863,63 @@ Perl_rpp_push_2(pTHX_ SV *sv1, SV *sv2) PERL_STATIC_INLINE void Perl_rpp_push_IMM(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_PUSH_IMM \ assert(sv) PERL_STATIC_INLINE void Perl_rpp_replace_1_1(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_REPLACE_1_1 \ assert(sv) PERL_STATIC_INLINE void Perl_rpp_replace_1_1_NN(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_REPLACE_1_1_NN \ assert(sv) PERL_STATIC_INLINE void Perl_rpp_replace_1_IMM_NN(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_REPLACE_1_IMM_NN \ assert(sv) PERL_STATIC_INLINE void Perl_rpp_replace_2_1(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_REPLACE_2_1 \ assert(sv) PERL_STATIC_INLINE void Perl_rpp_replace_2_1_COMMON(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_REPLACE_2_1_COMMON \ assert(sv) PERL_STATIC_INLINE void Perl_rpp_replace_2_1_NN(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_REPLACE_2_1_NN \ assert(sv) PERL_STATIC_INLINE void Perl_rpp_replace_2_IMM_NN(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_REPLACE_2_IMM_NN \ assert(sv) PERL_STATIC_INLINE void Perl_rpp_replace_at(pTHX_ SV **sp, SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_RPP_REPLACE_AT \ @@ -12240,6 +13927,7 @@ Perl_rpp_replace_at(pTHX_ SV **sp, SV *sv) PERL_STATIC_INLINE void Perl_rpp_replace_at_NN(pTHX_ SV **sp, SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_RPP_REPLACE_AT_NN \ @@ -12247,6 +13935,7 @@ Perl_rpp_replace_at_NN(pTHX_ SV **sp, SV *sv) PERL_STATIC_INLINE void Perl_rpp_replace_at_norc(pTHX_ SV **sp, SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_RPP_REPLACE_AT_NORC \ @@ -12254,31 +13943,37 @@ Perl_rpp_replace_at_norc(pTHX_ SV **sp, SV *sv) PERL_STATIC_INLINE void Perl_rpp_replace_at_norc_NN(pTHX_ SV **sp, SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_RPP_REPLACE_AT_NORC_NN \ assert(sp); assert(sv) PERL_STATIC_INLINE bool -Perl_rpp_stack_is_rc(pTHX); +Perl_rpp_stack_is_rc(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_RPP_STACK_IS_RC PERL_STATIC_INLINE bool -Perl_rpp_try_AMAGIC_1(pTHX_ int method, int flags); +Perl_rpp_try_AMAGIC_1(pTHX_ int method, int flags) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_RPP_TRY_AMAGIC_1 PERL_STATIC_INLINE bool -Perl_rpp_try_AMAGIC_2(pTHX_ int method, int flags); +Perl_rpp_try_AMAGIC_2(pTHX_ int method, int flags) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_RPP_TRY_AMAGIC_2 PERL_STATIC_INLINE void Perl_rpp_xpush_1(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_XPUSH_1 \ assert(sv) PERL_STATIC_INLINE void Perl_rpp_xpush_2(pTHX_ SV *sv1, SV *sv2) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_RPP_XPUSH_2 \ @@ -12286,24 +13981,28 @@ Perl_rpp_xpush_2(pTHX_ SV *sv1, SV *sv2) PERL_STATIC_INLINE void Perl_rpp_xpush_IMM(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_RPP_XPUSH_IMM \ assert(sv) PERL_STATIC_INLINE char * Perl_savepv(pTHX_ const char *pv) + Perl_attribute_nonnull_aTHX_ __attribute__malloc__ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SAVEPV PERL_STATIC_INLINE char * Perl_savepvn(pTHX_ const char *pv, Size_t len) + Perl_attribute_nonnull_aTHX_ __attribute__malloc__ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SAVEPVN PERL_STATIC_INLINE char * Perl_savesharedsvpv(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__malloc__ __attribute__warn_unused_result__; @@ -12312,6 +14011,7 @@ Perl_savesharedsvpv(pTHX_ SV *sv) PERL_STATIC_INLINE char * Perl_savesvpv(pTHX_ SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__malloc__ __attribute__warn_unused_result__; @@ -12328,30 +14028,35 @@ Perl_single_1bit_pos32(U32 word) PERL_STATIC_INLINE char * Perl_sv_pvbyten_force_wrapper(pTHX_ SV * const sv, STRLEN * const lp, const U32 dummy) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE_WRAPPER \ assert(sv) PERL_STATIC_INLINE char * Perl_sv_pvutf8n_force_wrapper(pTHX_ SV * const sv, STRLEN * const lp, const U32 dummy) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE_WRAPPER \ assert(sv) PERL_STATIC_INLINE char * Perl_sv_setpv_freshbuf(pTHX_ SV * const sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SV_SETPV_FRESHBUF \ assert(sv) PERL_STATIC_INLINE void Perl_switch_argstack(pTHX_ AV *to) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_SWITCH_ARGSTACK \ assert(to); assert(SvTYPE(to) == SVt_PVAV) PERL_STATIC_INLINE IV Perl_utf8_distance(pTHX_ const U8 *a, const U8 *b) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -12392,6 +14097,7 @@ Perl_utf8_hop_overshoot(const U8 *s, SSize_t off, const U8 * const start, const PERL_STATIC_INLINE bool Perl_utf8_to_bytes_new_pv(pTHX_ U8 const **s_ptr, STRLEN *lenp, void **free_me) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -12400,6 +14106,7 @@ Perl_utf8_to_bytes_new_pv(pTHX_ U8 const **s_ptr, STRLEN *lenp, void **free_me) PERL_STATIC_INLINE bool Perl_utf8_to_bytes_overwrite(pTHX_ U8 **s_ptr, STRLEN *lenp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_UTF8_TO_BYTES_OVERWRITE \ @@ -12407,6 +14114,7 @@ Perl_utf8_to_bytes_overwrite(pTHX_ U8 **s_ptr, STRLEN *lenp) PERL_STATIC_INLINE bool Perl_utf8_to_bytes_temp_pv(pTHX_ U8 const **s_ptr, STRLEN *lenp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_UTF8_TO_BYTES_TEMP_PV \ @@ -12429,6 +14137,7 @@ Perl_utf8_to_uv_or_die(const U8 * const s, const U8 *e, Size_t *advance_p) PERL_STATIC_INLINE UV Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF \ @@ -12442,12 +14151,14 @@ Perl_utf8n_to_uvchr_msgs(const U8 * const s0, STRLEN curlen, STRLEN *retlen, con PERL_STATIC_INLINE U8 * Perl_uv_to_utf8(pTHX_ U8 *d, UV uv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_UV_TO_UTF8 \ assert(d) PERL_STATIC_INLINE U8 * Perl_uv_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_UV_TO_UTF8_FLAGS \ assert(d) @@ -12461,72 +14172,84 @@ Perl_valid_utf8_to_uv(const U8 *s, STRLEN *retlen) PERL_STATIC_INLINE void Perl_cx_popblock(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPBLOCK \ assert(cx) PERL_STATIC_INLINE void Perl_cx_popeval(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPEVAL \ assert(cx) PERL_STATIC_INLINE void Perl_cx_popformat(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPFORMAT \ assert(cx) PERL_STATIC_INLINE void Perl_cx_popgiven(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPGIVEN \ assert(cx) PERL_STATIC_INLINE void Perl_cx_poploop(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPLOOP \ assert(cx) PERL_STATIC_INLINE void Perl_cx_popsub(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPSUB \ assert(cx) PERL_STATIC_INLINE void Perl_cx_popsub_args(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPSUB_ARGS \ assert(cx) PERL_STATIC_INLINE void Perl_cx_popsub_common(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPSUB_COMMON \ assert(cx) PERL_STATIC_INLINE void Perl_cx_popwhen(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_POPWHEN \ assert(cx) PERL_STATIC_INLINE PERL_CONTEXT * Perl_cx_pushblock(pTHX_ U8 type, U8 gimme, SV **sp, I32 saveix) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_CX_PUSHBLOCK \ assert(sp) PERL_STATIC_INLINE void Perl_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_PUSHEVAL \ assert(cx) PERL_STATIC_INLINE void Perl_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CX_PUSHFORMAT \ @@ -12535,12 +14258,14 @@ Perl_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv) PERL_STATIC_INLINE void Perl_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_PUSHGIVEN \ assert(cx) PERL_STATIC_INLINE void Perl_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV *itersave) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CX_PUSHLOOP_FOR \ @@ -12548,12 +14273,14 @@ Perl_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV *itersave) PERL_STATIC_INLINE void Perl_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_PUSHLOOP_PLAIN \ assert(cx) PERL_STATIC_INLINE void Perl_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_CX_PUSHSUB \ @@ -12562,24 +14289,28 @@ Perl_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs) PERL_STATIC_INLINE void Perl_cx_pushtry(pTHX_ PERL_CONTEXT *cx, OP *retop) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_PUSHTRY \ assert(cx) PERL_STATIC_INLINE void Perl_cx_pushwhen(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_PUSHWHEN \ assert(cx) PERL_STATIC_INLINE void Perl_cx_topblock(pTHX_ PERL_CONTEXT *cx) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_CX_TOPBLOCK \ assert(cx) PERL_STATIC_INLINE U8 -Perl_gimme_V(pTHX); +Perl_gimme_V(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_GIMME_V # if !defined(HAS_STRLCAT) @@ -12604,6 +14335,7 @@ Perl_is_utf8_non_invariant_string(const U8 * const s, STRLEN len) PERL_STATIC_INLINE STRLEN S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SV_OR_PV_POS_U2B \ @@ -12656,9 +14388,11 @@ S_is_invlist(const SV * const invlist) defined(PERL_IN_REGCOMP_ANY) PERL_STATIC_INLINE SV * S_add_cp_to_invlist(pTHX_ SV *invlist, const UV cp) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; PERL_STATIC_INLINE void S_invlist_extend(pTHX_ SV * const invlist, const UV len) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_STATIC_INLINE UV S_invlist_highest(SV * const invlist) @@ -12666,6 +14400,7 @@ S_invlist_highest(SV * const invlist) __attribute__warn_unused_result__; PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV * const invlist, const UV len, const bool offset) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # endif /* defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_REGCOMP_ANY) */ @@ -12788,6 +14523,7 @@ Perl_single_1bit_pos64(U64 word) # if defined(USE_ITHREADS) PERL_STATIC_INLINE AV * Perl_cop_file_avn(pTHX_ const COP *cop) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_COP_FILE_AVN \ assert(cop) @@ -12806,11 +14542,13 @@ Perl_get_context(void) assert(real_pp_fn) PERL_CALLCONV int -Perl_runops_wrap(pTHX); +Perl_runops_wrap(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_RUNOPS_WRAP PERL_CALLCONV void Perl_xs_wrap(pTHX_ XSUBADDR_t xsub, CV *cv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_XS_WRAP \ @@ -12820,6 +14558,7 @@ Perl_xs_wrap(pTHX_ XSUBADDR_t xsub, CV *cv) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV OP * Perl_pp_wrap(pTHX_ Perl_ppaddr_t real_pp_fn, I32 nargs, int nlists) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # endif #endif /* defined(PERL_RC_STACK) */ @@ -12850,6 +14589,7 @@ Perl_sighandler(int sig) #if defined(UNLINK_ALL_VERSIONS) PERL_CALLCONV I32 Perl_unlnk(pTHX_ const char *f) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_UNLNK \ assert(f) @@ -12858,20 +14598,24 @@ Perl_unlnk(pTHX_ const char *f) #if defined(USE_C_BACKTRACE) PERL_CALLCONV bool Perl_dump_c_backtrace(pTHX_ PerlIO *fp, int max_depth, int skip) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE \ assert(fp) /* PERL_CALLCONV void -free_c_backtrace(pTHX_ Perl_c_backtrace *bt); */ +free_c_backtrace(pTHX_ Perl_c_backtrace *bt) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV Perl_c_backtrace * Perl_get_c_backtrace(pTHX_ int max_depth, int skip) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_GET_C_BACKTRACE PERL_CALLCONV SV * -Perl_get_c_backtrace_dump(pTHX_ int max_depth, int skip); +Perl_get_c_backtrace_dump(pTHX_ int max_depth, int skip) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_GET_C_BACKTRACE_DUMP #endif /* defined(USE_C_BACKTRACE) */ @@ -12890,26 +14634,32 @@ Perl_get_c_backtrace_dump(pTHX_ int max_depth, int skip); # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV void Perl_dtrace_probe_call(pTHX_ CV *cv, bool is_call) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void Perl_dtrace_probe_load(pTHX_ const char *name, bool is_loading) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void Perl_dtrace_probe_op(pTHX_ const OP *op) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); PERL_CALLCONV void -Perl_dtrace_probe_phase(pTHX_ enum perl_phase phase); +Perl_dtrace_probe_phase(pTHX_ enum perl_phase phase) + Perl_attribute_nonnull_aTHX_; # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ #endif /* defined(USE_DTRACE) */ #if defined(USE_ITHREADS) PERL_CALLCONV PADOFFSET Perl_alloccopstash(pTHX_ HV *hv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_ALLOCCOPSTASH \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void * Perl_any_dup(pTHX_ void *v, const PerlInterpreter *proto_perl) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_ANY_DUP \ @@ -12931,6 +14681,7 @@ Perl_clone_params_new(PerlInterpreter * const from, PerlInterpreter * const to) PERL_CALLCONV PERL_CONTEXT * Perl_cx_dup(pTHX_ PERL_CONTEXT *cx, I32 ix, I32 max, CLONE_PARAMS *param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_4) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_CX_DUP \ @@ -12938,6 +14689,7 @@ Perl_cx_dup(pTHX_ PERL_CONTEXT *cx, I32 ix, I32 max, CLONE_PARAMS *param) PERL_CALLCONV DIR * Perl_dirp_dup(pTHX_ DIR * const dp, CLONE_PARAMS * const param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DIRP_DUP \ @@ -12945,12 +14697,14 @@ Perl_dirp_dup(pTHX_ DIR * const dp, CLONE_PARAMS * const param) PERL_CALLCONV PerlIO * Perl_fp_dup(pTHX_ PerlIO * const fp, const char type, CLONE_PARAMS * const param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_FP_DUP \ assert(param) PERL_CALLCONV GP * Perl_gp_dup(pTHX_ GP * const gp, CLONE_PARAMS * const param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_GP_DUP \ @@ -12958,6 +14712,7 @@ Perl_gp_dup(pTHX_ GP * const gp, CLONE_PARAMS * const param) PERL_CALLCONV HE * Perl_he_dup(pTHX_ const HE *e, bool shared, CLONE_PARAMS *param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_HE_DUP \ @@ -12965,6 +14720,7 @@ Perl_he_dup(pTHX_ const HE *e, bool shared, CLONE_PARAMS *param) PERL_CALLCONV HEK * Perl_hek_dup(pTHX_ HEK *e, CLONE_PARAMS *param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_HEK_DUP \ @@ -12972,6 +14728,7 @@ Perl_hek_dup(pTHX_ HEK *e, CLONE_PARAMS *param) PERL_CALLCONV MAGIC * Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS * const param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_MG_DUP \ @@ -12979,6 +14736,7 @@ Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS * const param) PERL_CALLCONV struct mro_meta * Perl_mro_meta_dup(pTHX_ struct mro_meta *smeta, CLONE_PARAMS *param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -12987,6 +14745,7 @@ Perl_mro_meta_dup(pTHX_ struct mro_meta *smeta, CLONE_PARAMS *param) PERL_CALLCONV OP * Perl_newPADOP(pTHX_ I32 type, I32 flags, SV *sv) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_3) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NEWPADOP \ @@ -12994,6 +14753,7 @@ Perl_newPADOP(pTHX_ I32 type, I32 flags, SV *sv) PERL_CALLCONV PADLIST * Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__ @@ -13003,6 +14763,7 @@ Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param) PERL_CALLCONV PADNAME * Perl_padname_dup(pTHX_ PADNAME *src, CLONE_PARAMS *param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__ @@ -13012,6 +14773,7 @@ Perl_padname_dup(pTHX_ PADNAME *src, CLONE_PARAMS *param) PERL_CALLCONV PADNAMELIST * Perl_padnamelist_dup(pTHX_ PADNAMELIST *srcpad, CLONE_PARAMS *param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); @@ -13020,6 +14782,7 @@ Perl_padnamelist_dup(pTHX_ PADNAMELIST *srcpad, CLONE_PARAMS *param) PERL_CALLCONV yy_parser * Perl_parser_dup(pTHX_ const yy_parser * const proto, CLONE_PARAMS * const param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PARSER_DUP \ assert(param) @@ -13032,6 +14795,7 @@ perl_clone(PerlInterpreter *proto_perl, UV flags) PERL_CALLCONV void Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS *param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -13040,6 +14804,7 @@ Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS *param) PERL_CALLCONV void * Perl_regdupe_internal(pTHX_ REGEXP * const r, CLONE_PARAMS *param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_REGDUPE_INTERNAL \ @@ -13047,6 +14812,7 @@ Perl_regdupe_internal(pTHX_ REGEXP * const r, CLONE_PARAMS *param) PERL_CALLCONV void Perl_rvpv_dup(pTHX_ SV * const dsv, const SV * const ssv, CLONE_PARAMS * const param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); @@ -13055,6 +14821,7 @@ Perl_rvpv_dup(pTHX_ SV * const dsv, const SV * const ssv, CLONE_PARAMS * const p PERL_CALLCONV PERL_SI * Perl_si_dup(pTHX_ PERL_SI *si, CLONE_PARAMS *param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SI_DUP \ @@ -13062,6 +14829,7 @@ Perl_si_dup(pTHX_ PERL_SI *si, CLONE_PARAMS *param) PERL_CALLCONV ANY * Perl_ss_dup(pTHX_ PerlInterpreter *proto_perl, CLONE_PARAMS *param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; @@ -13070,6 +14838,7 @@ Perl_ss_dup(pTHX_ PerlInterpreter *proto_perl, CLONE_PARAMS *param) PERL_CALLCONV SV * Perl_sv_dup(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SV_DUP \ @@ -13077,6 +14846,7 @@ Perl_sv_dup(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) PERL_CALLCONV SV * Perl_sv_dup_inc(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SV_DUP_INC \ @@ -13085,6 +14855,7 @@ Perl_sv_dup_inc(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) # if defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) PERL_CALLCONV void Perl_op_relocate_sv(pTHX_ SV **svp, PADOFFSET *targp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -13094,12 +14865,14 @@ Perl_op_relocate_sv(pTHX_ SV **svp, PADOFFSET *targp) # endif /* defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) */ #else /* if !defined(USE_ITHREADS) */ /* PERL_CALLCONV void -Perl_CopFILEGV_set(pTHX_ COP *c, GV *gv); */ +Perl_CopFILEGV_set(pTHX_ COP *c, GV *gv) + Perl_attribute_nonnull_aTHX_; */ #endif #if defined(USE_LOCALE_COLLATE) PERL_CALLCONV int Perl_magic_freecollxfrm(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -13108,6 +14881,7 @@ Perl_magic_freecollxfrm(pTHX_ SV *sv, MAGIC *mg) PERL_CALLCONV int Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2) __attribute__visibility__("hidden"); @@ -13118,10 +14892,12 @@ Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg) assert(src) /* PERL_CALLCONV char * -Perl_sv_collxfrm(pTHX_ SV * const sv, STRLEN * const nxp); */ +Perl_sv_collxfrm(pTHX_ SV * const sv, STRLEN * const nxp) + Perl_attribute_nonnull_aTHX_; */ PERL_CALLCONV char * Perl_sv_collxfrm_flags(pTHX_ SV * const sv, STRLEN * const nxp, I32 const flags) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_SV_COLLXFRM_FLAGS \ @@ -13130,11 +14906,13 @@ Perl_sv_collxfrm_flags(pTHX_ SV * const sv, STRLEN * const nxp, I32 const flags) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV SV * Perl_strxfrm(pTHX_ SV *src) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # if defined(PERL_IN_LOCALE_C) || defined(PERL_IN_MATHOMS_C) || \ defined(PERL_IN_SV_C) PERL_CALLCONV char * Perl_mem_collxfrm_(pTHX_ const char *input_string, STRLEN len, STRLEN *xlen, bool utf8) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) Perl_attribute_nonnull_(pTHX_3) __attribute__visibility__("hidden"); @@ -13155,108 +14933,132 @@ Perl_warn_problematic_locale(void); #endif #if defined(USE_PERLIO) PERL_CALLCONV void -Perl_PerlIO_clearerr(pTHX_ PerlIO *f); +Perl_PerlIO_clearerr(pTHX_ PerlIO *f) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_CLEARERR PERL_CALLCONV int -Perl_PerlIO_close(pTHX_ PerlIO *f); +Perl_PerlIO_close(pTHX_ PerlIO *f) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_CLOSE PERL_CALLCONV int -Perl_PerlIO_eof(pTHX_ PerlIO *f); +Perl_PerlIO_eof(pTHX_ PerlIO *f) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_EOF PERL_CALLCONV int -Perl_PerlIO_error(pTHX_ PerlIO *f); +Perl_PerlIO_error(pTHX_ PerlIO *f) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_ERROR PERL_CALLCONV int -Perl_PerlIO_fileno(pTHX_ PerlIO *f); +Perl_PerlIO_fileno(pTHX_ PerlIO *f) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_FILENO PERL_CALLCONV int -Perl_PerlIO_fill(pTHX_ PerlIO *f); +Perl_PerlIO_fill(pTHX_ PerlIO *f) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_FILL PERL_CALLCONV int -Perl_PerlIO_flush(pTHX_ PerlIO *f); +Perl_PerlIO_flush(pTHX_ PerlIO *f) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_FLUSH PERL_CALLCONV STDCHAR * -Perl_PerlIO_get_base(pTHX_ PerlIO *f); +Perl_PerlIO_get_base(pTHX_ PerlIO *f) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_GET_BASE PERL_CALLCONV SSize_t Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_PERLIO_GET_BUFSIZ PERL_CALLCONV SSize_t Perl_PerlIO_get_cnt(pTHX_ PerlIO *f) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_PERLIO_GET_CNT PERL_CALLCONV STDCHAR * -Perl_PerlIO_get_ptr(pTHX_ PerlIO *f); +Perl_PerlIO_get_ptr(pTHX_ PerlIO *f) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_GET_PTR PERL_CALLCONV SSize_t Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PERLIO_READ \ assert(vbuf) PERL_CALLCONV void -Perl_PerlIO_restore_errno(pTHX_ PerlIO *f); +Perl_PerlIO_restore_errno(pTHX_ PerlIO *f) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_RESTORE_ERRNO PERL_CALLCONV void -Perl_PerlIO_save_errno(pTHX_ PerlIO *f); +Perl_PerlIO_save_errno(pTHX_ PerlIO *f) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_SAVE_ERRNO PERL_CALLCONV int -Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence); +Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_SEEK PERL_CALLCONV void -Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, SSize_t cnt); +Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, SSize_t cnt) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_SET_CNT PERL_CALLCONV void -Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR *ptr, SSize_t cnt); +Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR *ptr, SSize_t cnt) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_SET_PTRCNT PERL_CALLCONV void -Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f); +Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_SETLINEBUF PERL_CALLCONV PerlIO * Perl_PerlIO_stderr(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_PERLIO_STDERR PERL_CALLCONV PerlIO * Perl_PerlIO_stdin(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_PERLIO_STDIN PERL_CALLCONV PerlIO * Perl_PerlIO_stdout(pTHX) + Perl_attribute_nonnull_aTHX_ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_PERLIO_STDOUT PERL_CALLCONV Off_t -Perl_PerlIO_tell(pTHX_ PerlIO *f); +Perl_PerlIO_tell(pTHX_ PerlIO *f) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_PERLIO_TELL PERL_CALLCONV SSize_t Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PERLIO_UNREAD \ assert(vbuf) PERL_CALLCONV SSize_t Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2); # define PERL_ARGS_ASSERT_PERLIO_WRITE \ assert(vbuf) @@ -13264,7 +15066,8 @@ Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count) #endif /* defined(USE_PERLIO) */ #if defined(USE_PERL_SWITCH_LOCALE_CONTEXT) PERL_CALLCONV void -Perl_switch_locale_context(pTHX); +Perl_switch_locale_context(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_SWITCH_LOCALE_CONTEXT #endif @@ -13286,17 +15089,20 @@ Perl_quadmath_format_valid(const char *format) #endif /* defined(USE_QUADMATH) */ #if defined(USE_THREADS) PERL_CALLCONV void -Perl_thread_locale_init(pTHX); +Perl_thread_locale_init(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_THREAD_LOCALE_INIT PERL_CALLCONV void -Perl_thread_locale_term(pTHX); +Perl_thread_locale_term(pTHX) + Perl_attribute_nonnull_aTHX_; # define PERL_ARGS_ASSERT_THREAD_LOCALE_TERM -#endif +#endif /* defined(USE_THREADS) */ #if defined(VMS) || defined(WIN32) PERL_CALLCONV int Perl_do_aspawn(pTHX_ SV *really, SV **mark, SV **sp) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_2) Perl_attribute_nonnull_(pTHX_3); # define PERL_ARGS_ASSERT_DO_ASPAWN \ @@ -13304,12 +15110,14 @@ Perl_do_aspawn(pTHX_ SV *really, SV **mark, SV **sp) PERL_CALLCONV int Perl_do_spawn(pTHX_ char *cmd) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DO_SPAWN \ assert(cmd) PERL_CALLCONV int Perl_do_spawn_nowait(pTHX_ char *cmd) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1); # define PERL_ARGS_ASSERT_DO_SPAWN_NOWAIT \ assert(cmd) @@ -13323,6 +15131,7 @@ Perl_get_context(void) PERL_CALLCONV bool Perl_get_win32_message_utf8ness(pTHX_ const char *string) + Perl_attribute_nonnull_aTHX_ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_GET_WIN32_MESSAGE_UTF8NESS @@ -13336,6 +15145,7 @@ win32_croak_not_implemented(const char *fname) #else /* if !defined(WIN32) */ PERL_CALLCONV bool Perl_do_exec3(pTHX_ const char *incmd, int fd, int do_report) + Perl_attribute_nonnull_aTHX_ Perl_attribute_nonnull_(pTHX_1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_EXEC3 \ diff --git a/regen/embed.pl b/regen/embed.pl index c9c6ff5b406e..e89307a5c4e1 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -429,6 +429,8 @@ sub generate_proto_h { . " f or F flag"; } + unshift @attrs, "Perl_attribute_nonnull_aTHX_" if $has_context; + if ( @attrs ) { $ret .= "\n" . join( "\n", map { (" " x 8) . $_ } @attrs); @@ -496,6 +498,12 @@ sub generate_proto_h { # define Perl_attribute_nonnull_(which) __attribute__nonnull__(which) #endif + #if defined(MULTIPLICITY) + # define Perl_attribute_nonnull_aTHX_ __attribute__nonnull__(1) + #else + # define Perl_attribute_nonnull_aTHX_ + #endif + START_EXTERN_C $clean #ifdef PERL_CORE