xref: /openbsd/gnu/usr.bin/perl/proto.h (revision 3d61058a) 
1 /* -*- mode: C; buffer-read-only: t -*-
2  *
3  *    proto.h
4  *
5  *    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
6  *    2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013,
7  *    2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022
8  *    by Larry Wall and others
9  *
10  *    You may distribute under the terms of either the GNU General Public
11  *    License or the Artistic License, as specified in the README file.
12  *
13  * !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
14  * This file is built by regen/embed.pl from embed.fnc, intrpvar.h,
15  * perlvars.h, regen/opcodes, regen/embed.pl, regen/embed_lib.pl and
16  * regen/HeaderParser.pm.
17  * Any changes made here will be lost!
18  *
19  * Edit those files and run 'make regen_headers' to effect changes.
20  */
21 
22 START_EXTERN_C
23 PERL_CALLCONV int
24 Perl_Gv_AMupdate(pTHX_ HV *stash, bool destructing);
25 #define PERL_ARGS_ASSERT_GV_AMUPDATE            \
26         assert(stash)
27 
28 PERL_CALLCONV const char *
29 Perl_PerlIO_context_layers(pTHX_ const char *mode);
30 #define PERL_ARGS_ASSERT_PERLIO_CONTEXT_LAYERS
31 
32 PERL_CALLCONV int
33 Perl_PerlLIO_dup2_cloexec(pTHX_ int oldfd, int newfd)
34         __attribute__visibility__("hidden");
35 #define PERL_ARGS_ASSERT_PERLLIO_DUP2_CLOEXEC
36 
37 PERL_CALLCONV int
38 Perl_PerlLIO_dup_cloexec(pTHX_ int oldfd)
39         __attribute__warn_unused_result__
40         __attribute__visibility__("hidden");
41 #define PERL_ARGS_ASSERT_PERLLIO_DUP_CLOEXEC
42 
43 PERL_CALLCONV int
44 Perl_PerlLIO_open3_cloexec(pTHX_ const char *file, int flag, int perm)
45         __attribute__warn_unused_result__
46         __attribute__visibility__("hidden");
47 #define PERL_ARGS_ASSERT_PERLLIO_OPEN3_CLOEXEC  \
48         assert(file)
49 
50 PERL_CALLCONV int
51 Perl_PerlLIO_open_cloexec(pTHX_ const char *file, int flag)
52         __attribute__warn_unused_result__
53         __attribute__visibility__("hidden");
54 #define PERL_ARGS_ASSERT_PERLLIO_OPEN_CLOEXEC   \
55         assert(file)
56 
57 /* PERL_CALLCONV const XOP *
58 Perl_custom_op_xop(pTHX_ const OP *o); */
59 
60 PERL_CALLCONV const char *
61 Perl_langinfo(const nl_item item);
62 #define PERL_ARGS_ASSERT_PERL_LANGINFO
63 
64 PERL_CALLCONV const char *
65 Perl_langinfo8(const nl_item item, utf8ness_t *utf8ness);
66 #define PERL_ARGS_ASSERT_PERL_LANGINFO8         \
67         assert(utf8ness)
68 
69 PERL_CALLCONV HV *
70 Perl_localeconv(pTHX);
71 #define PERL_ARGS_ASSERT_PERL_LOCALECONV
72 
73 PERL_CALLCONV const char *
74 Perl_setlocale(const int category, const char *locale);
75 #define PERL_ARGS_ASSERT_PERL_SETLOCALE
76 
77 PERL_CALLCONV void *
78 Perl_Slab_Alloc(pTHX_ size_t sz)
79         __attribute__warn_unused_result__;
80 #define PERL_ARGS_ASSERT_SLAB_ALLOC
81 
82 PERL_CALLCONV void
83 Perl_Slab_Free(pTHX_ void *op);
84 #define PERL_ARGS_ASSERT_SLAB_FREE              \
85         assert(op)
86 
87 /* PERL_CALLCONV void
88 SvREFCNT_dec_set_NULL(pTHX_ SV *sv); */
89 
90 PERL_CALLCONV const char *
91 Perl__byte_dump_string(pTHX_ const U8 * const start, const STRLEN len, const bool format);
92 #define PERL_ARGS_ASSERT__BYTE_DUMP_STRING
93 
94 PERL_CALLCONV void
95 Perl__force_out_malformed_utf8_message(pTHX_ const U8 * const p, const U8 * const e, const U32 flags, const bool die_here);
96 #define PERL_ARGS_ASSERT__FORCE_OUT_MALFORMED_UTF8_MESSAGE \
97         assert(p); assert(e)
98 
99 PERL_CALLCONV Size_t
100 Perl__inverse_folds(pTHX_ const UV cp, U32 *first_folds_to, const U32 **remaining_folds_to)
101         __attribute__warn_unused_result__;
102 #define PERL_ARGS_ASSERT__INVERSE_FOLDS         \
103         assert(first_folds_to); assert(remaining_folds_to)
104 
105 PERL_CALLCONV bool
106 Perl__is_in_locale_category(pTHX_ const bool compiling, const int category);
107 #define PERL_ARGS_ASSERT__IS_IN_LOCALE_CATEGORY
108 
109 PERL_CALLCONV bool
110 Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c)
111         __attribute__warn_unused_result__;
112 #define PERL_ARGS_ASSERT__IS_UNI_FOO
113 
114 PERL_CALLCONV bool
115 Perl__is_uni_perl_idcont(pTHX_ UV c)
116         __attribute__warn_unused_result__;
117 #define PERL_ARGS_ASSERT__IS_UNI_PERL_IDCONT
118 
119 PERL_CALLCONV bool
120 Perl__is_uni_perl_idstart(pTHX_ UV c)
121         __attribute__warn_unused_result__;
122 #define PERL_ARGS_ASSERT__IS_UNI_PERL_IDSTART
123 
124 PERL_CALLCONV bool
125 Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p, const U8 * const e)
126         __attribute__warn_unused_result__;
127 #define PERL_ARGS_ASSERT__IS_UTF8_FOO           \
128         assert(p); assert(e)
129 
130 PERL_CALLCONV bool
131 Perl__is_utf8_perl_idcont(pTHX_ const U8 *p, const U8 * const e)
132         __attribute__warn_unused_result__;
133 #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT   \
134         assert(p); assert(e)
135 
136 PERL_CALLCONV bool
137 Perl__is_utf8_perl_idstart(pTHX_ const U8 *p, const U8 * const e)
138         __attribute__warn_unused_result__;
139 #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART  \
140         assert(p); assert(e)
141 
142 PERL_CALLCONV UV
143 Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags);
144 #define PERL_ARGS_ASSERT__TO_UNI_FOLD_FLAGS     \
145         assert(p); assert(lenp)
146 
147 PERL_CALLCONV UV
148 Perl__to_utf8_fold_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, U8 flags);
149 #define PERL_ARGS_ASSERT__TO_UTF8_FOLD_FLAGS    \
150         assert(p); assert(ustrp)
151 
152 PERL_CALLCONV UV
153 Perl__to_utf8_lower_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags);
154 #define PERL_ARGS_ASSERT__TO_UTF8_LOWER_FLAGS   \
155         assert(p); assert(ustrp)
156 
157 PERL_CALLCONV UV
158 Perl__to_utf8_title_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags);
159 #define PERL_ARGS_ASSERT__TO_UTF8_TITLE_FLAGS   \
160         assert(p); assert(ustrp)
161 
162 PERL_CALLCONV UV
163 Perl__to_utf8_upper_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags);
164 #define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS   \
165         assert(p); assert(ustrp)
166 
167 PERL_CALLCONV UV
168 Perl__utf8n_to_uvchr_msgs_helper(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 *errors, AV **msgs);
169 #define PERL_ARGS_ASSERT__UTF8N_TO_UVCHR_MSGS_HELPER \
170         assert(s)
171 
172 PERL_CALLCONV_NO_RET void
173 Perl_abort_execution(pTHX_ SV *msg_sv, const char * const name)
174         __attribute__noreturn__
175         __attribute__visibility__("hidden");
176 #define PERL_ARGS_ASSERT_ABORT_EXECUTION        \
177         assert(name)
178 
179 PERL_CALLCONV LOGOP *
180 Perl_alloc_LOGOP(pTHX_ I32 type, OP *first, OP *other)
181         __attribute__visibility__("hidden");
182 #define PERL_ARGS_ASSERT_ALLOC_LOGOP
183 
184 PERL_CALLCONV PADOFFSET
185 Perl_allocmy(pTHX_ const char * const name, const STRLEN len, const U32 flags)
186         __attribute__visibility__("hidden");
187 #define PERL_ARGS_ASSERT_ALLOCMY                \
188         assert(name)
189 
190 PERL_CALLCONV bool
191 Perl_amagic_applies(pTHX_ SV *sv, int method, int flags);
192 #define PERL_ARGS_ASSERT_AMAGIC_APPLIES         \
193         assert(sv)
194 
195 PERL_CALLCONV SV *
196 Perl_amagic_call(pTHX_ SV *left, SV *right, int method, int dir);
197 #define PERL_ARGS_ASSERT_AMAGIC_CALL            \
198         assert(left); assert(right)
199 
200 PERL_CALLCONV SV *
201 Perl_amagic_deref_call(pTHX_ SV *ref, int method);
202 #define PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL      \
203         assert(ref)
204 
205 PERL_CALLCONV bool
206 Perl_amagic_is_enabled(pTHX_ int method)
207         __attribute__visibility__("hidden");
208 #define PERL_ARGS_ASSERT_AMAGIC_IS_ENABLED
209 
210 PERL_CALLCONV SSize_t
211 Perl_apply(pTHX_ I32 type, SV **mark, SV **sp)
212         __attribute__visibility__("hidden");
213 #define PERL_ARGS_ASSERT_APPLY                  \
214         assert(mark); assert(sp)
215 
216 PERL_CALLCONV void
217 Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv, const char *attrstr, STRLEN len);
218 #define PERL_ARGS_ASSERT_APPLY_ATTRS_STRING     \
219         assert(stashpv); assert(cv); assert(attrstr)
220 
221 PERL_CALLCONV OP *
222 Perl_apply_builtin_cv_attributes(pTHX_ CV *cv, OP *attrlist);
223 #define PERL_ARGS_ASSERT_APPLY_BUILTIN_CV_ATTRIBUTES \
224         assert(cv)
225 
226 PERL_CALLCONV void
227 Perl_atfork_lock(void);
228 #define PERL_ARGS_ASSERT_ATFORK_LOCK
229 
230 PERL_CALLCONV void
231 Perl_atfork_unlock(void);
232 #define PERL_ARGS_ASSERT_ATFORK_UNLOCK
233 
234 PERL_CALLCONV SV **
235 Perl_av_arylen_p(pTHX_ AV *av);
236 #define PERL_ARGS_ASSERT_AV_ARYLEN_P            \
237         assert(av)
238 
239 PERL_CALLCONV void
240 Perl_av_clear(pTHX_ AV *av);
241 #define PERL_ARGS_ASSERT_AV_CLEAR               \
242         assert(av)
243 
244 PERL_CALLCONV void
245 Perl_av_create_and_push(pTHX_ AV ** const avp, SV * const val);
246 #define PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH     \
247         assert(avp); assert(val)
248 
249 PERL_CALLCONV SV **
250 Perl_av_create_and_unshift_one(pTHX_ AV ** const avp, SV * const val);
251 #define PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE \
252         assert(avp); assert(val)
253 
254 PERL_CALLCONV SV *
255 Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags);
256 #define PERL_ARGS_ASSERT_AV_DELETE              \
257         assert(av)
258 
259 PERL_CALLCONV void
260 Perl_av_dump(pTHX_ AV *av);
261 #define PERL_ARGS_ASSERT_AV_DUMP
262 
263 PERL_CALLCONV bool
264 Perl_av_exists(pTHX_ AV *av, SSize_t key)
265         __attribute__warn_unused_result__;
266 #define PERL_ARGS_ASSERT_AV_EXISTS              \
267         assert(av)
268 
269 PERL_CALLCONV void
270 Perl_av_extend(pTHX_ AV *av, SSize_t key);
271 #define PERL_ARGS_ASSERT_AV_EXTEND              \
272         assert(av)
273 
274 PERL_CALLCONV void
275 Perl_av_extend_guts(pTHX_ AV *av, SSize_t key, SSize_t *maxp, SV ***allocp, SV ***arrayp)
276         __attribute__visibility__("hidden");
277 #define PERL_ARGS_ASSERT_AV_EXTEND_GUTS         \
278         assert(maxp); assert(allocp); assert(arrayp)
279 
280 PERL_CALLCONV SV **
281 Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval)
282         __attribute__warn_unused_result__;
283 #define PERL_ARGS_ASSERT_AV_FETCH               \
284         assert(av)
285 
286 PERL_CALLCONV void
287 Perl_av_fill(pTHX_ AV *av, SSize_t fill);
288 #define PERL_ARGS_ASSERT_AV_FILL                \
289         assert(av)
290 
291 PERL_CALLCONV IV *
292 Perl_av_iter_p(pTHX_ AV *av);
293 #define PERL_ARGS_ASSERT_AV_ITER_P              \
294         assert(av)
295 
296 PERL_CALLCONV SSize_t
297 Perl_av_len(pTHX_ AV *av)
298         __attribute__warn_unused_result__;
299 #define PERL_ARGS_ASSERT_AV_LEN                 \
300         assert(av)
301 
302 PERL_CALLCONV AV *
303 Perl_av_make(pTHX_ SSize_t size, SV **strp)
304         __attribute__warn_unused_result__;
305 #define PERL_ARGS_ASSERT_AV_MAKE                \
306         assert(strp)
307 
308 PERL_CALLCONV SV *
309 Perl_av_nonelem(pTHX_ AV *av, SSize_t ix)
310         __attribute__visibility__("hidden");
311 #define PERL_ARGS_ASSERT_AV_NONELEM             \
312         assert(av)
313 
314 PERL_CALLCONV SV *
315 Perl_av_pop(pTHX_ AV *av);
316 #define PERL_ARGS_ASSERT_AV_POP                 \
317         assert(av)
318 
319 PERL_CALLCONV void
320 Perl_av_push(pTHX_ AV *av, SV *val);
321 #define PERL_ARGS_ASSERT_AV_PUSH                \
322         assert(av); assert(val)
323 
324 PERL_CALLCONV void
325 Perl_av_reify(pTHX_ AV *av);
326 #define PERL_ARGS_ASSERT_AV_REIFY               \
327         assert(av)
328 
329 PERL_CALLCONV SV *
330 Perl_av_shift(pTHX_ AV *av)
331         __attribute__warn_unused_result__;
332 #define PERL_ARGS_ASSERT_AV_SHIFT               \
333         assert(av)
334 
335 PERL_CALLCONV SV **
336 Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val);
337 #define PERL_ARGS_ASSERT_AV_STORE               \
338         assert(av)
339 
340 /* PERL_CALLCONV SSize_t
341 av_tindex(pTHX_ AV *av)
342         __attribute__warn_unused_result__; */
343 
344 /* PERL_CALLCONV SSize_t
345 av_top_index(pTHX_ AV *av)
346         __attribute__warn_unused_result__; */
347 
348 PERL_CALLCONV void
349 Perl_av_undef(pTHX_ AV *av);
350 #define PERL_ARGS_ASSERT_AV_UNDEF               \
351         assert(av)
352 
353 PERL_CALLCONV void
354 Perl_av_unshift(pTHX_ AV *av, SSize_t num);
355 #define PERL_ARGS_ASSERT_AV_UNSHIFT             \
356         assert(av)
357 
358 PERL_CALLCONV OP *
359 Perl_bind_match(pTHX_ I32 type, OP *left, OP *right)
360         __attribute__warn_unused_result__
361         __attribute__visibility__("hidden");
362 #define PERL_ARGS_ASSERT_BIND_MATCH             \
363         assert(left); assert(right)
364 
365 PERL_CALLCONV OP *
366 Perl_block_end(pTHX_ I32 floor, OP *seq)
367         __attribute__warn_unused_result__;
368 #define PERL_ARGS_ASSERT_BLOCK_END
369 
370 PERL_CALLCONV U8
371 Perl_block_gimme(pTHX)
372         __attribute__warn_unused_result__;
373 #define PERL_ARGS_ASSERT_BLOCK_GIMME
374 
375 PERL_CALLCONV int
376 Perl_block_start(pTHX_ int full)
377         __attribute__warn_unused_result__;
378 #define PERL_ARGS_ASSERT_BLOCK_START
379 
380 PERL_CALLCONV void
381 Perl_blockhook_register(pTHX_ BHK *hk);
382 #define PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER     \
383         assert(hk)
384 
385 PERL_CALLCONV void
386 Perl_boot_core_PerlIO(pTHX)
387         __attribute__visibility__("hidden");
388 #define PERL_ARGS_ASSERT_BOOT_CORE_PERLIO
389 
390 PERL_CALLCONV void
391 Perl_boot_core_UNIVERSAL(pTHX)
392         __attribute__visibility__("hidden");
393 #define PERL_ARGS_ASSERT_BOOT_CORE_UNIVERSAL
394 
395 PERL_CALLCONV void
396 Perl_boot_core_builtin(pTHX)
397         __attribute__visibility__("hidden");
398 #define PERL_ARGS_ASSERT_BOOT_CORE_BUILTIN
399 
400 PERL_CALLCONV void
401 Perl_boot_core_mro(pTHX)
402         __attribute__visibility__("hidden");
403 #define PERL_ARGS_ASSERT_BOOT_CORE_MRO
404 
405 PERL_CALLCONV OP *
406 Perl_build_infix_plugin(pTHX_ OP *lhs, OP *rhs, void *tokendata)
407         __attribute__visibility__("hidden");
408 #define PERL_ARGS_ASSERT_BUILD_INFIX_PLUGIN     \
409         assert(lhs); assert(rhs); assert(tokendata)
410 
411 PERL_CALLCONV int
412 Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen);
413 #define PERL_ARGS_ASSERT_BYTES_CMP_UTF8         \
414         assert(b); assert(u)
415 
416 PERL_CALLCONV U8 *
417 Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *lenp, bool *is_utf8p);
418 #define PERL_ARGS_ASSERT_BYTES_FROM_UTF8        \
419         assert(s); assert(lenp); assert(is_utf8p)
420 
421 PERL_CALLCONV U8 *
422 Perl_bytes_from_utf8_loc(const U8 *s, STRLEN *lenp, bool *is_utf8p, const U8 **first_unconverted);
423 #define PERL_ARGS_ASSERT_BYTES_FROM_UTF8_LOC    \
424         assert(s); assert(lenp); assert(is_utf8p)
425 
426 PERL_CALLCONV U8 *
427 Perl_bytes_to_utf8(pTHX_ const U8 *s, STRLEN *lenp);
428 #define PERL_ARGS_ASSERT_BYTES_TO_UTF8          \
429         assert(s); assert(lenp)
430 
431 PERL_CALLCONV SSize_t
432 Perl_call_argv(pTHX_ const char *sub_name, I32 flags, char **argv);
433 #define PERL_ARGS_ASSERT_CALL_ARGV              \
434         assert(sub_name); assert(argv)
435 
436 PERL_CALLCONV void
437 Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr);
438 #define PERL_ARGS_ASSERT_CALL_ATEXIT
439 
440 PERL_CALLCONV void
441 Perl_call_list(pTHX_ I32 oldscope, AV *paramList);
442 #define PERL_ARGS_ASSERT_CALL_LIST              \
443         assert(paramList)
444 
445 PERL_CALLCONV SSize_t
446 Perl_call_method(pTHX_ const char *methname, I32 flags);
447 #define PERL_ARGS_ASSERT_CALL_METHOD            \
448         assert(methname)
449 
450 PERL_CALLCONV SSize_t
451 Perl_call_pv(pTHX_ const char *sub_name, I32 flags);
452 #define PERL_ARGS_ASSERT_CALL_PV                \
453         assert(sub_name)
454 
455 PERL_CALLCONV SSize_t
456 Perl_call_sv(pTHX_ SV *sv, I32 flags);
457 #define PERL_ARGS_ASSERT_CALL_SV                \
458         assert(sv)
459 
460 PERL_CALLCONV const PERL_CONTEXT *
461 Perl_caller_cx(pTHX_ I32 level, const PERL_CONTEXT **dbcxp);
462 #define PERL_ARGS_ASSERT_CALLER_CX
463 
464 PERL_CALLCONV Malloc_t
465 Perl_calloc(MEM_SIZE elements, MEM_SIZE size)
466         __attribute__malloc__
467         __attribute__warn_unused_result__;
468 #define PERL_ARGS_ASSERT_CALLOC
469 
470 PERL_CALLCONV bool
471 Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t *statbufp)
472         __attribute__warn_unused_result__
473         __attribute__visibility__("hidden");
474 #define PERL_ARGS_ASSERT_CANDO                  \
475         assert(statbufp)
476 
477 PERL_CALLCONV I32
478 Perl_cast_i32(NV f)
479         __attribute__warn_unused_result__;
480 #define PERL_ARGS_ASSERT_CAST_I32
481 
482 PERL_CALLCONV IV
483 Perl_cast_iv(NV f)
484         __attribute__warn_unused_result__;
485 #define PERL_ARGS_ASSERT_CAST_IV
486 
487 PERL_CALLCONV U32
488 Perl_cast_ulong(NV f)
489         __attribute__warn_unused_result__;
490 #define PERL_ARGS_ASSERT_CAST_ULONG
491 
492 PERL_CALLCONV UV
493 Perl_cast_uv(NV f)
494         __attribute__warn_unused_result__;
495 #define PERL_ARGS_ASSERT_CAST_UV
496 
497 PERL_CALLCONV bool
498 Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len)
499         __attribute__visibility__("hidden");
500 #define PERL_ARGS_ASSERT_CHECK_UTF8_PRINT       \
501         assert(s)
502 
503 PERL_CALLCONV OP *
504 Perl_ck_entersub_args_core(pTHX_ OP *entersubop, GV *namegv, SV *protosv)
505         __attribute__visibility__("hidden");
506 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_CORE  \
507         assert(entersubop); assert(namegv); assert(protosv)
508 
509 PERL_CALLCONV OP *
510 Perl_ck_entersub_args_list(pTHX_ OP *entersubop);
511 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_LIST  \
512         assert(entersubop)
513 
514 PERL_CALLCONV OP *
515 Perl_ck_entersub_args_proto(pTHX_ OP *entersubop, GV *namegv, SV *protosv);
516 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO \
517         assert(entersubop); assert(namegv); assert(protosv)
518 
519 PERL_CALLCONV OP *
520 Perl_ck_entersub_args_proto_or_list(pTHX_ OP *entersubop, GV *namegv, SV *protosv);
521 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO_OR_LIST \
522         assert(entersubop); assert(namegv); assert(protosv)
523 
524 PERL_CALLCONV void
525 Perl_ck_warner(pTHX_ U32 err, const char *pat, ...)
526         __attribute__format__(__printf__,pTHX_2,pTHX_3);
527 #define PERL_ARGS_ASSERT_CK_WARNER              \
528         assert(pat)
529 
530 PERL_CALLCONV void
531 Perl_ck_warner_d(pTHX_ U32 err, const char *pat, ...)
532         __attribute__format__(__printf__,pTHX_2,pTHX_3);
533 #define PERL_ARGS_ASSERT_CK_WARNER_D            \
534         assert(pat)
535 
536 PERL_CALLCONV bool
537 Perl_ckwarn(pTHX_ U32 w)
538         __attribute__warn_unused_result__
539         __attribute__pure__;
540 #define PERL_ARGS_ASSERT_CKWARN
541 
542 PERL_CALLCONV bool
543 Perl_ckwarn_d(pTHX_ U32 w)
544         __attribute__warn_unused_result__
545         __attribute__pure__;
546 #define PERL_ARGS_ASSERT_CKWARN_D
547 
548 PERL_CALLCONV void
549 Perl_clear_defarray(pTHX_ AV *av, bool abandon);
550 #define PERL_ARGS_ASSERT_CLEAR_DEFARRAY         \
551         assert(av)
552 
553 PERL_CALLCONV const COP *
554 Perl_closest_cop(pTHX_ const COP *cop, const OP *o, const OP *curop, bool opnext)
555         __attribute__visibility__("hidden");
556 #define PERL_ARGS_ASSERT_CLOSEST_COP            \
557         assert(cop)
558 
559 PERL_CALLCONV OP *
560 Perl_cmpchain_extend(pTHX_ I32 type, OP *ch, OP *right)
561         __attribute__warn_unused_result__
562         __attribute__visibility__("hidden");
563 #define PERL_ARGS_ASSERT_CMPCHAIN_EXTEND        \
564         assert(ch)
565 
566 PERL_CALLCONV OP *
567 Perl_cmpchain_finish(pTHX_ OP *ch)
568         __attribute__warn_unused_result__
569         __attribute__visibility__("hidden");
570 #define PERL_ARGS_ASSERT_CMPCHAIN_FINISH        \
571         assert(ch)
572 
573 PERL_CALLCONV OP *
574 Perl_cmpchain_start(pTHX_ I32 type, OP *left, OP *right)
575         __attribute__warn_unused_result__
576         __attribute__visibility__("hidden");
577 #define PERL_ARGS_ASSERT_CMPCHAIN_START
578 
579 PERL_CALLCONV const char *
580 Perl_cntrl_to_mnemonic(const U8 c)
581         __attribute__warn_unused_result__;
582 #define PERL_ARGS_ASSERT_CNTRL_TO_MNEMONIC
583 
584 PERL_CALLCONV const char *
585 Perl_cop_fetch_label(pTHX_ COP * const cop, STRLEN *len, U32 *flags);
586 #define PERL_ARGS_ASSERT_COP_FETCH_LABEL        \
587         assert(cop)
588 
589 PERL_CALLCONV void
590 Perl_cop_store_label(pTHX_ COP * const cop, const char *label, STRLEN len, U32 flags);
591 #define PERL_ARGS_ASSERT_COP_STORE_LABEL        \
592         assert(cop); assert(label)
593 
594 PERL_CALLCONV SV *
595 Perl_core_prototype(pTHX_ SV *sv, const char *name, const int code, int * const opnum)
596         __attribute__visibility__("hidden");
597 #define PERL_ARGS_ASSERT_CORE_PROTOTYPE         \
598         assert(name)
599 
600 PERL_CALLCONV OP *
601 Perl_coresub_op(pTHX_ SV * const coreargssv, const int code, const int opnum)
602         __attribute__visibility__("hidden");
603 #define PERL_ARGS_ASSERT_CORESUB_OP             \
604         assert(coreargssv)
605 
606 PERL_CALLCONV void
607 Perl_create_eval_scope(pTHX_ OP *retop, SV **sp, U32 flags)
608         __attribute__visibility__("hidden");
609 #define PERL_ARGS_ASSERT_CREATE_EVAL_SCOPE      \
610         assert(sp)
611 
612 PERL_CALLCONV_NO_RET void
613 Perl_croak(pTHX_ const char *pat, ...)
614         __attribute__noreturn__
615         __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
616 #define PERL_ARGS_ASSERT_CROAK
617 
618 PERL_CALLCONV_NO_RET void
619 Perl_croak_caller(const char *pat, ...)
620         __attribute__noreturn__
621         __attribute__visibility__("hidden")
622         __attribute__format__null_ok__(__printf__,1,2);
623 #define PERL_ARGS_ASSERT_CROAK_CALLER
624 
625 PERL_STATIC_NO_RET void
626 Perl_croak_memory_wrap(void)
627         __attribute__noreturn__;
628 #define PERL_ARGS_ASSERT_CROAK_MEMORY_WRAP
629 
630 PERL_CALLCONV_NO_RET void
631 Perl_croak_no_mem(void)
632         __attribute__noreturn__
633         __attribute__visibility__("hidden");
634 #define PERL_ARGS_ASSERT_CROAK_NO_MEM
635 
636 PERL_CALLCONV_NO_RET void
637 Perl_croak_no_mem_ext(const char *context, STRLEN len)
638         __attribute__noreturn__
639         __attribute__visibility__("hidden");
640 #define PERL_ARGS_ASSERT_CROAK_NO_MEM_EXT       \
641         assert(context)
642 
643 PERL_CALLCONV_NO_RET void
644 Perl_croak_no_modify(void)
645         __attribute__noreturn__;
646 #define PERL_ARGS_ASSERT_CROAK_NO_MODIFY
647 
648 PERL_CALLCONV_NO_RET void
649 Perl_croak_popstack(void)
650         __attribute__noreturn__;
651 #define PERL_ARGS_ASSERT_CROAK_POPSTACK
652 
653 PERL_CALLCONV_NO_RET void
654 Perl_croak_sv(pTHX_ SV *baseex)
655         __attribute__noreturn__;
656 #define PERL_ARGS_ASSERT_CROAK_SV               \
657         assert(baseex)
658 
659 PERL_CALLCONV_NO_RET void
660 Perl_croak_xs_usage(const CV * const cv, const char * const params)
661         __attribute__noreturn__;
662 #define PERL_ARGS_ASSERT_CROAK_XS_USAGE         \
663         assert(cv); assert(params)
664 
665 PERL_CALLCONV Signal_t
666 Perl_csighandler1(int sig);
667 #define PERL_ARGS_ASSERT_CSIGHANDLER1
668 
669 PERL_CALLCONV Signal_t
670 Perl_csighandler3(int sig, Siginfo_t *info, void *uap);
671 #define PERL_ARGS_ASSERT_CSIGHANDLER3
672 
673 PERL_CALLCONV regexp_engine const *
674 Perl_current_re_engine(pTHX);
675 #define PERL_ARGS_ASSERT_CURRENT_RE_ENGINE
676 
677 PERL_CALLCONV XOPRETANY
678 Perl_custom_op_get_field(pTHX_ const OP *o, const xop_flags_enum field)
679         __attribute__warn_unused_result__;
680 #define PERL_ARGS_ASSERT_CUSTOM_OP_GET_FIELD    \
681         assert(o)
682 
683 PERL_CALLCONV void
684 Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop);
685 #define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER     \
686         assert(ppaddr); assert(xop)
687 
688 PERL_CALLCONV void
689 Perl_cv_ckproto_len_flags(pTHX_ const CV *cv, const GV *gv, const char *p, const STRLEN len, const U32 flags);
690 #define PERL_ARGS_ASSERT_CV_CKPROTO_LEN_FLAGS   \
691         assert(cv)
692 
693 PERL_CALLCONV CV *
694 Perl_cv_clone(pTHX_ CV *proto);
695 #define PERL_ARGS_ASSERT_CV_CLONE               \
696         assert(proto)
697 
698 PERL_CALLCONV CV *
699 Perl_cv_clone_into(pTHX_ CV *proto, CV *target)
700         __attribute__visibility__("hidden");
701 #define PERL_ARGS_ASSERT_CV_CLONE_INTO          \
702         assert(proto); assert(target)
703 
704 PERL_CALLCONV SV *
705 Perl_cv_const_sv(const CV * const cv)
706         __attribute__warn_unused_result__;
707 #define PERL_ARGS_ASSERT_CV_CONST_SV
708 
709 PERL_CALLCONV SV *
710 Perl_cv_const_sv_or_av(const CV * const cv)
711         __attribute__warn_unused_result__
712         __attribute__visibility__("hidden");
713 #define PERL_ARGS_ASSERT_CV_CONST_SV_OR_AV
714 
715 PERL_CALLCONV void
716 Perl_cv_forget_slab(pTHX_ CV *cv)
717         __attribute__visibility__("hidden");
718 #define PERL_ARGS_ASSERT_CV_FORGET_SLAB
719 
720 PERL_CALLCONV void
721 Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p);
722 #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER    \
723         assert(cv); assert(ckfun_p); assert(ckobj_p)
724 
725 PERL_CALLCONV void
726 Perl_cv_get_call_checker_flags(pTHX_ CV *cv, U32 gflags, Perl_call_checker *ckfun_p, SV **ckobj_p, U32 *ckflags_p);
727 #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER_FLAGS \
728         assert(cv); assert(ckfun_p); assert(ckobj_p); assert(ckflags_p)
729 
730 PERL_CALLCONV SV *
731 Perl_cv_name(pTHX_ CV *cv, SV *sv, U32 flags);
732 #define PERL_ARGS_ASSERT_CV_NAME                \
733         assert(cv)
734 
735 PERL_CALLCONV void
736 Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj);
737 #define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER    \
738         assert(cv); assert(ckfun); assert(ckobj)
739 
740 PERL_CALLCONV void
741 Perl_cv_set_call_checker_flags(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj, U32 ckflags);
742 #define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER_FLAGS \
743         assert(cv); assert(ckfun); assert(ckobj)
744 
745 PERL_CALLCONV void
746 Perl_cv_undef(pTHX_ CV *cv);
747 #define PERL_ARGS_ASSERT_CV_UNDEF               \
748         assert(cv)
749 
750 PERL_CALLCONV void
751 Perl_cv_undef_flags(pTHX_ CV *cv, U32 flags)
752         __attribute__visibility__("hidden");
753 #define PERL_ARGS_ASSERT_CV_UNDEF_FLAGS         \
754         assert(cv)
755 
756 PERL_CALLCONV GV *
757 Perl_cvgv_from_hek(pTHX_ CV *cv);
758 #define PERL_ARGS_ASSERT_CVGV_FROM_HEK          \
759         assert(cv)
760 
761 PERL_CALLCONV void
762 Perl_cvgv_set(pTHX_ CV *cv, GV *gv);
763 #define PERL_ARGS_ASSERT_CVGV_SET               \
764         assert(cv)
765 
766 PERL_CALLCONV void
767 Perl_cvstash_set(pTHX_ CV *cv, HV *stash);
768 #define PERL_ARGS_ASSERT_CVSTASH_SET            \
769         assert(cv)
770 
771 PERL_CALLCONV void
772 Perl_cx_dump(pTHX_ PERL_CONTEXT *cx);
773 #define PERL_ARGS_ASSERT_CX_DUMP                \
774         assert(cx)
775 
776 PERL_CALLCONV I32
777 Perl_cxinc(pTHX)
778         __attribute__warn_unused_result__;
779 #define PERL_ARGS_ASSERT_CXINC
780 
781 PERL_CALLCONV void
782 Perl_deb(pTHX_ const char *pat, ...)
783         __attribute__format__(__printf__,pTHX_1,pTHX_2);
784 #define PERL_ARGS_ASSERT_DEB                    \
785         assert(pat)
786 
787 PERL_CALLCONV void
788 Perl_deb_stack_all(pTHX)
789         __attribute__visibility__("hidden");
790 #define PERL_ARGS_ASSERT_DEB_STACK_ALL
791 
792 PERL_CALLCONV I32
793 Perl_debop(pTHX_ const OP *o);
794 #define PERL_ARGS_ASSERT_DEBOP                  \
795         assert(o)
796 
797 PERL_CALLCONV void
798 Perl_debprofdump(pTHX);
799 #define PERL_ARGS_ASSERT_DEBPROFDUMP
800 
801 PERL_CALLCONV I32
802 Perl_debstack(pTHX);
803 #define PERL_ARGS_ASSERT_DEBSTACK
804 
805 PERL_CALLCONV I32
806 Perl_debstackptrs(pTHX);
807 #define PERL_ARGS_ASSERT_DEBSTACKPTRS
808 
809 PERL_CALLCONV void
810 Perl_debug_hash_seed(pTHX_ bool via_debug_h)
811         __attribute__visibility__("hidden");
812 #define PERL_ARGS_ASSERT_DEBUG_HASH_SEED
813 
814 PERL_CALLCONV SV *
815 Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg)
816         __attribute__warn_unused_result__
817         __attribute__visibility__("hidden");
818 #define PERL_ARGS_ASSERT_DEFELEM_TARGET         \
819         assert(sv)
820 
821 PERL_CALLCONV void
822 Perl_delete_eval_scope(pTHX)
823         __attribute__visibility__("hidden");
824 #define PERL_ARGS_ASSERT_DELETE_EVAL_SCOPE
825 
826 PERL_CALLCONV char *
827 Perl_delimcpy(char *to, const char *to_end, const char *from, const char *from_end, const int delim, I32 *retlen);
828 #define PERL_ARGS_ASSERT_DELIMCPY               \
829         assert(to); assert(to_end); assert(from); assert(from_end); assert(retlen)
830 
831 PERL_CALLCONV char *
832 Perl_delimcpy_no_escape(char *to, const char *to_end, const char *from, const char *from_end, const int delim, I32 *retlen);
833 #define PERL_ARGS_ASSERT_DELIMCPY_NO_ESCAPE     \
834         assert(to); assert(to_end); assert(from); assert(from_end); assert(retlen)
835 
836 PERL_CALLCONV void
837 Perl_despatch_signals(pTHX);
838 #define PERL_ARGS_ASSERT_DESPATCH_SIGNALS
839 
840 PERL_CALLCONV_NO_RET OP *
841 Perl_die(pTHX_ const char *pat, ...)
842         __attribute__noreturn__
843         __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
844 #define PERL_ARGS_ASSERT_DIE
845 
846 PERL_CALLCONV_NO_RET OP *
847 Perl_die_sv(pTHX_ SV *baseex)
848         __attribute__noreturn__;
849 #define PERL_ARGS_ASSERT_DIE_SV                 \
850         assert(baseex)
851 
852 PERL_CALLCONV_NO_RET void
853 Perl_die_unwind(pTHX_ SV *msv)
854         __attribute__noreturn__
855         __attribute__visibility__("hidden");
856 #define PERL_ARGS_ASSERT_DIE_UNWIND             \
857         assert(msv)
858 
859 PERL_CALLCONV bool
860 Perl_do_aexec5(pTHX_ SV *really, SV **mark, SV **sp, int fd, int do_report)
861         __attribute__visibility__("hidden");
862 #define PERL_ARGS_ASSERT_DO_AEXEC5              \
863         assert(mark); assert(sp)
864 
865 PERL_CALLCONV bool
866 Perl_do_close(pTHX_ GV *gv, bool is_explicit);
867 #define PERL_ARGS_ASSERT_DO_CLOSE
868 
869 PERL_CALLCONV void
870 Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full)
871         __attribute__visibility__("hidden");
872 #define PERL_ARGS_ASSERT_DO_DUMP_PAD            \
873         assert(file)
874 
875 PERL_CALLCONV bool
876 Perl_do_eof(pTHX_ GV *gv)
877         __attribute__visibility__("hidden");
878 #define PERL_ARGS_ASSERT_DO_EOF                 \
879         assert(gv)
880 
881 PERL_CALLCONV void
882 Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv);
883 #define PERL_ARGS_ASSERT_DO_GV_DUMP             \
884         assert(file); assert(name)
885 
886 PERL_CALLCONV void
887 Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv);
888 #define PERL_ARGS_ASSERT_DO_GVGV_DUMP           \
889         assert(file); assert(name)
890 
891 PERL_CALLCONV void
892 Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv);
893 #define PERL_ARGS_ASSERT_DO_HV_DUMP             \
894         assert(file); assert(name)
895 
896 PERL_CALLCONV void
897 Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp);
898 #define PERL_ARGS_ASSERT_DO_JOIN                \
899         assert(sv); assert(delim); assert(mark); assert(sp)
900 
901 PERL_CALLCONV void
902 Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim);
903 #define PERL_ARGS_ASSERT_DO_MAGIC_DUMP          \
904         assert(file)
905 
906 PERL_CALLCONV I32
907 Perl_do_ncmp(pTHX_ SV * const left, SV * const right)
908         __attribute__warn_unused_result__
909         __attribute__visibility__("hidden");
910 #define PERL_ARGS_ASSERT_DO_NCMP                \
911         assert(left); assert(right)
912 
913 PERL_CALLCONV void
914 Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o);
915 #define PERL_ARGS_ASSERT_DO_OP_DUMP             \
916         assert(file)
917 
918 PERL_CALLCONV bool
919 Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num)
920         __attribute__visibility__("hidden");
921 #define PERL_ARGS_ASSERT_DO_OPEN6               \
922         assert(gv); assert(oname)
923 
924 PERL_CALLCONV bool
925 Perl_do_open_raw(pTHX_ GV *gv, const char *oname, STRLEN len, int rawmode, int rawperm, Stat_t *statbufp)
926         __attribute__visibility__("hidden");
927 #define PERL_ARGS_ASSERT_DO_OPEN_RAW            \
928         assert(gv); assert(oname)
929 
930 PERL_CALLCONV bool
931 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);
932 #define PERL_ARGS_ASSERT_DO_OPENN               \
933         assert(gv); assert(oname)
934 
935 PERL_CALLCONV void
936 Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm);
937 #define PERL_ARGS_ASSERT_DO_PMOP_DUMP           \
938         assert(file)
939 
940 PERL_CALLCONV bool
941 Perl_do_print(pTHX_ SV *sv, PerlIO *fp)
942         __attribute__visibility__("hidden");
943 #define PERL_ARGS_ASSERT_DO_PRINT               \
944         assert(fp)
945 
946 PERL_CALLCONV OP *
947 Perl_do_readline(pTHX)
948         __attribute__warn_unused_result__
949         __attribute__visibility__("hidden");
950 #define PERL_ARGS_ASSERT_DO_READLINE
951 
952 PERL_CALLCONV bool
953 Perl_do_seek(pTHX_ GV *gv, Off_t pos, int whence)
954         __attribute__visibility__("hidden");
955 #define PERL_ARGS_ASSERT_DO_SEEK
956 
957 PERL_CALLCONV void
958 Perl_do_sprintf(pTHX_ SV *sv, SSize_t len, SV **sarg);
959 #define PERL_ARGS_ASSERT_DO_SPRINTF             \
960         assert(sv); assert(sarg)
961 
962 PERL_CALLCONV void
963 Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim);
964 #define PERL_ARGS_ASSERT_DO_SV_DUMP             \
965         assert(file)
966 
967 PERL_CALLCONV Off_t
968 Perl_do_sysseek(pTHX_ GV *gv, Off_t pos, int whence)
969         __attribute__visibility__("hidden");
970 #define PERL_ARGS_ASSERT_DO_SYSSEEK             \
971         assert(gv)
972 
973 PERL_CALLCONV Off_t
974 Perl_do_tell(pTHX_ GV *gv)
975         __attribute__warn_unused_result__
976         __attribute__visibility__("hidden");
977 #define PERL_ARGS_ASSERT_DO_TELL                \
978         assert(gv)
979 
980 PERL_CALLCONV Size_t
981 Perl_do_trans(pTHX_ SV *sv)
982         __attribute__visibility__("hidden");
983 #define PERL_ARGS_ASSERT_DO_TRANS               \
984         assert(sv)
985 
986 PERL_CALLCONV I16
987 Perl_do_uniprop_match(const char * const key, const U16 key_len)
988         __attribute__warn_unused_result__;
989 #define PERL_ARGS_ASSERT_DO_UNIPROP_MATCH       \
990         assert(key)
991 
992 PERL_CALLCONV UV
993 Perl_do_vecget(pTHX_ SV *sv, STRLEN offset, int size)
994         __attribute__visibility__("hidden");
995 #define PERL_ARGS_ASSERT_DO_VECGET              \
996         assert(sv)
997 
998 PERL_CALLCONV void
999 Perl_do_vecset(pTHX_ SV *sv)
1000         __attribute__visibility__("hidden");
1001 #define PERL_ARGS_ASSERT_DO_VECSET              \
1002         assert(sv)
1003 
1004 PERL_CALLCONV void
1005 Perl_do_vop(pTHX_ I32 optype, SV *sv, SV *left, SV *right)
1006         __attribute__visibility__("hidden");
1007 #define PERL_ARGS_ASSERT_DO_VOP                 \
1008         assert(sv); assert(left); assert(right)
1009 
1010 PERL_CALLCONV OP *
1011 Perl_dofile(pTHX_ OP *term, I32 force_builtin)
1012         __attribute__visibility__("hidden");
1013 #define PERL_ARGS_ASSERT_DOFILE                 \
1014         assert(term)
1015 
1016 PERL_CALLCONV bool
1017 Perl_doing_taint(int argc, char **argv, char **env)
1018         __attribute__warn_unused_result__;
1019 #define PERL_ARGS_ASSERT_DOING_TAINT
1020 
1021 PERL_CALLCONV OP *
1022 Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref);
1023 #define PERL_ARGS_ASSERT_DOREF                  \
1024         assert(o)
1025 
1026 PERL_CALLCONV void
1027 Perl_dounwind(pTHX_ I32 cxix);
1028 #define PERL_ARGS_ASSERT_DOUNWIND
1029 
1030 PERL_CALLCONV U8
1031 Perl_dowantarray(pTHX)
1032         __attribute__deprecated__
1033         __attribute__warn_unused_result__;
1034 #define PERL_ARGS_ASSERT_DOWANTARRAY
1035 
1036 PERL_CALLCONV void
1037 Perl_drand48_init_r(perl_drand48_t *random_state, U32 seed);
1038 #define PERL_ARGS_ASSERT_DRAND48_INIT_R         \
1039         assert(random_state)
1040 
1041 PERL_CALLCONV double
1042 Perl_drand48_r(perl_drand48_t *random_state);
1043 #define PERL_ARGS_ASSERT_DRAND48_R              \
1044         assert(random_state)
1045 
1046 PERL_CALLCONV void
1047 Perl_dump_all(pTHX);
1048 #define PERL_ARGS_ASSERT_DUMP_ALL
1049 
1050 PERL_CALLCONV void
1051 Perl_dump_all_perl(pTHX_ bool justperl)
1052         __attribute__visibility__("hidden");
1053 #define PERL_ARGS_ASSERT_DUMP_ALL_PERL
1054 
1055 PERL_CALLCONV void
1056 Perl_dump_eval(pTHX);
1057 #define PERL_ARGS_ASSERT_DUMP_EVAL
1058 
1059 PERL_CALLCONV void
1060 Perl_dump_form(pTHX_ const GV *gv);
1061 #define PERL_ARGS_ASSERT_DUMP_FORM              \
1062         assert(gv)
1063 
1064 PERL_CALLCONV void
1065 Perl_dump_indent(pTHX_ I32 level, PerlIO *file, const char *pat, ...)
1066         __attribute__format__(__printf__,pTHX_3,pTHX_4);
1067 #define PERL_ARGS_ASSERT_DUMP_INDENT            \
1068         assert(file); assert(pat)
1069 
1070 PERL_CALLCONV void
1071 Perl_dump_packsubs(pTHX_ const HV *stash);
1072 #define PERL_ARGS_ASSERT_DUMP_PACKSUBS          \
1073         assert(stash)
1074 
1075 PERL_CALLCONV void
1076 Perl_dump_packsubs_perl(pTHX_ const HV *stash, bool justperl)
1077         __attribute__visibility__("hidden");
1078 #define PERL_ARGS_ASSERT_DUMP_PACKSUBS_PERL     \
1079         assert(stash)
1080 
1081 PERL_CALLCONV void
1082 Perl_dump_sub(pTHX_ const GV *gv);
1083 #define PERL_ARGS_ASSERT_DUMP_SUB               \
1084         assert(gv)
1085 
1086 PERL_CALLCONV void
1087 Perl_dump_sub_perl(pTHX_ const GV *gv, bool justperl)
1088         __attribute__visibility__("hidden");
1089 #define PERL_ARGS_ASSERT_DUMP_SUB_PERL          \
1090         assert(gv)
1091 
1092 PERL_CALLCONV void
1093 Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char *pat, va_list *args);
1094 #define PERL_ARGS_ASSERT_DUMP_VINDENT           \
1095         assert(file); assert(pat)
1096 
1097 PERL_CALLCONV char  *
1098 Perl_dup_warnings(pTHX_ char *warnings);
1099 #define PERL_ARGS_ASSERT_DUP_WARNINGS
1100 
1101 PERL_CALLCONV void
1102 Perl_emulate_cop_io(pTHX_ const COP * const c, SV * const sv);
1103 #define PERL_ARGS_ASSERT_EMULATE_COP_IO         \
1104         assert(c); assert(sv)
1105 
1106 PERL_CALLCONV SV *
1107 Perl_eval_pv(pTHX_ const char *p, I32 croak_on_error);
1108 #define PERL_ARGS_ASSERT_EVAL_PV                \
1109         assert(p)
1110 
1111 PERL_CALLCONV SSize_t
1112 Perl_eval_sv(pTHX_ SV *sv, I32 flags);
1113 #define PERL_ARGS_ASSERT_EVAL_SV                \
1114         assert(sv)
1115 
1116 PERL_CALLCONV void
1117 Perl_fatal_warner(pTHX_ U32 err, const char *pat, ...)
1118         __attribute__format__(__printf__,pTHX_2,pTHX_3);
1119 #define PERL_ARGS_ASSERT_FATAL_WARNER           \
1120         assert(pat)
1121 
1122 PERL_CALLCONV void
1123 Perl_fbm_compile(pTHX_ SV *sv, U32 flags);
1124 #define PERL_ARGS_ASSERT_FBM_COMPILE            \
1125         assert(sv)
1126 
1127 PERL_CALLCONV char *
1128 Perl_fbm_instr(pTHX_ unsigned char *big, unsigned char *bigend, SV *littlestr, U32 flags)
1129         __attribute__warn_unused_result__;
1130 #define PERL_ARGS_ASSERT_FBM_INSTR              \
1131         assert(big); assert(bigend); assert(littlestr)
1132 
1133 PERL_CALLCONV SV *
1134 Perl_filter_add(pTHX_ filter_t funcp, SV *datasv);
1135 #define PERL_ARGS_ASSERT_FILTER_ADD
1136 
1137 PERL_CALLCONV void
1138 Perl_filter_del(pTHX_ filter_t funcp);
1139 #define PERL_ARGS_ASSERT_FILTER_DEL             \
1140         assert(funcp)
1141 
1142 PERL_CALLCONV I32
1143 Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen)
1144         __attribute__warn_unused_result__;
1145 #define PERL_ARGS_ASSERT_FILTER_READ            \
1146         assert(buf_sv)
1147 
1148 PERL_CALLCONV CV *
1149 Perl_find_lexical_cv(pTHX_ PADOFFSET off)
1150         __attribute__visibility__("hidden");
1151 #define PERL_ARGS_ASSERT_FIND_LEXICAL_CV
1152 
1153 PERL_CALLCONV CV *
1154 Perl_find_runcv(pTHX_ U32 *db_seqp)
1155         __attribute__warn_unused_result__;
1156 #define PERL_ARGS_ASSERT_FIND_RUNCV
1157 
1158 PERL_CALLCONV CV *
1159 Perl_find_runcv_where(pTHX_ U8 cond, IV arg, U32 *db_seqp)
1160         __attribute__warn_unused_result__
1161         __attribute__visibility__("hidden");
1162 #define PERL_ARGS_ASSERT_FIND_RUNCV_WHERE
1163 
1164 PERL_CALLCONV SV *
1165 Perl_find_rundefsv(pTHX);
1166 #define PERL_ARGS_ASSERT_FIND_RUNDEFSV
1167 
1168 PERL_CALLCONV char *
1169 Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char * const * const search_ext, I32 flags)
1170         __attribute__visibility__("hidden");
1171 #define PERL_ARGS_ASSERT_FIND_SCRIPT            \
1172         assert(scriptname)
1173 
1174 /* PERL_CALLCONV I32
1175 foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */
1176 
1177 PERL_CALLCONV I32
1178 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);
1179 #define PERL_ARGS_ASSERT_FOLDEQ_UTF8_FLAGS      \
1180         assert(s1); assert(s2)
1181 
1182 PERL_CALLCONV void
1183 Perl_forbid_outofblock_ops(pTHX_ OP *o, const char *blockname);
1184 #define PERL_ARGS_ASSERT_FORBID_OUTOFBLOCK_OPS  \
1185         assert(o); assert(blockname)
1186 
1187 PERL_CALLCONV void
1188 Perl_force_locale_unlock(pTHX)
1189         __attribute__visibility__("hidden");
1190 #define PERL_ARGS_ASSERT_FORCE_LOCALE_UNLOCK
1191 
1192 PERL_CALLCONV char *
1193 Perl_form(pTHX_ const char *pat, ...)
1194         __attribute__format__(__printf__,pTHX_1,pTHX_2);
1195 #define PERL_ARGS_ASSERT_FORM                   \
1196         assert(pat)
1197 
1198 PERL_CALLCONV void
1199 Perl_free_tied_hv_pool(pTHX)
1200         __attribute__visibility__("hidden");
1201 #define PERL_ARGS_ASSERT_FREE_TIED_HV_POOL
1202 
1203 PERL_CALLCONV void
1204 Perl_free_tmps(pTHX);
1205 #define PERL_ARGS_ASSERT_FREE_TMPS
1206 
1207 PERL_CALLCONV SV *
1208 Perl_get_and_check_backslash_N_name(pTHX_ const char *s, const char *e, const bool is_utf8, const char **error_msg)
1209         __attribute__warn_unused_result__;
1210 #define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME \
1211         assert(s); assert(e); assert(error_msg)
1212 
1213 PERL_CALLCONV AV *
1214 Perl_get_av(pTHX_ const char *name, I32 flags);
1215 #define PERL_ARGS_ASSERT_GET_AV                 \
1216         assert(name)
1217 
1218 PERL_CALLCONV CV *
1219 Perl_get_cv(pTHX_ const char *name, I32 flags);
1220 #define PERL_ARGS_ASSERT_GET_CV                 \
1221         assert(name)
1222 
1223 PERL_CALLCONV CV *
1224 Perl_get_cvn_flags(pTHX_ const char *name, STRLEN len, I32 flags);
1225 #define PERL_ARGS_ASSERT_GET_CVN_FLAGS          \
1226         assert(name)
1227 
1228 PERL_CALLCONV void
1229 Perl_get_db_sub(pTHX_ SV **svp, CV *cv);
1230 #define PERL_ARGS_ASSERT_GET_DB_SUB             \
1231         assert(cv)
1232 
1233 PERL_CALLCONV const char *
1234 Perl_get_deprecated_property_msg(const Size_t warning_offset)
1235         __attribute__warn_unused_result__;
1236 #define PERL_ARGS_ASSERT_GET_DEPRECATED_PROPERTY_MSG
1237 
1238 PERL_CALLCONV int
1239 Perl_get_extended_os_errno(void)
1240         __attribute__visibility__("hidden");
1241 #define PERL_ARGS_ASSERT_GET_EXTENDED_OS_ERRNO
1242 
1243 PERL_CALLCONV void
1244 Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer)
1245         __attribute__visibility__("hidden");
1246 #define PERL_ARGS_ASSERT_GET_HASH_SEED          \
1247         assert(seed_buffer)
1248 
1249 PERL_CALLCONV HV *
1250 Perl_get_hv(pTHX_ const char *name, I32 flags);
1251 #define PERL_ARGS_ASSERT_GET_HV                 \
1252         assert(name)
1253 
1254 PERL_CALLCONV const char *
1255 Perl_get_no_modify(pTHX)
1256         __attribute__deprecated__
1257         __attribute__warn_unused_result__
1258         __attribute__pure__
1259         __attribute__visibility__("hidden");
1260 #define PERL_ARGS_ASSERT_GET_NO_MODIFY
1261 
1262 PERL_CALLCONV char **
1263 Perl_get_op_descs(pTHX)
1264         __attribute__deprecated__
1265         __attribute__warn_unused_result__
1266         __attribute__pure__;
1267 #define PERL_ARGS_ASSERT_GET_OP_DESCS
1268 
1269 PERL_CALLCONV char **
1270 Perl_get_op_names(pTHX)
1271         __attribute__deprecated__
1272         __attribute__warn_unused_result__
1273         __attribute__pure__;
1274 #define PERL_ARGS_ASSERT_GET_OP_NAMES
1275 
1276 PERL_CALLCONV U32 *
1277 Perl_get_opargs(pTHX)
1278         __attribute__deprecated__
1279         __attribute__warn_unused_result__
1280         __attribute__pure__
1281         __attribute__visibility__("hidden");
1282 #define PERL_ARGS_ASSERT_GET_OPARGS
1283 
1284 PERL_CALLCONV PPADDR_t *
1285 Perl_get_ppaddr(pTHX)
1286         __attribute__deprecated__
1287         __attribute__warn_unused_result__
1288         __attribute__pure__;
1289 #define PERL_ARGS_ASSERT_GET_PPADDR
1290 
1291 PERL_CALLCONV SV *
1292 Perl_get_prop_definition(pTHX_ const int table_index)
1293         __attribute__warn_unused_result__;
1294 #define PERL_ARGS_ASSERT_GET_PROP_DEFINITION
1295 
1296 PERL_CALLCONV const char * const *
1297 Perl_get_prop_values(const int table_index)
1298         __attribute__warn_unused_result__;
1299 #define PERL_ARGS_ASSERT_GET_PROP_VALUES
1300 
1301 PERL_CALLCONV REGEXP *
1302 Perl_get_re_arg(pTHX_ SV *sv);
1303 #define PERL_ARGS_ASSERT_GET_RE_ARG
1304 
1305 PERL_CALLCONV SV *
1306 Perl_get_sv(pTHX_ const char *name, I32 flags);
1307 #define PERL_ARGS_ASSERT_GET_SV                 \
1308         assert(name)
1309 
1310 PERL_CALLCONV int
1311 Perl_getcwd_sv(pTHX_ SV *sv);
1312 #define PERL_ARGS_ASSERT_GETCWD_SV              \
1313         assert(sv)
1314 
1315 PERL_CALLCONV void
1316 Perl_gp_free(pTHX_ GV *gv);
1317 #define PERL_ARGS_ASSERT_GP_FREE
1318 
1319 PERL_CALLCONV GP *
1320 Perl_gp_ref(pTHX_ GP *gp);
1321 #define PERL_ARGS_ASSERT_GP_REF
1322 
1323 PERL_CALLCONV bool
1324 Perl_grok_atoUV(const char *pv, UV *valptr, const char **endptr);
1325 #define PERL_ARGS_ASSERT_GROK_ATOUV             \
1326         assert(pv); assert(valptr)
1327 
1328 PERL_CALLCONV UV
1329 Perl_grok_bin(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result);
1330 #define PERL_ARGS_ASSERT_GROK_BIN               \
1331         assert(start); assert(len_p); assert(flags)
1332 
1333 PERL_CALLCONV UV
1334 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);
1335 #define PERL_ARGS_ASSERT_GROK_BIN_OCT_HEX       \
1336         assert(start); assert(len_p); assert(flags)
1337 
1338 PERL_CALLCONV UV
1339 Perl_grok_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result);
1340 #define PERL_ARGS_ASSERT_GROK_HEX               \
1341         assert(start); assert(len_p); assert(flags)
1342 
1343 PERL_CALLCONV int
1344 Perl_grok_infnan(pTHX_ const char **sp, const char *send);
1345 #define PERL_ARGS_ASSERT_GROK_INFNAN            \
1346         assert(sp); assert(send)
1347 
1348 PERL_CALLCONV int
1349 Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep);
1350 #define PERL_ARGS_ASSERT_GROK_NUMBER            \
1351         assert(pv)
1352 
1353 PERL_CALLCONV int
1354 Perl_grok_number_flags(pTHX_ const char *pv, STRLEN len, UV *valuep, U32 flags);
1355 #define PERL_ARGS_ASSERT_GROK_NUMBER_FLAGS      \
1356         assert(pv)
1357 
1358 PERL_CALLCONV bool
1359 Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send)
1360         __attribute__warn_unused_result__;
1361 #define PERL_ARGS_ASSERT_GROK_NUMERIC_RADIX     \
1362         assert(sp); assert(send)
1363 
1364 PERL_CALLCONV UV
1365 Perl_grok_oct(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result);
1366 #define PERL_ARGS_ASSERT_GROK_OCT               \
1367         assert(start); assert(len_p); assert(flags)
1368 
1369 PERL_CALLCONV GV *
1370 Perl_gv_add_by_type(pTHX_ GV *gv, svtype type);
1371 #define PERL_ARGS_ASSERT_GV_ADD_BY_TYPE
1372 
1373 /* PERL_CALLCONV GV *
1374 gv_autoload4(pTHX_ HV *stash, const char *name, STRLEN len, I32 method)
1375         __attribute__warn_unused_result__; */
1376 
1377 PERL_CALLCONV GV *
1378 Perl_gv_autoload_pv(pTHX_ HV *stash, const char *namepv, U32 flags)
1379         __attribute__warn_unused_result__;
1380 #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PV         \
1381         assert(namepv)
1382 
1383 PERL_CALLCONV GV *
1384 Perl_gv_autoload_pvn(pTHX_ HV *stash, const char *name, STRLEN len, U32 flags)
1385         __attribute__warn_unused_result__;
1386 #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PVN        \
1387         assert(name)
1388 
1389 PERL_CALLCONV GV *
1390 Perl_gv_autoload_sv(pTHX_ HV *stash, SV *namesv, U32 flags)
1391         __attribute__warn_unused_result__;
1392 #define PERL_ARGS_ASSERT_GV_AUTOLOAD_SV         \
1393         assert(namesv)
1394 
1395 PERL_CALLCONV void
1396 Perl_gv_check(pTHX_ HV *stash);
1397 #define PERL_ARGS_ASSERT_GV_CHECK               \
1398         assert(stash)
1399 
1400 PERL_CALLCONV SV *
1401 Perl_gv_const_sv(pTHX_ GV *gv)
1402         __attribute__warn_unused_result__;
1403 #define PERL_ARGS_ASSERT_GV_CONST_SV            \
1404         assert(gv)
1405 
1406 PERL_CALLCONV void
1407 Perl_gv_dump(pTHX_ GV *gv);
1408 #define PERL_ARGS_ASSERT_GV_DUMP
1409 
1410 PERL_CALLCONV void
1411 Perl_gv_efullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain);
1412 #define PERL_ARGS_ASSERT_GV_EFULLNAME4          \
1413         assert(sv); assert(gv)
1414 
1415 PERL_CALLCONV GV *
1416 Perl_gv_fetchfile(pTHX_ const char *name);
1417 #define PERL_ARGS_ASSERT_GV_FETCHFILE           \
1418         assert(name)
1419 
1420 PERL_CALLCONV GV *
1421 Perl_gv_fetchfile_flags(pTHX_ const char * const name, const STRLEN len, const U32 flags);
1422 #define PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS     \
1423         assert(name)
1424 
1425 /* PERL_CALLCONV GV *
1426 gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level); */
1427 
1428 /* PERL_CALLCONV GV *
1429 gv_fetchmeth_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level); */
1430 
1431 PERL_CALLCONV GV *
1432 Perl_gv_fetchmeth_pv(pTHX_ HV *stash, const char *name, I32 level, U32 flags);
1433 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV        \
1434         assert(name)
1435 
1436 PERL_CALLCONV GV *
1437 Perl_gv_fetchmeth_pv_autoload(pTHX_ HV *stash, const char *name, I32 level, U32 flags);
1438 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV_AUTOLOAD \
1439         assert(name)
1440 
1441 PERL_CALLCONV GV *
1442 Perl_gv_fetchmeth_pvn(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags);
1443 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN       \
1444         assert(name)
1445 
1446 PERL_CALLCONV GV *
1447 Perl_gv_fetchmeth_pvn_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags);
1448 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN_AUTOLOAD \
1449         assert(name)
1450 
1451 PERL_CALLCONV GV *
1452 Perl_gv_fetchmeth_sv(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags);
1453 #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV        \
1454         assert(namesv)
1455 
1456 PERL_CALLCONV GV *
1457 Perl_gv_fetchmeth_sv_autoload(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags);
1458 #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV_AUTOLOAD \
1459         assert(namesv)
1460 
1461 PERL_CALLCONV GV *
1462 Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload);
1463 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD \
1464         assert(stash); assert(name)
1465 
1466 PERL_CALLCONV GV *
1467 Perl_gv_fetchmethod_pv_flags(pTHX_ HV *stash, const char *name, U32 flags);
1468 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PV_FLAGS \
1469         assert(stash); assert(name)
1470 
1471 PERL_CALLCONV GV *
1472 Perl_gv_fetchmethod_pvn_flags(pTHX_ HV *stash, const char *name, const STRLEN len, U32 flags);
1473 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PVN_FLAGS \
1474         assert(stash); assert(name)
1475 
1476 PERL_CALLCONV GV *
1477 Perl_gv_fetchmethod_sv_flags(pTHX_ HV *stash, SV *namesv, U32 flags);
1478 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_SV_FLAGS \
1479         assert(stash); assert(namesv)
1480 
1481 PERL_CALLCONV GV *
1482 Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 flags, const svtype sv_type);
1483 #define PERL_ARGS_ASSERT_GV_FETCHPV             \
1484         assert(nambeg)
1485 
1486 PERL_CALLCONV GV *
1487 Perl_gv_fetchpvn_flags(pTHX_ const char *name, STRLEN len, I32 flags, const svtype sv_type);
1488 #define PERL_ARGS_ASSERT_GV_FETCHPVN_FLAGS      \
1489         assert(name)
1490 
1491 PERL_CALLCONV GV *
1492 Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type);
1493 #define PERL_ARGS_ASSERT_GV_FETCHSV             \
1494         assert(name)
1495 
1496 PERL_CALLCONV void
1497 Perl_gv_fullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain);
1498 #define PERL_ARGS_ASSERT_GV_FULLNAME4           \
1499         assert(sv); assert(gv)
1500 
1501 PERL_CALLCONV CV *
1502 Perl_gv_handler(pTHX_ HV *stash, I32 id)
1503         __attribute__warn_unused_result__;
1504 #define PERL_ARGS_ASSERT_GV_HANDLER
1505 
1506 /* PERL_CALLCONV void
1507 gv_init(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, int multi); */
1508 
1509 PERL_CALLCONV void
1510 Perl_gv_init_pv(pTHX_ GV *gv, HV *stash, const char *name, U32 flags);
1511 #define PERL_ARGS_ASSERT_GV_INIT_PV             \
1512         assert(gv); assert(name)
1513 
1514 PERL_CALLCONV void
1515 Perl_gv_init_pvn(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, U32 flags);
1516 #define PERL_ARGS_ASSERT_GV_INIT_PVN            \
1517         assert(gv); assert(name)
1518 
1519 PERL_CALLCONV void
1520 Perl_gv_init_sv(pTHX_ GV *gv, HV *stash, SV *namesv, U32 flags);
1521 #define PERL_ARGS_ASSERT_GV_INIT_SV             \
1522         assert(gv); assert(namesv)
1523 
1524 PERL_CALLCONV void
1525 Perl_gv_name_set(pTHX_ GV *gv, const char *name, U32 len, U32 flags);
1526 #define PERL_ARGS_ASSERT_GV_NAME_SET            \
1527         assert(gv); assert(name)
1528 
1529 PERL_CALLCONV GV *
1530 Perl_gv_override(pTHX_ const char * const name, const STRLEN len);
1531 #define PERL_ARGS_ASSERT_GV_OVERRIDE            \
1532         assert(name)
1533 
1534 PERL_CALLCONV void
1535 Perl_gv_setref(pTHX_ SV * const dsv, SV * const ssv)
1536         __attribute__visibility__("hidden");
1537 #define PERL_ARGS_ASSERT_GV_SETREF              \
1538         assert(dsv); assert(ssv)
1539 
1540 PERL_CALLCONV HV *
1541 Perl_gv_stashpv(pTHX_ const char *name, I32 flags);
1542 #define PERL_ARGS_ASSERT_GV_STASHPV             \
1543         assert(name)
1544 
1545 PERL_CALLCONV HV *
1546 Perl_gv_stashpvn(pTHX_ const char *name, U32 namelen, I32 flags);
1547 #define PERL_ARGS_ASSERT_GV_STASHPVN            \
1548         assert(name)
1549 
1550 PERL_CALLCONV HV *
1551 Perl_gv_stashsv(pTHX_ SV *sv, I32 flags);
1552 #define PERL_ARGS_ASSERT_GV_STASHSV             \
1553         assert(sv)
1554 
1555 PERL_CALLCONV void
1556 Perl_gv_try_downgrade(pTHX_ GV *gv);
1557 #define PERL_ARGS_ASSERT_GV_TRY_DOWNGRADE       \
1558         assert(gv)
1559 
1560 PERL_CALLCONV struct xpvhv_aux *
1561 Perl_hv_auxalloc(pTHX_ HV *hv)
1562         __attribute__visibility__("hidden");
1563 #define PERL_ARGS_ASSERT_HV_AUXALLOC            \
1564         assert(hv)
1565 
1566 PERL_CALLCONV AV **
1567 Perl_hv_backreferences_p(pTHX_ HV *hv)
1568         __attribute__visibility__("hidden");
1569 #define PERL_ARGS_ASSERT_HV_BACKREFERENCES_P    \
1570         assert(hv)
1571 
1572 PERL_CALLCONV SV *
1573 Perl_hv_bucket_ratio(pTHX_ HV *hv)
1574         __attribute__warn_unused_result__;
1575 #define PERL_ARGS_ASSERT_HV_BUCKET_RATIO        \
1576         assert(hv)
1577 
1578 PERL_CALLCONV void
1579 Perl_hv_clear(pTHX_ HV *hv);
1580 #define PERL_ARGS_ASSERT_HV_CLEAR
1581 
1582 PERL_CALLCONV void
1583 Perl_hv_clear_placeholders(pTHX_ HV *hv);
1584 #define PERL_ARGS_ASSERT_HV_CLEAR_PLACEHOLDERS  \
1585         assert(hv)
1586 
1587 PERL_CALLCONV void *
1588 Perl_hv_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int flags, int action, SV *val, U32 hash);
1589 #define PERL_ARGS_ASSERT_HV_COMMON
1590 
1591 PERL_CALLCONV void *
1592 Perl_hv_common_key_len(pTHX_ HV *hv, const char *key, I32 klen_i32, const int action, SV *val, const U32 hash);
1593 #define PERL_ARGS_ASSERT_HV_COMMON_KEY_LEN      \
1594         assert(key)
1595 
1596 PERL_CALLCONV HV *
1597 Perl_hv_copy_hints_hv(pTHX_ HV * const ohv)
1598         __attribute__warn_unused_result__;
1599 #define PERL_ARGS_ASSERT_HV_COPY_HINTS_HV
1600 
1601 PERL_CALLCONV void
1602 Perl_hv_delayfree_ent(pTHX_ HV *notused, HE *entry);
1603 #define PERL_ARGS_ASSERT_HV_DELAYFREE_ENT
1604 
1605 PERL_CALLCONV void
1606 Perl_hv_dump(pTHX_ HV *hv);
1607 #define PERL_ARGS_ASSERT_HV_DUMP
1608 
1609 PERL_CALLCONV HE **
1610 Perl_hv_eiter_p(pTHX_ HV *hv)
1611         __attribute__warn_unused_result__;
1612 #define PERL_ARGS_ASSERT_HV_EITER_P             \
1613         assert(hv)
1614 
1615 PERL_CALLCONV void
1616 Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter);
1617 #define PERL_ARGS_ASSERT_HV_EITER_SET           \
1618         assert(hv)
1619 
1620 PERL_CALLCONV void
1621 Perl_hv_ename_add(pTHX_ HV *hv, const char *name, U32 len, U32 flags)
1622         __attribute__visibility__("hidden");
1623 #define PERL_ARGS_ASSERT_HV_ENAME_ADD           \
1624         assert(hv); assert(name)
1625 
1626 PERL_CALLCONV void
1627 Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len, U32 flags)
1628         __attribute__visibility__("hidden");
1629 #define PERL_ARGS_ASSERT_HV_ENAME_DELETE        \
1630         assert(hv); assert(name)
1631 
1632 PERL_CALLCONV STRLEN
1633 Perl_hv_fill(pTHX_ HV * const hv);
1634 #define PERL_ARGS_ASSERT_HV_FILL                \
1635         assert(hv)
1636 
1637 PERL_CALLCONV void
1638 Perl_hv_free_ent(pTHX_ HV *notused, HE *entry);
1639 #define PERL_ARGS_ASSERT_HV_FREE_ENT
1640 
1641 PERL_CALLCONV I32
1642 Perl_hv_iterinit(pTHX_ HV *hv);
1643 #define PERL_ARGS_ASSERT_HV_ITERINIT            \
1644         assert(hv)
1645 
1646 PERL_CALLCONV char *
1647 Perl_hv_iterkey(pTHX_ HE *entry, I32 *retlen)
1648         __attribute__warn_unused_result__;
1649 #define PERL_ARGS_ASSERT_HV_ITERKEY             \
1650         assert(entry); assert(retlen)
1651 
1652 PERL_CALLCONV SV *
1653 Perl_hv_iterkeysv(pTHX_ HE *entry)
1654         __attribute__warn_unused_result__;
1655 #define PERL_ARGS_ASSERT_HV_ITERKEYSV           \
1656         assert(entry)
1657 
1658 PERL_CALLCONV HE *
1659 Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags)
1660         __attribute__warn_unused_result__;
1661 #define PERL_ARGS_ASSERT_HV_ITERNEXT_FLAGS      \
1662         assert(hv)
1663 
1664 PERL_CALLCONV SV *
1665 Perl_hv_iternextsv(pTHX_ HV *hv, char **key, I32 *retlen)
1666         __attribute__warn_unused_result__;
1667 #define PERL_ARGS_ASSERT_HV_ITERNEXTSV          \
1668         assert(hv); assert(key); assert(retlen)
1669 
1670 PERL_CALLCONV SV *
1671 Perl_hv_iterval(pTHX_ HV *hv, HE *entry)
1672         __attribute__warn_unused_result__;
1673 #define PERL_ARGS_ASSERT_HV_ITERVAL             \
1674         assert(hv); assert(entry)
1675 
1676 PERL_CALLCONV void
1677 Perl_hv_ksplit(pTHX_ HV *hv, IV newmax);
1678 #define PERL_ARGS_ASSERT_HV_KSPLIT              \
1679         assert(hv)
1680 
1681 PERL_CALLCONV void
1682 Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags);
1683 #define PERL_ARGS_ASSERT_HV_NAME_SET            \
1684         assert(hv)
1685 
1686 PERL_CALLCONV I32
1687 Perl_hv_placeholders_get(pTHX_ const HV *hv)
1688         __attribute__warn_unused_result__;
1689 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_GET    \
1690         assert(hv)
1691 
1692 PERL_CALLCONV SSize_t *
1693 Perl_hv_placeholders_p(pTHX_ HV *hv)
1694         __attribute__warn_unused_result__;
1695 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_P      \
1696         assert(hv)
1697 
1698 PERL_CALLCONV void
1699 Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph);
1700 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_SET    \
1701         assert(hv)
1702 
1703 PERL_CALLCONV void
1704 Perl_hv_pushkv(pTHX_ HV *hv, U32 flags)
1705         __attribute__visibility__("hidden");
1706 #define PERL_ARGS_ASSERT_HV_PUSHKV              \
1707         assert(hv)
1708 
1709 PERL_CALLCONV void
1710 Perl_hv_rand_set(pTHX_ HV *hv, U32 new_xhv_rand);
1711 #define PERL_ARGS_ASSERT_HV_RAND_SET            \
1712         assert(hv)
1713 
1714 PERL_CALLCONV I32 *
1715 Perl_hv_riter_p(pTHX_ HV *hv)
1716         __attribute__warn_unused_result__;
1717 #define PERL_ARGS_ASSERT_HV_RITER_P             \
1718         assert(hv)
1719 
1720 PERL_CALLCONV void
1721 Perl_hv_riter_set(pTHX_ HV *hv, I32 riter);
1722 #define PERL_ARGS_ASSERT_HV_RITER_SET           \
1723         assert(hv)
1724 
1725 PERL_CALLCONV SV *
1726 Perl_hv_scalar(pTHX_ HV *hv)
1727         __attribute__warn_unused_result__;
1728 #define PERL_ARGS_ASSERT_HV_SCALAR              \
1729         assert(hv)
1730 
1731 /* PERL_CALLCONV SV **
1732 hv_stores(pTHX_ HV *hv, const char * const key, SV *val); */
1733 
1734 /* PERL_CALLCONV void
1735 hv_undef(pTHX_ HV *hv); */
1736 
1737 PERL_CALLCONV void
1738 Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags);
1739 #define PERL_ARGS_ASSERT_HV_UNDEF_FLAGS
1740 
1741 /* PERL_CALLCONV I32
1742 ibcmp(pTHX_ const char *a, const char *b, I32 len)
1743         __attribute__warn_unused_result__
1744         __attribute__pure__; */
1745 
1746 /* PERL_CALLCONV I32
1747 ibcmp_locale(pTHX_ const char *a, const char *b, I32 len)
1748         __attribute__warn_unused_result__
1749         __attribute__pure__; */
1750 
1751 /* PERL_CALLCONV I32
1752 ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */
1753 
1754 PERL_CALLCONV STRLEN
1755 Perl_infix_plugin_standard(pTHX_ char *operator_ptr, STRLEN operator_len, struct Perl_custom_infix **def);
1756 #define PERL_ARGS_ASSERT_INFIX_PLUGIN_STANDARD  \
1757         assert(operator_ptr); assert(def)
1758 
1759 PERL_CALLCONV void
1760 Perl_init_argv_symbols(pTHX_ int argc, char **argv)
1761         __attribute__visibility__("hidden");
1762 #define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS      \
1763         assert(argv)
1764 
1765 PERL_CALLCONV void
1766 Perl_init_constants(pTHX)
1767         __attribute__visibility__("hidden");
1768 #define PERL_ARGS_ASSERT_INIT_CONSTANTS
1769 
1770 PERL_CALLCONV void
1771 Perl_init_dbargs(pTHX)
1772         __attribute__visibility__("hidden");
1773 #define PERL_ARGS_ASSERT_INIT_DBARGS
1774 
1775 PERL_CALLCONV void
1776 Perl_init_debugger(pTHX)
1777         __attribute__visibility__("hidden");
1778 #define PERL_ARGS_ASSERT_INIT_DEBUGGER
1779 
1780 PERL_CALLCONV int
1781 Perl_init_i18nl10n(pTHX_ int printwarn);
1782 #define PERL_ARGS_ASSERT_INIT_I18NL10N
1783 
1784 PERL_CALLCONV void
1785 Perl_init_named_cv(pTHX_ CV *cv, OP *nameop);
1786 #define PERL_ARGS_ASSERT_INIT_NAMED_CV          \
1787         assert(cv); assert(nameop)
1788 
1789 PERL_CALLCONV void
1790 Perl_init_stacks(pTHX);
1791 #define PERL_ARGS_ASSERT_INIT_STACKS
1792 
1793 PERL_CALLCONV void
1794 Perl_init_tm(pTHX_ struct tm *ptm);
1795 #define PERL_ARGS_ASSERT_INIT_TM                \
1796         assert(ptm)
1797 
1798 PERL_CALLCONV void
1799 Perl_init_uniprops(pTHX)
1800         __attribute__visibility__("hidden");
1801 #define PERL_ARGS_ASSERT_INIT_UNIPROPS
1802 
1803 PERL_CALLCONV U32
1804 Perl_intro_my(pTHX);
1805 #define PERL_ARGS_ASSERT_INTRO_MY
1806 
1807 PERL_CALLCONV OP *
1808 Perl_invert(pTHX_ OP *cmd)
1809         __attribute__warn_unused_result__
1810         __attribute__visibility__("hidden");
1811 #define PERL_ARGS_ASSERT_INVERT
1812 
1813 PERL_CALLCONV void
1814 Perl_invmap_dump(pTHX_ SV *invlist, UV *map)
1815         __attribute__visibility__("hidden");
1816 #define PERL_ARGS_ASSERT_INVMAP_DUMP            \
1817         assert(invlist); assert(map)
1818 
1819 PERL_CALLCONV bool
1820 Perl_io_close(pTHX_ IO *io, GV *gv, bool is_explicit, bool warn_on_fail)
1821         __attribute__visibility__("hidden");
1822 #define PERL_ARGS_ASSERT_IO_CLOSE               \
1823         assert(io)
1824 
1825 /* PERL_CALLCONV bool
1826 is_ascii_string(const U8 * const s, STRLEN len)
1827         __attribute__warn_unused_result__
1828         __attribute__pure__; */
1829 
1830 /* PERL_CALLCONV bool
1831 is_c9strict_utf8_string(const U8 *s, STRLEN len)
1832         __attribute__warn_unused_result__; */
1833 
1834 /* PERL_CALLCONV bool
1835 is_c9strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */
1836 
1837 /* PERL_CALLCONV bool
1838 is_invariant_string(const U8 * const s, STRLEN len)
1839         __attribute__warn_unused_result__
1840         __attribute__pure__; */
1841 
1842 PERL_CALLCONV I32
1843 Perl_is_lvalue_sub(pTHX)
1844         __attribute__warn_unused_result__;
1845 #define PERL_ARGS_ASSERT_IS_LVALUE_SUB
1846 
1847 /* PERL_CALLCONV bool
1848 is_strict_utf8_string(const U8 *s, STRLEN len)
1849         __attribute__warn_unused_result__; */
1850 
1851 /* PERL_CALLCONV bool
1852 is_strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */
1853 
1854 PERL_CALLCONV Size_t
1855 Perl_is_utf8_FF_helper_(const U8 * const s0, const U8 * const e, const bool require_partial)
1856         __attribute__warn_unused_result__
1857         __attribute__pure__;
1858 #define PERL_ARGS_ASSERT_IS_UTF8_FF_HELPER_     \
1859         assert(s0); assert(e)
1860 
1861 PERL_CALLCONV STRLEN
1862 Perl_is_utf8_char_helper_(const U8 * const s, const U8 *e, const U32 flags)
1863         __attribute__warn_unused_result__
1864         __attribute__pure__;
1865 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_HELPER_   \
1866         assert(s); assert(e)
1867 
1868 /* PERL_CALLCONV bool
1869 is_utf8_fixed_width_buf_flags(const U8 * const s, STRLEN len, const U32 flags); */
1870 
1871 /* PERL_CALLCONV bool
1872 is_utf8_fixed_width_buf_loc_flags(const U8 * const s, STRLEN len, const U8 **ep, const U32 flags); */
1873 
1874 /* PERL_CALLCONV bool
1875 is_utf8_invariant_string(const U8 * const s, STRLEN len)
1876         __attribute__warn_unused_result__; */
1877 
1878 /* PERL_CALLCONV bool
1879 is_utf8_string(const U8 *s, STRLEN len)
1880         __attribute__warn_unused_result__; */
1881 
1882 /* PERL_CALLCONV bool
1883 is_utf8_string_loc_flags(const U8 *s, STRLEN len, const U8 **ep, const U32 flags); */
1884 
1885 /* PERL_CALLCONV bool
1886 is_utf8_valid_partial_char(const U8 * const s0, const U8 * const e)
1887         __attribute__warn_unused_result__
1888         __attribute__pure__; */
1889 
1890 PERL_CALLCONV bool
1891 Perl_isinfnan(NV nv)
1892         __attribute__warn_unused_result__
1893         __attribute__pure__;
1894 #define PERL_ARGS_ASSERT_ISINFNAN
1895 
1896 PERL_CALLCONV bool
1897 Perl_isinfnansv(pTHX_ SV *sv)
1898         __attribute__visibility__("hidden");
1899 #define PERL_ARGS_ASSERT_ISINFNANSV             \
1900         assert(sv)
1901 
1902 PERL_CALLCONV OP *
1903 Perl_jmaybe(pTHX_ OP *o)
1904         __attribute__visibility__("hidden");
1905 #define PERL_ARGS_ASSERT_JMAYBE                 \
1906         assert(o)
1907 
1908 PERL_CALLCONV I32
1909 Perl_keyword(pTHX_ const char *name, I32 len, bool all_keywords)
1910         __attribute__warn_unused_result__
1911         __attribute__pure__
1912         __attribute__visibility__("hidden");
1913 #define PERL_ARGS_ASSERT_KEYWORD                \
1914         assert(name)
1915 
1916 PERL_CALLCONV int
1917 Perl_keyword_plugin_standard(pTHX_ char *keyword_ptr, STRLEN keyword_len, OP **op_ptr);
1918 #define PERL_ARGS_ASSERT_KEYWORD_PLUGIN_STANDARD \
1919         assert(keyword_ptr); assert(op_ptr)
1920 
1921 PERL_CALLCONV void
1922 Perl_leave_adjust_stacks(pTHX_ SV **from_sp, SV **to_sp, U8 gimme, int filter);
1923 #define PERL_ARGS_ASSERT_LEAVE_ADJUST_STACKS    \
1924         assert(from_sp); assert(to_sp)
1925 
1926 PERL_CALLCONV void
1927 Perl_leave_scope(pTHX_ I32 base);
1928 #define PERL_ARGS_ASSERT_LEAVE_SCOPE
1929 
1930 PERL_CALLCONV bool
1931 Perl_lex_bufutf8(pTHX);
1932 #define PERL_ARGS_ASSERT_LEX_BUFUTF8
1933 
1934 PERL_CALLCONV void
1935 Perl_lex_discard_to(pTHX_ char *ptr);
1936 #define PERL_ARGS_ASSERT_LEX_DISCARD_TO         \
1937         assert(ptr)
1938 
1939 PERL_CALLCONV char *
1940 Perl_lex_grow_linestr(pTHX_ STRLEN len);
1941 #define PERL_ARGS_ASSERT_LEX_GROW_LINESTR
1942 
1943 PERL_CALLCONV bool
1944 Perl_lex_next_chunk(pTHX_ U32 flags);
1945 #define PERL_ARGS_ASSERT_LEX_NEXT_CHUNK
1946 
1947 PERL_CALLCONV I32
1948 Perl_lex_peek_unichar(pTHX_ U32 flags);
1949 #define PERL_ARGS_ASSERT_LEX_PEEK_UNICHAR
1950 
1951 PERL_CALLCONV void
1952 Perl_lex_read_space(pTHX_ U32 flags);
1953 #define PERL_ARGS_ASSERT_LEX_READ_SPACE
1954 
1955 PERL_CALLCONV void
1956 Perl_lex_read_to(pTHX_ char *ptr);
1957 #define PERL_ARGS_ASSERT_LEX_READ_TO            \
1958         assert(ptr)
1959 
1960 PERL_CALLCONV I32
1961 Perl_lex_read_unichar(pTHX_ U32 flags);
1962 #define PERL_ARGS_ASSERT_LEX_READ_UNICHAR
1963 
1964 PERL_CALLCONV void
1965 Perl_lex_start(pTHX_ SV *line, PerlIO *rsfp, U32 flags);
1966 #define PERL_ARGS_ASSERT_LEX_START
1967 
1968 PERL_CALLCONV void
1969 Perl_lex_stuff_pv(pTHX_ const char *pv, U32 flags);
1970 #define PERL_ARGS_ASSERT_LEX_STUFF_PV           \
1971         assert(pv)
1972 
1973 PERL_CALLCONV void
1974 Perl_lex_stuff_pvn(pTHX_ const char *pv, STRLEN len, U32 flags);
1975 #define PERL_ARGS_ASSERT_LEX_STUFF_PVN          \
1976         assert(pv)
1977 
1978 PERL_CALLCONV void
1979 Perl_lex_stuff_sv(pTHX_ SV *sv, U32 flags);
1980 #define PERL_ARGS_ASSERT_LEX_STUFF_SV           \
1981         assert(sv)
1982 
1983 PERL_CALLCONV void
1984 Perl_lex_unstuff(pTHX_ char *ptr);
1985 #define PERL_ARGS_ASSERT_LEX_UNSTUFF            \
1986         assert(ptr)
1987 
1988 PERL_CALLCONV OP *
1989 Perl_list(pTHX_ OP *o)
1990         __attribute__visibility__("hidden");
1991 #define PERL_ARGS_ASSERT_LIST
1992 
1993 PERL_CALLCONV HV *
1994 Perl_load_charnames(pTHX_ SV *char_name, const char *context, const STRLEN context_len, const char **error_msg)
1995         __attribute__warn_unused_result__;
1996 #define PERL_ARGS_ASSERT_LOAD_CHARNAMES         \
1997         assert(char_name); assert(context); assert(error_msg)
1998 
1999 PERL_CALLCONV void
2000 Perl_load_module(pTHX_ U32 flags, SV *name, SV *ver, ...);
2001 #define PERL_ARGS_ASSERT_LOAD_MODULE            \
2002         assert(name)
2003 
2004 PERL_CALLCONV_NO_RET void
2005 Perl_locale_panic(const char *msg, const line_t immediate_caller_line, const char * const higher_caller_file, const line_t higher_caller_line)
2006         __attribute__noreturn__;
2007 #define PERL_ARGS_ASSERT_LOCALE_PANIC           \
2008         assert(msg); assert(higher_caller_file)
2009 
2010 PERL_CALLCONV OP *
2011 Perl_localize(pTHX_ OP *o, I32 lex)
2012         __attribute__visibility__("hidden");
2013 #define PERL_ARGS_ASSERT_LOCALIZE               \
2014         assert(o)
2015 
2016 PERL_CALLCONV I32
2017 Perl_looks_like_number(pTHX_ SV * const sv)
2018         __attribute__warn_unused_result__;
2019 #define PERL_ARGS_ASSERT_LOOKS_LIKE_NUMBER      \
2020         assert(sv)
2021 
2022 PERL_CALLCONV int
2023 Perl_magic_clear_all_env(pTHX_ SV *sv, MAGIC *mg)
2024         __attribute__visibility__("hidden");
2025 #define PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV    \
2026         assert(sv); assert(mg)
2027 
2028 PERL_CALLCONV int
2029 Perl_magic_cleararylen_p(pTHX_ SV *sv, MAGIC *mg)
2030         __attribute__visibility__("hidden");
2031 #define PERL_ARGS_ASSERT_MAGIC_CLEARARYLEN_P    \
2032         assert(sv); assert(mg)
2033 
2034 PERL_CALLCONV int
2035 Perl_magic_clearenv(pTHX_ SV *sv, MAGIC *mg)
2036         __attribute__visibility__("hidden");
2037 #define PERL_ARGS_ASSERT_MAGIC_CLEARENV         \
2038         assert(sv); assert(mg)
2039 
2040 PERL_CALLCONV int
2041 Perl_magic_clearhint(pTHX_ SV *sv, MAGIC *mg)
2042         __attribute__visibility__("hidden");
2043 #define PERL_ARGS_ASSERT_MAGIC_CLEARHINT        \
2044         assert(sv); assert(mg)
2045 
2046 PERL_CALLCONV int
2047 Perl_magic_clearhints(pTHX_ SV *sv, MAGIC *mg)
2048         __attribute__visibility__("hidden");
2049 #define PERL_ARGS_ASSERT_MAGIC_CLEARHINTS       \
2050         assert(sv); assert(mg)
2051 
2052 PERL_CALLCONV int
2053 Perl_magic_clearhook(pTHX_ SV *sv, MAGIC *mg)
2054         __attribute__visibility__("hidden");
2055 #define PERL_ARGS_ASSERT_MAGIC_CLEARHOOK        \
2056         assert(mg)
2057 
2058 PERL_CALLCONV int
2059 Perl_magic_clearhookall(pTHX_ SV *sv, MAGIC *mg)
2060         __attribute__visibility__("hidden");
2061 #define PERL_ARGS_ASSERT_MAGIC_CLEARHOOKALL     \
2062         assert(mg)
2063 
2064 PERL_CALLCONV int
2065 Perl_magic_clearisa(pTHX_ SV *sv, MAGIC *mg)
2066         __attribute__visibility__("hidden");
2067 #define PERL_ARGS_ASSERT_MAGIC_CLEARISA         \
2068         assert(mg)
2069 
2070 PERL_CALLCONV int
2071 Perl_magic_clearpack(pTHX_ SV *sv, MAGIC *mg)
2072         __attribute__visibility__("hidden");
2073 #define PERL_ARGS_ASSERT_MAGIC_CLEARPACK        \
2074         assert(sv); assert(mg)
2075 
2076 PERL_CALLCONV int
2077 Perl_magic_clearsig(pTHX_ SV *sv, MAGIC *mg)
2078         __attribute__visibility__("hidden");
2079 #define PERL_ARGS_ASSERT_MAGIC_CLEARSIG         \
2080         assert(sv); assert(mg)
2081 
2082 PERL_CALLCONV int
2083 Perl_magic_copycallchecker(pTHX_ SV *sv, MAGIC *mg, SV *nsv, const char *name, I32 namlen)
2084         __attribute__visibility__("hidden");
2085 #define PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER  \
2086         assert(sv); assert(mg); assert(nsv)
2087 
2088 PERL_CALLCONV void
2089 Perl_magic_dump(pTHX_ const MAGIC *mg);
2090 #define PERL_ARGS_ASSERT_MAGIC_DUMP
2091 
2092 PERL_CALLCONV int
2093 Perl_magic_existspack(pTHX_ SV *sv, const MAGIC *mg)
2094         __attribute__visibility__("hidden");
2095 #define PERL_ARGS_ASSERT_MAGIC_EXISTSPACK       \
2096         assert(sv); assert(mg)
2097 
2098 PERL_CALLCONV int
2099 Perl_magic_freearylen_p(pTHX_ SV *sv, MAGIC *mg)
2100         __attribute__visibility__("hidden");
2101 #define PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P     \
2102         assert(sv); assert(mg)
2103 
2104 PERL_CALLCONV int
2105 Perl_magic_freedestruct(pTHX_ SV *sv, MAGIC *mg)
2106         __attribute__visibility__("hidden");
2107 #define PERL_ARGS_ASSERT_MAGIC_FREEDESTRUCT     \
2108         assert(sv); assert(mg)
2109 
2110 PERL_CALLCONV int
2111 Perl_magic_freemglob(pTHX_ SV *sv, MAGIC *mg)
2112         __attribute__visibility__("hidden");
2113 #define PERL_ARGS_ASSERT_MAGIC_FREEMGLOB        \
2114         assert(sv); assert(mg)
2115 
2116 PERL_CALLCONV int
2117 Perl_magic_freeovrld(pTHX_ SV *sv, MAGIC *mg)
2118         __attribute__visibility__("hidden");
2119 #define PERL_ARGS_ASSERT_MAGIC_FREEOVRLD        \
2120         assert(sv); assert(mg)
2121 
2122 PERL_CALLCONV int
2123 Perl_magic_freeutf8(pTHX_ SV *sv, MAGIC *mg)
2124         __attribute__visibility__("hidden");
2125 #define PERL_ARGS_ASSERT_MAGIC_FREEUTF8         \
2126         assert(sv); assert(mg)
2127 
2128 PERL_CALLCONV int
2129 Perl_magic_get(pTHX_ SV *sv, MAGIC *mg)
2130         __attribute__visibility__("hidden");
2131 #define PERL_ARGS_ASSERT_MAGIC_GET              \
2132         assert(sv); assert(mg)
2133 
2134 PERL_CALLCONV int
2135 Perl_magic_getarylen(pTHX_ SV *sv, const MAGIC *mg)
2136         __attribute__visibility__("hidden");
2137 #define PERL_ARGS_ASSERT_MAGIC_GETARYLEN        \
2138         assert(sv); assert(mg)
2139 
2140 PERL_CALLCONV int
2141 Perl_magic_getdebugvar(pTHX_ SV *sv, MAGIC *mg)
2142         __attribute__visibility__("hidden");
2143 #define PERL_ARGS_ASSERT_MAGIC_GETDEBUGVAR      \
2144         assert(sv); assert(mg)
2145 
2146 PERL_CALLCONV int
2147 Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg)
2148         __attribute__visibility__("hidden");
2149 #define PERL_ARGS_ASSERT_MAGIC_GETDEFELEM       \
2150         assert(sv); assert(mg)
2151 
2152 PERL_CALLCONV int
2153 Perl_magic_getnkeys(pTHX_ SV *sv, MAGIC *mg)
2154         __attribute__visibility__("hidden");
2155 #define PERL_ARGS_ASSERT_MAGIC_GETNKEYS         \
2156         assert(sv); assert(mg)
2157 
2158 PERL_CALLCONV int
2159 Perl_magic_getpack(pTHX_ SV *sv, MAGIC *mg)
2160         __attribute__visibility__("hidden");
2161 #define PERL_ARGS_ASSERT_MAGIC_GETPACK          \
2162         assert(sv); assert(mg)
2163 
2164 PERL_CALLCONV int
2165 Perl_magic_getpos(pTHX_ SV *sv, MAGIC *mg)
2166         __attribute__visibility__("hidden");
2167 #define PERL_ARGS_ASSERT_MAGIC_GETPOS           \
2168         assert(sv); assert(mg)
2169 
2170 PERL_CALLCONV int
2171 Perl_magic_getsig(pTHX_ SV *sv, MAGIC *mg)
2172         __attribute__visibility__("hidden");
2173 #define PERL_ARGS_ASSERT_MAGIC_GETSIG           \
2174         assert(sv); assert(mg)
2175 
2176 PERL_CALLCONV int
2177 Perl_magic_getsubstr(pTHX_ SV *sv, MAGIC *mg)
2178         __attribute__visibility__("hidden");
2179 #define PERL_ARGS_ASSERT_MAGIC_GETSUBSTR        \
2180         assert(sv); assert(mg)
2181 
2182 PERL_CALLCONV int
2183 Perl_magic_gettaint(pTHX_ SV *sv, MAGIC *mg)
2184         __attribute__visibility__("hidden");
2185 #define PERL_ARGS_ASSERT_MAGIC_GETTAINT         \
2186         assert(sv); assert(mg)
2187 
2188 PERL_CALLCONV int
2189 Perl_magic_getuvar(pTHX_ SV *sv, MAGIC *mg)
2190         __attribute__visibility__("hidden");
2191 #define PERL_ARGS_ASSERT_MAGIC_GETUVAR          \
2192         assert(sv); assert(mg)
2193 
2194 PERL_CALLCONV int
2195 Perl_magic_getvec(pTHX_ SV *sv, MAGIC *mg)
2196         __attribute__visibility__("hidden");
2197 #define PERL_ARGS_ASSERT_MAGIC_GETVEC           \
2198         assert(sv); assert(mg)
2199 
2200 PERL_CALLCONV int
2201 Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg)
2202         __attribute__visibility__("hidden");
2203 #define PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS     \
2204         assert(sv); assert(mg)
2205 
2206 PERL_CALLCONV SV *
2207 Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, U32 argc, ...)
2208         __attribute__visibility__("hidden");
2209 #define PERL_ARGS_ASSERT_MAGIC_METHCALL         \
2210         assert(sv); assert(mg); assert(meth)
2211 
2212 PERL_CALLCONV int
2213 Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key)
2214         __attribute__visibility__("hidden");
2215 #define PERL_ARGS_ASSERT_MAGIC_NEXTPACK         \
2216         assert(sv); assert(mg); assert(key)
2217 
2218 PERL_CALLCONV U32
2219 Perl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg)
2220         __attribute__visibility__("hidden");
2221 #define PERL_ARGS_ASSERT_MAGIC_REGDATA_CNT      \
2222         assert(sv); assert(mg)
2223 
2224 PERL_CALLCONV int
2225 Perl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg)
2226         __attribute__visibility__("hidden");
2227 #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET     \
2228         assert(sv); assert(mg)
2229 
2230 PERL_CALLCONV SV *
2231 Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg)
2232         __attribute__visibility__("hidden");
2233 #define PERL_ARGS_ASSERT_MAGIC_SCALARPACK       \
2234         assert(hv); assert(mg)
2235 
2236 PERL_CALLCONV int
2237 Perl_magic_set(pTHX_ SV *sv, MAGIC *mg)
2238         __attribute__visibility__("hidden");
2239 #define PERL_ARGS_ASSERT_MAGIC_SET              \
2240         assert(sv); assert(mg)
2241 
2242 PERL_CALLCONV int
2243 Perl_magic_set_all_env(pTHX_ SV *sv, MAGIC *mg)
2244         __attribute__visibility__("hidden");
2245 #define PERL_ARGS_ASSERT_MAGIC_SET_ALL_ENV      \
2246         assert(sv); assert(mg)
2247 
2248 PERL_CALLCONV int
2249 Perl_magic_setarylen(pTHX_ SV *sv, MAGIC *mg)
2250         __attribute__visibility__("hidden");
2251 #define PERL_ARGS_ASSERT_MAGIC_SETARYLEN        \
2252         assert(sv); assert(mg)
2253 
2254 PERL_CALLCONV int
2255 Perl_magic_setdbline(pTHX_ SV *sv, MAGIC *mg)
2256         __attribute__visibility__("hidden");
2257 #define PERL_ARGS_ASSERT_MAGIC_SETDBLINE        \
2258         assert(sv); assert(mg)
2259 
2260 PERL_CALLCONV int
2261 Perl_magic_setdebugvar(pTHX_ SV *sv, MAGIC *mg)
2262         __attribute__visibility__("hidden");
2263 #define PERL_ARGS_ASSERT_MAGIC_SETDEBUGVAR      \
2264         assert(sv); assert(mg)
2265 
2266 PERL_CALLCONV int
2267 Perl_magic_setdefelem(pTHX_ SV *sv, MAGIC *mg)
2268         __attribute__visibility__("hidden");
2269 #define PERL_ARGS_ASSERT_MAGIC_SETDEFELEM       \
2270         assert(sv); assert(mg)
2271 
2272 PERL_CALLCONV int
2273 Perl_magic_setenv(pTHX_ SV *sv, MAGIC *mg)
2274         __attribute__visibility__("hidden");
2275 #define PERL_ARGS_ASSERT_MAGIC_SETENV           \
2276         assert(sv); assert(mg)
2277 
2278 PERL_CALLCONV int
2279 Perl_magic_sethint(pTHX_ SV *sv, MAGIC *mg)
2280         __attribute__visibility__("hidden");
2281 #define PERL_ARGS_ASSERT_MAGIC_SETHINT          \
2282         assert(sv); assert(mg)
2283 
2284 PERL_CALLCONV int
2285 Perl_magic_sethook(pTHX_ SV *sv, MAGIC *mg)
2286         __attribute__visibility__("hidden");
2287 #define PERL_ARGS_ASSERT_MAGIC_SETHOOK          \
2288         assert(mg)
2289 
2290 PERL_CALLCONV int
2291 Perl_magic_sethookall(pTHX_ SV *sv, MAGIC *mg)
2292         __attribute__visibility__("hidden");
2293 #define PERL_ARGS_ASSERT_MAGIC_SETHOOKALL       \
2294         assert(sv); assert(mg)
2295 
2296 PERL_CALLCONV int
2297 Perl_magic_setisa(pTHX_ SV *sv, MAGIC *mg)
2298         __attribute__visibility__("hidden");
2299 #define PERL_ARGS_ASSERT_MAGIC_SETISA           \
2300         assert(sv); assert(mg)
2301 
2302 PERL_CALLCONV int
2303 Perl_magic_setlvref(pTHX_ SV *sv, MAGIC *mg)
2304         __attribute__visibility__("hidden");
2305 #define PERL_ARGS_ASSERT_MAGIC_SETLVREF         \
2306         assert(sv); assert(mg)
2307 
2308 PERL_CALLCONV int
2309 Perl_magic_setmglob(pTHX_ SV *sv, MAGIC *mg)
2310         __attribute__visibility__("hidden");
2311 #define PERL_ARGS_ASSERT_MAGIC_SETMGLOB         \
2312         assert(sv); assert(mg)
2313 
2314 PERL_CALLCONV int
2315 Perl_magic_setnkeys(pTHX_ SV *sv, MAGIC *mg)
2316         __attribute__visibility__("hidden");
2317 #define PERL_ARGS_ASSERT_MAGIC_SETNKEYS         \
2318         assert(sv); assert(mg)
2319 
2320 PERL_CALLCONV int
2321 Perl_magic_setnonelem(pTHX_ SV *sv, MAGIC *mg)
2322         __attribute__visibility__("hidden");
2323 #define PERL_ARGS_ASSERT_MAGIC_SETNONELEM       \
2324         assert(sv); assert(mg)
2325 
2326 PERL_CALLCONV int
2327 Perl_magic_setpack(pTHX_ SV *sv, MAGIC *mg)
2328         __attribute__visibility__("hidden");
2329 #define PERL_ARGS_ASSERT_MAGIC_SETPACK          \
2330         assert(sv); assert(mg)
2331 
2332 PERL_CALLCONV int
2333 Perl_magic_setpos(pTHX_ SV *sv, MAGIC *mg)
2334         __attribute__visibility__("hidden");
2335 #define PERL_ARGS_ASSERT_MAGIC_SETPOS           \
2336         assert(sv); assert(mg)
2337 
2338 PERL_CALLCONV int
2339 Perl_magic_setregexp(pTHX_ SV *sv, MAGIC *mg)
2340         __attribute__visibility__("hidden");
2341 #define PERL_ARGS_ASSERT_MAGIC_SETREGEXP        \
2342         assert(sv); assert(mg)
2343 
2344 PERL_CALLCONV int
2345 Perl_magic_setsig(pTHX_ SV *sv, MAGIC *mg)
2346         __attribute__visibility__("hidden");
2347 #define PERL_ARGS_ASSERT_MAGIC_SETSIG           \
2348         assert(mg)
2349 
2350 PERL_CALLCONV int
2351 Perl_magic_setsigall(pTHX_ SV *sv, MAGIC *mg)
2352         __attribute__visibility__("hidden");
2353 #define PERL_ARGS_ASSERT_MAGIC_SETSIGALL        \
2354         assert(sv); assert(mg)
2355 
2356 PERL_CALLCONV int
2357 Perl_magic_setsubstr(pTHX_ SV *sv, MAGIC *mg)
2358         __attribute__visibility__("hidden");
2359 #define PERL_ARGS_ASSERT_MAGIC_SETSUBSTR        \
2360         assert(sv); assert(mg)
2361 
2362 PERL_CALLCONV int
2363 Perl_magic_settaint(pTHX_ SV *sv, MAGIC *mg)
2364         __attribute__visibility__("hidden");
2365 #define PERL_ARGS_ASSERT_MAGIC_SETTAINT         \
2366         assert(sv); assert(mg)
2367 
2368 PERL_CALLCONV int
2369 Perl_magic_setutf8(pTHX_ SV *sv, MAGIC *mg)
2370         __attribute__visibility__("hidden");
2371 #define PERL_ARGS_ASSERT_MAGIC_SETUTF8          \
2372         assert(sv); assert(mg)
2373 
2374 PERL_CALLCONV int
2375 Perl_magic_setuvar(pTHX_ SV *sv, MAGIC *mg)
2376         __attribute__visibility__("hidden");
2377 #define PERL_ARGS_ASSERT_MAGIC_SETUVAR          \
2378         assert(sv); assert(mg)
2379 
2380 PERL_CALLCONV int
2381 Perl_magic_setvec(pTHX_ SV *sv, MAGIC *mg)
2382         __attribute__visibility__("hidden");
2383 #define PERL_ARGS_ASSERT_MAGIC_SETVEC           \
2384         assert(sv); assert(mg)
2385 
2386 PERL_CALLCONV U32
2387 Perl_magic_sizepack(pTHX_ SV *sv, MAGIC *mg)
2388         __attribute__visibility__("hidden");
2389 #define PERL_ARGS_ASSERT_MAGIC_SIZEPACK         \
2390         assert(sv); assert(mg)
2391 
2392 PERL_CALLCONV int
2393 Perl_magic_wipepack(pTHX_ SV *sv, MAGIC *mg)
2394         __attribute__visibility__("hidden");
2395 #define PERL_ARGS_ASSERT_MAGIC_WIPEPACK         \
2396         assert(sv); assert(mg)
2397 
2398 PERL_CALLCONV Malloc_t
2399 Perl_malloc(MEM_SIZE nbytes)
2400         __attribute__malloc__
2401         __attribute__warn_unused_result__;
2402 #define PERL_ARGS_ASSERT_MALLOC
2403 
2404 PERL_CALLCONV Stack_off_t *
2405 Perl_markstack_grow(pTHX);
2406 #define PERL_ARGS_ASSERT_MARKSTACK_GROW
2407 
2408 PERL_CALLCONV int
2409 Perl_mbtowc_(pTHX_ const wchar_t *pwc, const char *s, const Size_t len);
2410 #define PERL_ARGS_ASSERT_MBTOWC_
2411 
2412 PERL_CALLCONV SV *
2413 Perl_mess(pTHX_ const char *pat, ...)
2414         __attribute__format__(__printf__,pTHX_1,pTHX_2);
2415 #define PERL_ARGS_ASSERT_MESS                   \
2416         assert(pat)
2417 
2418 PERL_CALLCONV SV *
2419 Perl_mess_sv(pTHX_ SV *basemsg, bool consume);
2420 #define PERL_ARGS_ASSERT_MESS_SV                \
2421         assert(basemsg)
2422 
2423 PERL_CALLCONV Free_t
2424 Perl_mfree(Malloc_t where);
2425 #define PERL_ARGS_ASSERT_MFREE
2426 
2427 PERL_CALLCONV int
2428 Perl_mg_clear(pTHX_ SV *sv);
2429 #define PERL_ARGS_ASSERT_MG_CLEAR               \
2430         assert(sv)
2431 
2432 PERL_CALLCONV int
2433 Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen);
2434 #define PERL_ARGS_ASSERT_MG_COPY                \
2435         assert(sv); assert(nsv)
2436 
2437 PERL_CALLCONV MAGIC *
2438 Perl_mg_find(const SV *sv, int type)
2439         __attribute__warn_unused_result__;
2440 #define PERL_ARGS_ASSERT_MG_FIND
2441 
2442 PERL_CALLCONV MAGIC *
2443 Perl_mg_find_mglob(pTHX_ SV *sv)
2444         __attribute__warn_unused_result__;
2445 #define PERL_ARGS_ASSERT_MG_FIND_MGLOB          \
2446         assert(sv)
2447 
2448 PERL_CALLCONV MAGIC *
2449 Perl_mg_findext(const SV *sv, int type, const MGVTBL *vtbl)
2450         __attribute__warn_unused_result__;
2451 #define PERL_ARGS_ASSERT_MG_FINDEXT
2452 
2453 PERL_CALLCONV int
2454 Perl_mg_free(pTHX_ SV *sv);
2455 #define PERL_ARGS_ASSERT_MG_FREE                \
2456         assert(sv)
2457 
2458 PERL_CALLCONV void
2459 Perl_mg_free_type(pTHX_ SV *sv, int how);
2460 #define PERL_ARGS_ASSERT_MG_FREE_TYPE           \
2461         assert(sv)
2462 
2463 PERL_CALLCONV void
2464 Perl_mg_freeext(pTHX_ SV *sv, int how, const MGVTBL *vtbl);
2465 #define PERL_ARGS_ASSERT_MG_FREEEXT             \
2466         assert(sv)
2467 
2468 PERL_CALLCONV int
2469 Perl_mg_get(pTHX_ SV *sv);
2470 #define PERL_ARGS_ASSERT_MG_GET                 \
2471         assert(sv)
2472 
2473 PERL_CALLCONV void
2474 Perl_mg_localize(pTHX_ SV *sv, SV *nsv, bool setmagic)
2475         __attribute__visibility__("hidden");
2476 #define PERL_ARGS_ASSERT_MG_LOCALIZE            \
2477         assert(sv); assert(nsv)
2478 
2479 PERL_CALLCONV void
2480 Perl_mg_magical(SV *sv);
2481 #define PERL_ARGS_ASSERT_MG_MAGICAL             \
2482         assert(sv)
2483 
2484 PERL_CALLCONV int
2485 Perl_mg_set(pTHX_ SV *sv);
2486 #define PERL_ARGS_ASSERT_MG_SET                 \
2487         assert(sv)
2488 
2489 PERL_CALLCONV I32
2490 Perl_mg_size(pTHX_ SV *sv);
2491 #define PERL_ARGS_ASSERT_MG_SIZE                \
2492         assert(sv)
2493 
2494 PERL_CALLCONV void
2495 Perl_mini_mktime(struct tm *ptm);
2496 #define PERL_ARGS_ASSERT_MINI_MKTIME            \
2497         assert(ptm)
2498 
2499 PERL_CALLCONV int
2500 Perl_mode_from_discipline(pTHX_ const char *s, STRLEN len)
2501         __attribute__visibility__("hidden");
2502 #define PERL_ARGS_ASSERT_MODE_FROM_DISCIPLINE
2503 
2504 PERL_CALLCONV void *
2505 Perl_more_bodies(pTHX_ const svtype sv_type, const size_t body_size, const size_t arena_size);
2506 #define PERL_ARGS_ASSERT_MORE_BODIES
2507 
2508 PERL_CALLCONV const char *
2509 Perl_moreswitches(pTHX_ const char *s);
2510 #define PERL_ARGS_ASSERT_MORESWITCHES           \
2511         assert(s)
2512 
2513 PERL_CALLCONV void
2514 Perl_mortal_destructor_sv(pTHX_ SV *coderef, SV *args);
2515 #define PERL_ARGS_ASSERT_MORTAL_DESTRUCTOR_SV   \
2516         assert(coderef)
2517 
2518 PERL_CALLCONV void
2519 Perl_mortal_svfunc_x(pTHX_ SVFUNC_t f, SV *p);
2520 #define PERL_ARGS_ASSERT_MORTAL_SVFUNC_X
2521 
2522 PERL_CALLCONV const struct mro_alg *
2523 Perl_mro_get_from_name(pTHX_ SV *name);
2524 #define PERL_ARGS_ASSERT_MRO_GET_FROM_NAME      \
2525         assert(name)
2526 
2527 PERL_CALLCONV AV *
2528 Perl_mro_get_linear_isa(pTHX_ HV *stash);
2529 #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA     \
2530         assert(stash)
2531 
2532 PERL_CALLCONV SV *
2533 Perl_mro_get_private_data(pTHX_ struct mro_meta * const smeta, const struct mro_alg * const which);
2534 #define PERL_ARGS_ASSERT_MRO_GET_PRIVATE_DATA   \
2535         assert(smeta); assert(which)
2536 
2537 PERL_CALLCONV void
2538 Perl_mro_isa_changed_in(pTHX_ HV *stash)
2539         __attribute__visibility__("hidden");
2540 #define PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN     \
2541         assert(stash)
2542 
2543 PERL_CALLCONV struct mro_meta *
2544 Perl_mro_meta_init(pTHX_ HV *stash);
2545 #define PERL_ARGS_ASSERT_MRO_META_INIT          \
2546         assert(stash)
2547 
2548 PERL_CALLCONV void
2549 Perl_mro_method_changed_in(pTHX_ HV *stash);
2550 #define PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN  \
2551         assert(stash)
2552 
2553 PERL_CALLCONV void
2554 Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash, const GV * const gv, U32 flags);
2555 #define PERL_ARGS_ASSERT_MRO_PACKAGE_MOVED      \
2556         assert(gv)
2557 
2558 PERL_CALLCONV void
2559 Perl_mro_register(pTHX_ const struct mro_alg *mro);
2560 #define PERL_ARGS_ASSERT_MRO_REGISTER           \
2561         assert(mro)
2562 
2563 PERL_CALLCONV void
2564 Perl_mro_set_mro(pTHX_ struct mro_meta * const meta, SV * const name);
2565 #define PERL_ARGS_ASSERT_MRO_SET_MRO            \
2566         assert(meta); assert(name)
2567 
2568 PERL_CALLCONV SV *
2569 Perl_mro_set_private_data(pTHX_ struct mro_meta * const smeta, const struct mro_alg * const which, SV * const data);
2570 #define PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA   \
2571         assert(smeta); assert(which); assert(data)
2572 
2573 PERL_CALLCONV SV *
2574 Perl_multiconcat_stringify(pTHX_ const OP *o);
2575 #define PERL_ARGS_ASSERT_MULTICONCAT_STRINGIFY  \
2576         assert(o)
2577 
2578 PERL_CALLCONV SV *
2579 Perl_multideref_stringify(pTHX_ const OP *o, CV *cv);
2580 #define PERL_ARGS_ASSERT_MULTIDEREF_STRINGIFY   \
2581         assert(o)
2582 
2583 PERL_CALLCONV NV
2584 Perl_my_atof(pTHX_ const char *s);
2585 #define PERL_ARGS_ASSERT_MY_ATOF                \
2586         assert(s)
2587 
2588 PERL_CALLCONV char *
2589 Perl_my_atof2(pTHX_ const char *orig, NV *value);
2590 #define PERL_ARGS_ASSERT_MY_ATOF2               \
2591         assert(orig); assert(value)
2592 
2593 PERL_CALLCONV char *
2594 Perl_my_atof3(pTHX_ const char *orig, NV *value, const STRLEN len);
2595 #define PERL_ARGS_ASSERT_MY_ATOF3               \
2596         assert(orig); assert(value)
2597 
2598 PERL_CALLCONV OP *
2599 Perl_my_attrs(pTHX_ OP *o, OP *attrs)
2600         __attribute__visibility__("hidden");
2601 #define PERL_ARGS_ASSERT_MY_ATTRS               \
2602         assert(o)
2603 
2604 PERL_CALLCONV void
2605 Perl_my_clearenv(pTHX);
2606 #define PERL_ARGS_ASSERT_MY_CLEARENV
2607 
2608 PERL_CALLCONV int
2609 Perl_my_dirfd(DIR *dir);
2610 #define PERL_ARGS_ASSERT_MY_DIRFD
2611 
2612 PERL_CALLCONV_NO_RET void
2613 Perl_my_exit(pTHX_ U32 status)
2614         __attribute__noreturn__;
2615 #define PERL_ARGS_ASSERT_MY_EXIT
2616 
2617 PERL_CALLCONV_NO_RET void
2618 Perl_my_failure_exit(pTHX)
2619         __attribute__noreturn__;
2620 #define PERL_ARGS_ASSERT_MY_FAILURE_EXIT
2621 
2622 PERL_CALLCONV I32
2623 Perl_my_fflush_all(pTHX);
2624 #define PERL_ARGS_ASSERT_MY_FFLUSH_ALL
2625 
2626 PERL_CALLCONV Pid_t
2627 Perl_my_fork(void);
2628 #define PERL_ARGS_ASSERT_MY_FORK
2629 
2630 /* PERL_CALLCONV I32
2631 my_lstat(pTHX); */
2632 
2633 PERL_CALLCONV I32
2634 Perl_my_lstat_flags(pTHX_ const U32 flags);
2635 #define PERL_ARGS_ASSERT_MY_LSTAT_FLAGS
2636 
2637 PERL_CALLCONV int
2638 Perl_my_mkostemp_cloexec(char *templte, int flags)
2639         __attribute__warn_unused_result__
2640         __attribute__visibility__("hidden");
2641 #define PERL_ARGS_ASSERT_MY_MKOSTEMP_CLOEXEC    \
2642         assert(templte)
2643 
2644 PERL_CALLCONV int
2645 Perl_my_mkstemp_cloexec(char *templte)
2646         __attribute__warn_unused_result__
2647         __attribute__visibility__("hidden");
2648 #define PERL_ARGS_ASSERT_MY_MKSTEMP_CLOEXEC     \
2649         assert(templte)
2650 
2651 PERL_CALLCONV PerlIO *
2652 Perl_my_popen_list(pTHX_ const char *mode, int n, SV **args);
2653 #define PERL_ARGS_ASSERT_MY_POPEN_LIST          \
2654         assert(mode); assert(args)
2655 
2656 PERL_CALLCONV void
2657 Perl_my_setenv(pTHX_ const char *nam, const char *val);
2658 #define PERL_ARGS_ASSERT_MY_SETENV
2659 
2660 PERL_CALLCONV int
2661 Perl_my_snprintf(char *buffer, const Size_t len, const char *format, ...)
2662         __attribute__format__(__printf__,3,4);
2663 #define PERL_ARGS_ASSERT_MY_SNPRINTF            \
2664         assert(buffer); assert(format)
2665 
2666 PERL_CALLCONV int
2667 Perl_my_socketpair(int family, int type, int protocol, int fd[2]);
2668 #define PERL_ARGS_ASSERT_MY_SOCKETPAIR
2669 
2670 /* PERL_CALLCONV I32
2671 my_stat(pTHX); */
2672 
2673 PERL_CALLCONV I32
2674 Perl_my_stat_flags(pTHX_ const U32 flags);
2675 #define PERL_ARGS_ASSERT_MY_STAT_FLAGS
2676 
2677 PERL_CALLCONV const char *
2678 Perl_my_strerror(pTHX_ const int errnum, utf8ness_t *utf8ness)
2679         __attribute__visibility__("hidden");
2680 #define PERL_ARGS_ASSERT_MY_STRERROR            \
2681         assert(utf8ness)
2682 
2683 PERL_CALLCONV char *
2684 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)
2685         __attribute__format__(__strftime__,pTHX_1,0);
2686 #define PERL_ARGS_ASSERT_MY_STRFTIME            \
2687         assert(fmt)
2688 
2689 PERL_CALLCONV NV
2690 Perl_my_strtod(const char * const s, char **e)
2691         __attribute__warn_unused_result__;
2692 #define PERL_ARGS_ASSERT_MY_STRTOD              \
2693         assert(s)
2694 
2695 PERL_CALLCONV void
2696 Perl_my_unexec(pTHX)
2697         __attribute__visibility__("hidden");
2698 #define PERL_ARGS_ASSERT_MY_UNEXEC
2699 
2700 PERL_CALLCONV int
2701 Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap);
2702 #define PERL_ARGS_ASSERT_MY_VSNPRINTF           \
2703         assert(buffer); assert(format)
2704 
2705 PERL_CALLCONV OP *
2706 Perl_newANONATTRSUB(pTHX_ I32 floor, OP *proto, OP *attrs, OP *block);
2707 #define PERL_ARGS_ASSERT_NEWANONATTRSUB
2708 
2709 PERL_CALLCONV OP *
2710 Perl_newANONHASH(pTHX_ OP *o)
2711         __attribute__warn_unused_result__;
2712 #define PERL_ARGS_ASSERT_NEWANONHASH
2713 
2714 PERL_CALLCONV OP *
2715 Perl_newANONLIST(pTHX_ OP *o)
2716         __attribute__warn_unused_result__;
2717 #define PERL_ARGS_ASSERT_NEWANONLIST
2718 
2719 PERL_CALLCONV OP *
2720 Perl_newANONSUB(pTHX_ I32 floor, OP *proto, OP *block);
2721 #define PERL_ARGS_ASSERT_NEWANONSUB
2722 
2723 PERL_CALLCONV OP *
2724 Perl_newARGDEFELEMOP(pTHX_ I32 flags, OP *expr, I32 argindex)
2725         __attribute__warn_unused_result__;
2726 #define PERL_ARGS_ASSERT_NEWARGDEFELEMOP        \
2727         assert(expr)
2728 
2729 PERL_CALLCONV OP *
2730 Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
2731         __attribute__warn_unused_result__;
2732 #define PERL_ARGS_ASSERT_NEWASSIGNOP
2733 
2734 /* PERL_CALLCONV CV *
2735 newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); */
2736 
2737 PERL_CALLCONV CV *
2738 Perl_newATTRSUB_x(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block, bool o_is_gv);
2739 #define PERL_ARGS_ASSERT_NEWATTRSUB_X
2740 
2741 PERL_CALLCONV OP *
2742 Perl_newAVREF(pTHX_ OP *o)
2743         __attribute__warn_unused_result__;
2744 #define PERL_ARGS_ASSERT_NEWAVREF               \
2745         assert(o)
2746 
2747 /* PERL_CALLCONV AV *
2748 newAV_alloc_x(pTHX_ SSize_t size)
2749         __attribute__warn_unused_result__; */
2750 
2751 /* PERL_CALLCONV AV *
2752 newAV_alloc_xz(pTHX_ SSize_t size)
2753         __attribute__warn_unused_result__; */
2754 
2755 /* PERL_CALLCONV AV *
2756 newAV_mortal(pTHX)
2757         __attribute__warn_unused_result__; */
2758 
2759 PERL_CALLCONV AV *
2760 Perl_newAVav(pTHX_ AV *oav)
2761         __attribute__warn_unused_result__;
2762 #define PERL_ARGS_ASSERT_NEWAVAV
2763 
2764 PERL_CALLCONV AV *
2765 Perl_newAVhv(pTHX_ HV *ohv)
2766         __attribute__warn_unused_result__;
2767 #define PERL_ARGS_ASSERT_NEWAVHV
2768 
2769 PERL_CALLCONV OP *
2770 Perl_newBINOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
2771         __attribute__warn_unused_result__;
2772 #define PERL_ARGS_ASSERT_NEWBINOP
2773 
2774 PERL_CALLCONV OP *
2775 Perl_newCONDOP(pTHX_ I32 flags, OP *first, OP *trueop, OP *falseop)
2776         __attribute__warn_unused_result__;
2777 #define PERL_ARGS_ASSERT_NEWCONDOP              \
2778         assert(first)
2779 
2780 PERL_CALLCONV CV *
2781 Perl_newCONSTSUB(pTHX_ HV *stash, const char *name, SV *sv);
2782 #define PERL_ARGS_ASSERT_NEWCONSTSUB
2783 
2784 PERL_CALLCONV CV *
2785 Perl_newCONSTSUB_flags(pTHX_ HV *stash, const char *name, STRLEN len, U32 flags, SV *sv);
2786 #define PERL_ARGS_ASSERT_NEWCONSTSUB_FLAGS
2787 
2788 PERL_CALLCONV OP *
2789 Perl_newCVREF(pTHX_ I32 flags, OP *o)
2790         __attribute__warn_unused_result__;
2791 #define PERL_ARGS_ASSERT_NEWCVREF
2792 
2793 PERL_CALLCONV OP *
2794 Perl_newDEFEROP(pTHX_ I32 flags, OP *block)
2795         __attribute__warn_unused_result__;
2796 #define PERL_ARGS_ASSERT_NEWDEFEROP             \
2797         assert(block)
2798 
2799 PERL_CALLCONV OP *
2800 Perl_newDEFSVOP(pTHX)
2801         __attribute__warn_unused_result__;
2802 #define PERL_ARGS_ASSERT_NEWDEFSVOP
2803 
2804 PERL_CALLCONV void
2805 Perl_newFORM(pTHX_ I32 floor, OP *o, OP *block);
2806 #define PERL_ARGS_ASSERT_NEWFORM
2807 
2808 PERL_CALLCONV OP *
2809 Perl_newFOROP(pTHX_ I32 flags, OP *sv, OP *expr, OP *block, OP *cont)
2810         __attribute__warn_unused_result__;
2811 #define PERL_ARGS_ASSERT_NEWFOROP               \
2812         assert(expr)
2813 
2814 PERL_CALLCONV OP *
2815 Perl_newGIVENOP(pTHX_ OP *cond, OP *block, PADOFFSET defsv_off)
2816         __attribute__warn_unused_result__;
2817 #define PERL_ARGS_ASSERT_NEWGIVENOP             \
2818         assert(cond); assert(block)
2819 
2820 PERL_CALLCONV GP *
2821 Perl_newGP(pTHX_ GV * const gv);
2822 #define PERL_ARGS_ASSERT_NEWGP                  \
2823         assert(gv)
2824 
2825 PERL_CALLCONV OP *
2826 Perl_newGVOP(pTHX_ I32 type, I32 flags, GV *gv)
2827         __attribute__warn_unused_result__;
2828 #define PERL_ARGS_ASSERT_NEWGVOP                \
2829         assert(gv)
2830 
2831 PERL_CALLCONV OP *
2832 Perl_newGVREF(pTHX_ I32 type, OP *o)
2833         __attribute__warn_unused_result__;
2834 #define PERL_ARGS_ASSERT_NEWGVREF
2835 
2836 /* PERL_CALLCONV GV *
2837 newGVgen(pTHX_ const char *pack); */
2838 
2839 PERL_CALLCONV GV *
2840 Perl_newGVgen_flags(pTHX_ const char *pack, U32 flags)
2841         __attribute__warn_unused_result__;
2842 #define PERL_ARGS_ASSERT_NEWGVGEN_FLAGS         \
2843         assert(pack)
2844 
2845 PERL_CALLCONV OP *
2846 Perl_newHVREF(pTHX_ OP *o)
2847         __attribute__warn_unused_result__;
2848 #define PERL_ARGS_ASSERT_NEWHVREF               \
2849         assert(o)
2850 
2851 PERL_CALLCONV HV *
2852 Perl_newHVhv(pTHX_ HV *hv)
2853         __attribute__warn_unused_result__;
2854 #define PERL_ARGS_ASSERT_NEWHVHV
2855 
2856 PERL_CALLCONV OP *
2857 Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
2858         __attribute__warn_unused_result__;
2859 #define PERL_ARGS_ASSERT_NEWLISTOP
2860 
2861 PERL_CALLCONV OP *
2862 Perl_newLISTOPn(pTHX_ I32 type, I32 flags, ...)
2863         __attribute__warn_unused_result__;
2864 #define PERL_ARGS_ASSERT_NEWLISTOPN
2865 
2866 PERL_CALLCONV OP *
2867 Perl_newLOGOP(pTHX_ I32 optype, I32 flags, OP *first, OP *other)
2868         __attribute__warn_unused_result__;
2869 #define PERL_ARGS_ASSERT_NEWLOGOP               \
2870         assert(first); assert(other)
2871 
2872 PERL_CALLCONV OP *
2873 Perl_newLOOPEX(pTHX_ I32 type, OP *label)
2874         __attribute__warn_unused_result__;
2875 #define PERL_ARGS_ASSERT_NEWLOOPEX              \
2876         assert(label)
2877 
2878 PERL_CALLCONV OP *
2879 Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP *expr, OP *block)
2880         __attribute__warn_unused_result__;
2881 #define PERL_ARGS_ASSERT_NEWLOOPOP              \
2882         assert(expr)
2883 
2884 PERL_CALLCONV OP *
2885 Perl_newMETHOP(pTHX_ I32 type, I32 flags, OP *dynamic_meth)
2886         __attribute__warn_unused_result__;
2887 #define PERL_ARGS_ASSERT_NEWMETHOP              \
2888         assert(dynamic_meth)
2889 
2890 PERL_CALLCONV OP *
2891 Perl_newMETHOP_named(pTHX_ I32 type, I32 flags, SV * const_meth)
2892         __attribute__warn_unused_result__;
2893 #define PERL_ARGS_ASSERT_NEWMETHOP_NAMED        \
2894         assert(const_meth)
2895 
2896 PERL_CALLCONV CV *
2897 Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block);
2898 #define PERL_ARGS_ASSERT_NEWMYSUB               \
2899         assert(o)
2900 
2901 PERL_CALLCONV OP *
2902 Perl_newNULLLIST(pTHX)
2903         __attribute__warn_unused_result__;
2904 #define PERL_ARGS_ASSERT_NEWNULLLIST
2905 
2906 PERL_CALLCONV OP *
2907 Perl_newOP(pTHX_ I32 optype, I32 flags)
2908         __attribute__warn_unused_result__;
2909 #define PERL_ARGS_ASSERT_NEWOP
2910 
2911 PERL_CALLCONV PADNAMELIST *
2912 Perl_newPADNAMELIST(size_t max)
2913         __attribute__warn_unused_result__;
2914 #define PERL_ARGS_ASSERT_NEWPADNAMELIST
2915 
2916 PERL_CALLCONV PADNAME *
2917 Perl_newPADNAMEouter(PADNAME *outer)
2918         __attribute__warn_unused_result__;
2919 #define PERL_ARGS_ASSERT_NEWPADNAMEOUTER        \
2920         assert(outer)
2921 
2922 PERL_CALLCONV PADNAME *
2923 Perl_newPADNAMEpvn(const char *s, STRLEN len)
2924         __attribute__warn_unused_result__;
2925 #define PERL_ARGS_ASSERT_NEWPADNAMEPVN          \
2926         assert(s)
2927 
2928 PERL_CALLCONV OP *
2929 Perl_newPMOP(pTHX_ I32 type, I32 flags)
2930         __attribute__warn_unused_result__;
2931 #define PERL_ARGS_ASSERT_NEWPMOP
2932 
2933 PERL_CALLCONV void
2934 Perl_newPROG(pTHX_ OP *o);
2935 #define PERL_ARGS_ASSERT_NEWPROG                \
2936         assert(o)
2937 
2938 PERL_CALLCONV OP *
2939 Perl_newPVOP(pTHX_ I32 type, I32 flags, char *pv)
2940         __attribute__warn_unused_result__;
2941 #define PERL_ARGS_ASSERT_NEWPVOP
2942 
2943 PERL_CALLCONV OP *
2944 Perl_newRANGE(pTHX_ I32 flags, OP *left, OP *right)
2945         __attribute__warn_unused_result__;
2946 #define PERL_ARGS_ASSERT_NEWRANGE               \
2947         assert(left); assert(right)
2948 
2949 PERL_CALLCONV SV *
2950 Perl_newRV(pTHX_ SV * const sv)
2951         __attribute__warn_unused_result__;
2952 #define PERL_ARGS_ASSERT_NEWRV                  \
2953         assert(sv)
2954 
2955 PERL_CALLCONV OP *
2956 Perl_newSLICEOP(pTHX_ I32 flags, OP *subscript, OP *listop)
2957         __attribute__warn_unused_result__;
2958 #define PERL_ARGS_ASSERT_NEWSLICEOP
2959 
2960 PERL_CALLCONV OP *
2961 Perl_newSTATEOP(pTHX_ I32 flags, char *label, OP *o)
2962         __attribute__warn_unused_result__;
2963 #define PERL_ARGS_ASSERT_NEWSTATEOP
2964 
2965 PERL_CALLCONV CV *
2966 Perl_newSTUB(pTHX_ GV *gv, bool fake)
2967         __attribute__visibility__("hidden");
2968 #define PERL_ARGS_ASSERT_NEWSTUB                \
2969         assert(gv)
2970 
2971 PERL_CALLCONV SV *
2972 Perl_newSV(pTHX_ const STRLEN len)
2973         __attribute__warn_unused_result__;
2974 #define PERL_ARGS_ASSERT_NEWSV
2975 
2976 PERL_CALLCONV OP *
2977 Perl_newSVOP(pTHX_ I32 type, I32 flags, SV *sv)
2978         __attribute__warn_unused_result__;
2979 #define PERL_ARGS_ASSERT_NEWSVOP                \
2980         assert(sv)
2981 
2982 PERL_CALLCONV OP *
2983 Perl_newSVREF(pTHX_ OP *o)
2984         __attribute__warn_unused_result__;
2985 #define PERL_ARGS_ASSERT_NEWSVREF               \
2986         assert(o)
2987 
2988 PERL_CALLCONV SV *
2989 Perl_newSV_false(pTHX)
2990         __attribute__warn_unused_result__;
2991 #define PERL_ARGS_ASSERT_NEWSV_FALSE
2992 
2993 PERL_CALLCONV SV *
2994 Perl_newSV_true(pTHX)
2995         __attribute__warn_unused_result__;
2996 #define PERL_ARGS_ASSERT_NEWSV_TRUE
2997 
2998 PERL_CALLCONV SV *
2999 Perl_newSVavdefelem(pTHX_ AV *av, SSize_t ix, bool extendible)
3000         __attribute__warn_unused_result__
3001         __attribute__visibility__("hidden");
3002 #define PERL_ARGS_ASSERT_NEWSVAVDEFELEM         \
3003         assert(av)
3004 
3005 PERL_CALLCONV SV *
3006 Perl_newSVbool(pTHX_ const bool bool_val)
3007         __attribute__warn_unused_result__;
3008 #define PERL_ARGS_ASSERT_NEWSVBOOL
3009 
3010 PERL_CALLCONV SV *
3011 Perl_newSVhek(pTHX_ const HEK * const hek)
3012         __attribute__warn_unused_result__;
3013 #define PERL_ARGS_ASSERT_NEWSVHEK
3014 
3015 PERL_CALLCONV SV *
3016 Perl_newSVhek_mortal(pTHX_ const HEK * const hek)
3017         __attribute__warn_unused_result__;
3018 #define PERL_ARGS_ASSERT_NEWSVHEK_MORTAL
3019 
3020 PERL_CALLCONV SV *
3021 Perl_newSViv(pTHX_ const IV i)
3022         __attribute__warn_unused_result__;
3023 #define PERL_ARGS_ASSERT_NEWSVIV
3024 
3025 PERL_CALLCONV SV *
3026 Perl_newSVnv(pTHX_ const NV n)
3027         __attribute__warn_unused_result__;
3028 #define PERL_ARGS_ASSERT_NEWSVNV
3029 
3030 PERL_CALLCONV SV *
3031 Perl_newSVpv(pTHX_ const char * const s, const STRLEN len)
3032         __attribute__warn_unused_result__;
3033 #define PERL_ARGS_ASSERT_NEWSVPV
3034 
3035 PERL_CALLCONV SV *
3036 Perl_newSVpv_share(pTHX_ const char *s, U32 hash)
3037         __attribute__warn_unused_result__;
3038 #define PERL_ARGS_ASSERT_NEWSVPV_SHARE
3039 
3040 PERL_CALLCONV SV *
3041 Perl_newSVpvf(pTHX_ const char * const pat, ...)
3042         __attribute__warn_unused_result__
3043         __attribute__format__(__printf__,pTHX_1,pTHX_2);
3044 #define PERL_ARGS_ASSERT_NEWSVPVF               \
3045         assert(pat)
3046 
3047 PERL_CALLCONV SV *
3048 Perl_newSVpvn(pTHX_ const char * const buffer, const STRLEN len)
3049         __attribute__warn_unused_result__;
3050 #define PERL_ARGS_ASSERT_NEWSVPVN
3051 
3052 PERL_CALLCONV SV *
3053 Perl_newSVpvn_flags(pTHX_ const char * const s, const STRLEN len, const U32 flags)
3054         __attribute__warn_unused_result__;
3055 #define PERL_ARGS_ASSERT_NEWSVPVN_FLAGS
3056 
3057 PERL_CALLCONV SV *
3058 Perl_newSVpvn_share(pTHX_ const char *s, I32 len, U32 hash)
3059         __attribute__warn_unused_result__;
3060 #define PERL_ARGS_ASSERT_NEWSVPVN_SHARE
3061 
3062 PERL_CALLCONV SV *
3063 Perl_newSVrv(pTHX_ SV * const rv, const char * const classname);
3064 #define PERL_ARGS_ASSERT_NEWSVRV                \
3065         assert(rv)
3066 
3067 PERL_CALLCONV SV *
3068 Perl_newSVsv_flags(pTHX_ SV * const old, I32 flags)
3069         __attribute__warn_unused_result__;
3070 #define PERL_ARGS_ASSERT_NEWSVSV_FLAGS
3071 
3072 /* PERL_CALLCONV SV *
3073 newSVsv_nomg(pTHX_ SV * const old)
3074         __attribute__warn_unused_result__; */
3075 
3076 PERL_CALLCONV SV *
3077 Perl_newSVuv(pTHX_ const UV u)
3078         __attribute__warn_unused_result__;
3079 #define PERL_ARGS_ASSERT_NEWSVUV
3080 
3081 PERL_CALLCONV OP *
3082 Perl_newTRYCATCHOP(pTHX_ I32 flags, OP *tryblock, OP *catchvar, OP *catchblock)
3083         __attribute__warn_unused_result__;
3084 #define PERL_ARGS_ASSERT_NEWTRYCATCHOP          \
3085         assert(tryblock); assert(catchvar); assert(catchblock)
3086 
3087 PERL_CALLCONV OP *
3088 Perl_newUNOP(pTHX_ I32 type, I32 flags, OP *first)
3089         __attribute__warn_unused_result__;
3090 #define PERL_ARGS_ASSERT_NEWUNOP
3091 
3092 PERL_CALLCONV OP *
3093 Perl_newUNOP_AUX(pTHX_ I32 type, I32 flags, OP *first, UNOP_AUX_item *aux)
3094         __attribute__warn_unused_result__;
3095 #define PERL_ARGS_ASSERT_NEWUNOP_AUX
3096 
3097 PERL_CALLCONV OP *
3098 Perl_newWHENOP(pTHX_ OP *cond, OP *block)
3099         __attribute__warn_unused_result__;
3100 #define PERL_ARGS_ASSERT_NEWWHENOP              \
3101         assert(block)
3102 
3103 PERL_CALLCONV OP *
3104 Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP *loop, OP *expr, OP *block, OP *cont, I32 has_my)
3105         __attribute__warn_unused_result__;
3106 #define PERL_ARGS_ASSERT_NEWWHILEOP
3107 
3108 PERL_CALLCONV CV *
3109 Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename);
3110 #define PERL_ARGS_ASSERT_NEWXS                  \
3111         assert(subaddr); assert(filename)
3112 
3113 PERL_CALLCONV CV *
3114 Perl_newXS_deffile(pTHX_ const char *name, XSUBADDR_t subaddr);
3115 #define PERL_ARGS_ASSERT_NEWXS_DEFFILE          \
3116         assert(name); assert(subaddr)
3117 
3118 PERL_CALLCONV CV *
3119 Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr, const char * const filename, const char * const proto, U32 flags);
3120 #define PERL_ARGS_ASSERT_NEWXS_FLAGS            \
3121         assert(subaddr); assert(filename)
3122 
3123 PERL_CALLCONV CV *
3124 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)
3125         __attribute__visibility__("hidden");
3126 #define PERL_ARGS_ASSERT_NEWXS_LEN_FLAGS        \
3127         assert(subaddr)
3128 
3129 PERL_CALLCONV PERL_SI *
3130 Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems)
3131         __attribute__warn_unused_result__;
3132 #define PERL_ARGS_ASSERT_NEW_STACKINFO
3133 
3134 PERL_CALLCONV PERL_SI *
3135 Perl_new_stackinfo_flags(pTHX_ I32 stitems, I32 cxitems, UV flags)
3136         __attribute__warn_unused_result__;
3137 #define PERL_ARGS_ASSERT_NEW_STACKINFO_FLAGS
3138 
3139 PERL_CALLCONV SV *
3140 Perl_new_version(pTHX_ SV *ver);
3141 #define PERL_ARGS_ASSERT_NEW_VERSION            \
3142         assert(ver)
3143 
3144 PERL_CALLCONV char *
3145 Perl_new_warnings_bitfield(pTHX_ char *buffer, const char * const bits, STRLEN size)
3146         __attribute__warn_unused_result__;
3147 #define PERL_ARGS_ASSERT_NEW_WARNINGS_BITFIELD  \
3148         assert(bits)
3149 
3150 PERL_CALLCONV PerlIO *
3151 Perl_nextargv(pTHX_ GV *gv, bool nomagicopen)
3152         __attribute__visibility__("hidden");
3153 #define PERL_ARGS_ASSERT_NEXTARGV               \
3154         assert(gv)
3155 
3156 PERL_CALLCONV char *
3157 Perl_ninstr(const char *big, const char *bigend, const char *little, const char *lend)
3158         __attribute__warn_unused_result__
3159         __attribute__pure__;
3160 #define PERL_ARGS_ASSERT_NINSTR                 \
3161         assert(big); assert(bigend); assert(little); assert(lend)
3162 
3163 PERL_CALLCONV void
3164 Perl_no_bareword_filehandle(pTHX_ const char *fhname)
3165         __attribute__visibility__("hidden");
3166 #define PERL_ARGS_ASSERT_NO_BAREWORD_FILEHANDLE \
3167         assert(fhname)
3168 
3169 PERL_CALLCONV_NO_RET void
3170 Perl_noperl_die(const char *pat, ...)
3171         __attribute__noreturn__
3172         __attribute__format__(__printf__,1,2);
3173 #define PERL_ARGS_ASSERT_NOPERL_DIE             \
3174         assert(pat)
3175 
3176 PERL_CALLCONV int
3177 Perl_nothreadhook(pTHX);
3178 #define PERL_ARGS_ASSERT_NOTHREADHOOK
3179 
3180 PERL_CALLCONV void
3181 Perl_notify_parser_that_changed_to_utf8(pTHX)
3182         __attribute__visibility__("hidden");
3183 #define PERL_ARGS_ASSERT_NOTIFY_PARSER_THAT_CHANGED_TO_UTF8
3184 
3185 PERL_CALLCONV OP *
3186 Perl_oopsAV(pTHX_ OP *o)
3187         __attribute__warn_unused_result__
3188         __attribute__visibility__("hidden");
3189 #define PERL_ARGS_ASSERT_OOPSAV                 \
3190         assert(o)
3191 
3192 PERL_CALLCONV OP *
3193 Perl_oopsHV(pTHX_ OP *o)
3194         __attribute__warn_unused_result__
3195         __attribute__visibility__("hidden");
3196 #define PERL_ARGS_ASSERT_OOPSHV                 \
3197         assert(o)
3198 
3199 PERL_CALLCONV OP *
3200 Perl_op_append_elem(pTHX_ I32 optype, OP *first, OP *last);
3201 #define PERL_ARGS_ASSERT_OP_APPEND_ELEM
3202 
3203 PERL_CALLCONV OP *
3204 Perl_op_append_list(pTHX_ I32 optype, OP *first, OP *last);
3205 #define PERL_ARGS_ASSERT_OP_APPEND_LIST
3206 
3207 PERL_CALLCONV OPclass
3208 Perl_op_class(pTHX_ const OP *o);
3209 #define PERL_ARGS_ASSERT_OP_CLASS
3210 
3211 PERL_CALLCONV void
3212 Perl_op_clear(pTHX_ OP *o);
3213 #define PERL_ARGS_ASSERT_OP_CLEAR               \
3214         assert(o)
3215 
3216 PERL_CALLCONV OP *
3217 Perl_op_contextualize(pTHX_ OP *o, I32 context);
3218 #define PERL_ARGS_ASSERT_OP_CONTEXTUALIZE       \
3219         assert(o)
3220 
3221 PERL_CALLCONV OP *
3222 Perl_op_convert_list(pTHX_ I32 optype, I32 flags, OP *o)
3223         __attribute__warn_unused_result__;
3224 #define PERL_ARGS_ASSERT_OP_CONVERT_LIST
3225 
3226 PERL_CALLCONV void
3227 Perl_op_dump(pTHX_ const OP *o);
3228 #define PERL_ARGS_ASSERT_OP_DUMP                \
3229         assert(o)
3230 
3231 PERL_CALLCONV OP *
3232 Perl_op_force_list(pTHX_ OP *o);
3233 #define PERL_ARGS_ASSERT_OP_FORCE_LIST
3234 
3235 PERL_CALLCONV void
3236 Perl_op_free(pTHX_ OP *arg);
3237 #define PERL_ARGS_ASSERT_OP_FREE
3238 
3239 PERL_CALLCONV OP *
3240 Perl_op_linklist(pTHX_ OP *o);
3241 #define PERL_ARGS_ASSERT_OP_LINKLIST            \
3242         assert(o)
3243 
3244 /* PERL_CALLCONV OP *
3245 op_lvalue(pTHX_ OP *o, I32 type); */
3246 
3247 PERL_CALLCONV OP *
3248 Perl_op_lvalue_flags(pTHX_ OP *o, I32 type, U32 flags);
3249 #define PERL_ARGS_ASSERT_OP_LVALUE_FLAGS
3250 
3251 PERL_CALLCONV void
3252 Perl_op_null(pTHX_ OP *o);
3253 #define PERL_ARGS_ASSERT_OP_NULL                \
3254         assert(o)
3255 
3256 PERL_CALLCONV OP *
3257 Perl_op_parent(OP *o);
3258 #define PERL_ARGS_ASSERT_OP_PARENT              \
3259         assert(o)
3260 
3261 PERL_CALLCONV OP *
3262 Perl_op_prepend_elem(pTHX_ I32 optype, OP *first, OP *last);
3263 #define PERL_ARGS_ASSERT_OP_PREPEND_ELEM
3264 
3265 PERL_CALLCONV void
3266 Perl_op_refcnt_lock(pTHX);
3267 #define PERL_ARGS_ASSERT_OP_REFCNT_LOCK
3268 
3269 PERL_CALLCONV void
3270 Perl_op_refcnt_unlock(pTHX);
3271 #define PERL_ARGS_ASSERT_OP_REFCNT_UNLOCK
3272 
3273 PERL_CALLCONV OP *
3274 Perl_op_scope(pTHX_ OP *o);
3275 #define PERL_ARGS_ASSERT_OP_SCOPE
3276 
3277 PERL_CALLCONV OP *
3278 Perl_op_sibling_splice(OP *parent, OP *start, int del_count, OP *insert);
3279 #define PERL_ARGS_ASSERT_OP_SIBLING_SPLICE
3280 
3281 PERL_CALLCONV OP *
3282 Perl_op_unscope(pTHX_ OP *o)
3283         __attribute__visibility__("hidden");
3284 #define PERL_ARGS_ASSERT_OP_UNSCOPE
3285 
3286 PERL_CALLCONV OP *
3287 Perl_op_wrap_finally(pTHX_ OP *block, OP *finally)
3288         __attribute__warn_unused_result__;
3289 #define PERL_ARGS_ASSERT_OP_WRAP_FINALLY        \
3290         assert(block); assert(finally)
3291 
3292 PERL_CALLCONV void
3293 Perl_package(pTHX_ OP *o)
3294         __attribute__visibility__("hidden");
3295 #define PERL_ARGS_ASSERT_PACKAGE                \
3296         assert(o)
3297 
3298 PERL_CALLCONV void
3299 Perl_package_version(pTHX_ OP *v)
3300         __attribute__visibility__("hidden");
3301 #define PERL_ARGS_ASSERT_PACKAGE_VERSION        \
3302         assert(v)
3303 
3304 PERL_CALLCONV void
3305 Perl_packlist(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist);
3306 #define PERL_ARGS_ASSERT_PACKLIST               \
3307         assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist)
3308 
3309 PERL_CALLCONV PADOFFSET
3310 Perl_pad_add_anon(pTHX_ CV *func, I32 optype);
3311 #define PERL_ARGS_ASSERT_PAD_ADD_ANON           \
3312         assert(func)
3313 
3314 PERL_CALLCONV PADOFFSET
3315 Perl_pad_add_name_pv(pTHX_ const char *name, const U32 flags, HV *typestash, HV *ourstash);
3316 #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PV        \
3317         assert(name)
3318 
3319 PERL_CALLCONV PADOFFSET
3320 Perl_pad_add_name_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags, HV *typestash, HV *ourstash);
3321 #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PVN       \
3322         assert(namepv)
3323 
3324 PERL_CALLCONV PADOFFSET
3325 Perl_pad_add_name_sv(pTHX_ SV *name, U32 flags, HV *typestash, HV *ourstash);
3326 #define PERL_ARGS_ASSERT_PAD_ADD_NAME_SV        \
3327         assert(name)
3328 
3329 PERL_CALLCONV void
3330 Perl_pad_add_weakref(pTHX_ CV *func)
3331         __attribute__visibility__("hidden");
3332 #define PERL_ARGS_ASSERT_PAD_ADD_WEAKREF        \
3333         assert(func)
3334 
3335 PERL_CALLCONV PADOFFSET
3336 Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype);
3337 #define PERL_ARGS_ASSERT_PAD_ALLOC
3338 
3339 PERL_CALLCONV void
3340 Perl_pad_block_start(pTHX_ int full)
3341         __attribute__visibility__("hidden");
3342 #define PERL_ARGS_ASSERT_PAD_BLOCK_START
3343 
3344 PERL_CALLCONV PADOFFSET
3345 Perl_pad_findmy_pv(pTHX_ const char *name, U32 flags);
3346 #define PERL_ARGS_ASSERT_PAD_FINDMY_PV          \
3347         assert(name)
3348 
3349 PERL_CALLCONV PADOFFSET
3350 Perl_pad_findmy_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags);
3351 #define PERL_ARGS_ASSERT_PAD_FINDMY_PVN         \
3352         assert(namepv)
3353 
3354 PERL_CALLCONV PADOFFSET
3355 Perl_pad_findmy_sv(pTHX_ SV *name, U32 flags);
3356 #define PERL_ARGS_ASSERT_PAD_FINDMY_SV          \
3357         assert(name)
3358 
3359 PERL_CALLCONV void
3360 Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv)
3361         __attribute__visibility__("hidden");
3362 #define PERL_ARGS_ASSERT_PAD_FIXUP_INNER_ANONS  \
3363         assert(padlist); assert(old_cv); assert(new_cv)
3364 
3365 PERL_CALLCONV void
3366 Perl_pad_free(pTHX_ PADOFFSET po)
3367         __attribute__visibility__("hidden");
3368 #define PERL_ARGS_ASSERT_PAD_FREE
3369 
3370 PERL_CALLCONV OP *
3371 Perl_pad_leavemy(pTHX)
3372         __attribute__visibility__("hidden");
3373 #define PERL_ARGS_ASSERT_PAD_LEAVEMY
3374 
3375 PERL_CALLCONV PADLIST *
3376 Perl_pad_new(pTHX_ int flags)
3377         __attribute__warn_unused_result__;
3378 #define PERL_ARGS_ASSERT_PAD_NEW
3379 
3380 PERL_CALLCONV void
3381 Perl_pad_push(pTHX_ PADLIST *padlist, int depth);
3382 #define PERL_ARGS_ASSERT_PAD_PUSH               \
3383         assert(padlist)
3384 
3385 PERL_CALLCONV void
3386 Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust)
3387         __attribute__visibility__("hidden");
3388 #define PERL_ARGS_ASSERT_PAD_SWIPE
3389 
3390 PERL_CALLCONV void
3391 Perl_pad_tidy(pTHX_ padtidy_type type);
3392 #define PERL_ARGS_ASSERT_PAD_TIDY
3393 
3394 PERL_CALLCONV PAD **
3395 Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val)
3396         __attribute__visibility__("hidden");
3397 #define PERL_ARGS_ASSERT_PADLIST_STORE          \
3398         assert(padlist)
3399 
3400 PERL_CALLCONV void
3401 Perl_padname_free(pTHX_ PADNAME *pn);
3402 #define PERL_ARGS_ASSERT_PADNAME_FREE           \
3403         assert(pn)
3404 
3405 PERL_CALLCONV PADNAME *
3406 Perl_padnamelist_fetch(PADNAMELIST *pnl, SSize_t key)
3407         __attribute__warn_unused_result__;
3408 #define PERL_ARGS_ASSERT_PADNAMELIST_FETCH      \
3409         assert(pnl)
3410 
3411 PERL_CALLCONV void
3412 Perl_padnamelist_free(pTHX_ PADNAMELIST *pnl);
3413 #define PERL_ARGS_ASSERT_PADNAMELIST_FREE       \
3414         assert(pnl)
3415 
3416 PERL_CALLCONV PADNAME **
3417 Perl_padnamelist_store(pTHX_ PADNAMELIST *pnl, SSize_t key, PADNAME *val);
3418 #define PERL_ARGS_ASSERT_PADNAMELIST_STORE      \
3419         assert(pnl)
3420 
3421 PERL_CALLCONV OP *
3422 Perl_parse_arithexpr(pTHX_ U32 flags);
3423 #define PERL_ARGS_ASSERT_PARSE_ARITHEXPR
3424 
3425 PERL_CALLCONV OP *
3426 Perl_parse_barestmt(pTHX_ U32 flags);
3427 #define PERL_ARGS_ASSERT_PARSE_BARESTMT
3428 
3429 PERL_CALLCONV OP *
3430 Perl_parse_block(pTHX_ U32 flags);
3431 #define PERL_ARGS_ASSERT_PARSE_BLOCK
3432 
3433 PERL_CALLCONV OP *
3434 Perl_parse_fullexpr(pTHX_ U32 flags);
3435 #define PERL_ARGS_ASSERT_PARSE_FULLEXPR
3436 
3437 PERL_CALLCONV OP *
3438 Perl_parse_fullstmt(pTHX_ U32 flags);
3439 #define PERL_ARGS_ASSERT_PARSE_FULLSTMT
3440 
3441 PERL_CALLCONV SV *
3442 Perl_parse_label(pTHX_ U32 flags);
3443 #define PERL_ARGS_ASSERT_PARSE_LABEL
3444 
3445 PERL_CALLCONV OP *
3446 Perl_parse_listexpr(pTHX_ U32 flags);
3447 #define PERL_ARGS_ASSERT_PARSE_LISTEXPR
3448 
3449 PERL_CALLCONV OP *
3450 Perl_parse_stmtseq(pTHX_ U32 flags);
3451 #define PERL_ARGS_ASSERT_PARSE_STMTSEQ
3452 
3453 PERL_CALLCONV OP *
3454 Perl_parse_subsignature(pTHX_ U32 flags);
3455 #define PERL_ARGS_ASSERT_PARSE_SUBSIGNATURE
3456 
3457 PERL_CALLCONV OP *
3458 Perl_parse_termexpr(pTHX_ U32 flags);
3459 #define PERL_ARGS_ASSERT_PARSE_TERMEXPR
3460 
3461 PERL_CALLCONV U32
3462 Perl_parse_unicode_opts(pTHX_ const char **popt)
3463         __attribute__visibility__("hidden");
3464 #define PERL_ARGS_ASSERT_PARSE_UNICODE_OPTS     \
3465         assert(popt)
3466 
3467 PERL_CALLCONV void
3468 Perl_parser_free(pTHX_ const yy_parser *parser)
3469         __attribute__visibility__("hidden");
3470 #define PERL_ARGS_ASSERT_PARSER_FREE            \
3471         assert(parser)
3472 
3473 PERL_CALLCONV void
3474 Perl_peep(pTHX_ OP *o)
3475         __attribute__visibility__("hidden");
3476 #define PERL_ARGS_ASSERT_PEEP
3477 
3478 PERL_CALLCONV PerlInterpreter *
3479 perl_alloc(void);
3480 #define PERL_ARGS_ASSERT_PERL_ALLOC
3481 
3482 PERL_CALLCONV void
3483 perl_construct(PerlInterpreter *my_perl);
3484 #define PERL_ARGS_ASSERT_PERL_CONSTRUCT         \
3485         assert(my_perl)
3486 
3487 PERL_CALLCONV int
3488 perl_destruct(PerlInterpreter *my_perl);
3489 #define PERL_ARGS_ASSERT_PERL_DESTRUCT          \
3490         assert(my_perl)
3491 
3492 PERL_CALLCONV void
3493 perl_free(PerlInterpreter *my_perl);
3494 #define PERL_ARGS_ASSERT_PERL_FREE              \
3495         assert(my_perl)
3496 
3497 PERL_CALLCONV int
3498 perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char **argv, char **env);
3499 #define PERL_ARGS_ASSERT_PERL_PARSE             \
3500         assert(my_perl)
3501 
3502 PERL_CALLCONV int
3503 perl_run(PerlInterpreter *my_perl);
3504 #define PERL_ARGS_ASSERT_PERL_RUN               \
3505         assert(my_perl)
3506 
3507 PERL_CALLCONV Signal_t
3508 Perl_perly_sighandler(int sig, Siginfo_t *info, void *uap, bool safe);
3509 #define PERL_ARGS_ASSERT_PERLY_SIGHANDLER
3510 
3511 /* PERL_CALLCONV const char * const
3512 phase_name(pTHX_ enum perl_phase); */
3513 
3514 PERL_CALLCONV void
3515 Perl_pmop_dump(pTHX_ PMOP *pm);
3516 #define PERL_ARGS_ASSERT_PMOP_DUMP
3517 
3518 PERL_CALLCONV OP *
3519 Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl, UV flags, I32 floor)
3520         __attribute__visibility__("hidden");
3521 #define PERL_ARGS_ASSERT_PMRUNTIME              \
3522         assert(o); assert(expr)
3523 
3524 PERL_CALLCONV void
3525 Perl_pop_scope(pTHX);
3526 #define PERL_ARGS_ASSERT_POP_SCOPE
3527 
3528 PERL_CALLCONV void
3529 Perl_populate_isa(pTHX_ const char *name, STRLEN len, ...)
3530         __attribute__visibility__("hidden");
3531 #define PERL_ARGS_ASSERT_POPULATE_ISA           \
3532         assert(name)
3533 
3534 PERL_CALLCONV REGEXP *
3535 Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags);
3536 #define PERL_ARGS_ASSERT_PREGCOMP               \
3537         assert(pattern)
3538 
3539 PERL_CALLCONV I32
3540 Perl_pregexec(pTHX_ REGEXP * const prog, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *screamer, U32 nosave);
3541 #define PERL_ARGS_ASSERT_PREGEXEC               \
3542         assert(prog); assert(stringarg); assert(strend); assert(strbeg); \
3543         assert(screamer)
3544 
3545 PERL_CALLCONV void
3546 Perl_pregfree(pTHX_ REGEXP *r);
3547 #define PERL_ARGS_ASSERT_PREGFREE
3548 
3549 PERL_CALLCONV void
3550 Perl_pregfree2(pTHX_ REGEXP *rx);
3551 #define PERL_ARGS_ASSERT_PREGFREE2              \
3552         assert(rx)
3553 
3554 PERL_CALLCONV const char *
3555 Perl_prescan_version(pTHX_ const char *s, bool strict, const char **errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha);
3556 #define PERL_ARGS_ASSERT_PRESCAN_VERSION        \
3557         assert(s)
3558 
3559 PERL_CALLCONV void *
3560 Perl_ptr_table_fetch(pTHX_ PTR_TBL_t * const tbl, const void * const sv)
3561         __attribute__warn_unused_result__;
3562 #define PERL_ARGS_ASSERT_PTR_TABLE_FETCH        \
3563         assert(tbl)
3564 
3565 PERL_CALLCONV void
3566 Perl_ptr_table_free(pTHX_ PTR_TBL_t * const tbl);
3567 #define PERL_ARGS_ASSERT_PTR_TABLE_FREE
3568 
3569 PERL_CALLCONV PTR_TBL_t *
3570 Perl_ptr_table_new(pTHX)
3571         __attribute__warn_unused_result__;
3572 #define PERL_ARGS_ASSERT_PTR_TABLE_NEW
3573 
3574 PERL_CALLCONV void
3575 Perl_ptr_table_split(pTHX_ PTR_TBL_t * const tbl);
3576 #define PERL_ARGS_ASSERT_PTR_TABLE_SPLIT        \
3577         assert(tbl)
3578 
3579 PERL_CALLCONV void
3580 Perl_ptr_table_store(pTHX_ PTR_TBL_t * const tbl, const void * const oldsv, void * const newsv);
3581 #define PERL_ARGS_ASSERT_PTR_TABLE_STORE        \
3582         assert(tbl); assert(newsv)
3583 
3584 PERL_CALLCONV void
3585 Perl_push_scope(pTHX);
3586 #define PERL_ARGS_ASSERT_PUSH_SCOPE
3587 
3588 PERL_CALLCONV char *
3589 Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim);
3590 #define PERL_ARGS_ASSERT_PV_DISPLAY             \
3591         assert(dsv); assert(pv)
3592 
3593 PERL_CALLCONV char *
3594 Perl_pv_escape(pTHX_ SV *dsv, char const * const str, const STRLEN count, STRLEN max, STRLEN * const escaped, U32 flags);
3595 #define PERL_ARGS_ASSERT_PV_ESCAPE              \
3596         assert(str)
3597 
3598 PERL_CALLCONV char *
3599 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);
3600 #define PERL_ARGS_ASSERT_PV_PRETTY              \
3601         assert(dsv); assert(str)
3602 
3603 PERL_CALLCONV char *
3604 Perl_pv_uni_display(pTHX_ SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV flags);
3605 #define PERL_ARGS_ASSERT_PV_UNI_DISPLAY         \
3606         assert(dsv); assert(spv)
3607 
3608 PERL_CALLCONV void
3609 Perl_qerror(pTHX_ SV *err);
3610 #define PERL_ARGS_ASSERT_QERROR
3611 
3612 PERL_CALLCONV char *
3613 Perl_rcpv_copy(pTHX_ char * const pv);
3614 #define PERL_ARGS_ASSERT_RCPV_COPY
3615 
3616 PERL_CALLCONV char *
3617 Perl_rcpv_free(pTHX_ char * const pv);
3618 #define PERL_ARGS_ASSERT_RCPV_FREE
3619 
3620 PERL_CALLCONV char *
3621 Perl_rcpv_new(pTHX_ const char * const pv, STRLEN len, U32 flags)
3622         __attribute__malloc__
3623         __attribute__warn_unused_result__;
3624 #define PERL_ARGS_ASSERT_RCPV_NEW
3625 
3626 PERL_CALLCONV REGEXP *
3627 Perl_re_compile(pTHX_ SV * const pattern, U32 orig_rx_flags);
3628 #define PERL_ARGS_ASSERT_RE_COMPILE             \
3629         assert(pattern)
3630 
3631 PERL_CALLCONV char *
3632 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);
3633 #define PERL_ARGS_ASSERT_RE_INTUIT_START        \
3634         assert(rx); assert(strbeg); assert(strpos); assert(strend)
3635 
3636 PERL_CALLCONV SV *
3637 Perl_re_intuit_string(pTHX_ REGEXP  * const r);
3638 #define PERL_ARGS_ASSERT_RE_INTUIT_STRING       \
3639         assert(r)
3640 
3641 PERL_CALLCONV REGEXP *
3642 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);
3643 #define PERL_ARGS_ASSERT_RE_OP_COMPILE          \
3644         assert(eng)
3645 
3646 PERL_CALLCONV Malloc_t
3647 Perl_realloc(Malloc_t where, MEM_SIZE nbytes)
3648         __attribute__warn_unused_result__;
3649 #define PERL_ARGS_ASSERT_REALLOC
3650 
3651 PERL_CALLCONV void
3652 Perl_reentrant_free(pTHX);
3653 #define PERL_ARGS_ASSERT_REENTRANT_FREE
3654 
3655 PERL_CALLCONV void
3656 Perl_reentrant_init(pTHX);
3657 #define PERL_ARGS_ASSERT_REENTRANT_INIT
3658 
3659 PERL_CALLCONV void *
3660 Perl_reentrant_retry(const char *f, ...);
3661 #define PERL_ARGS_ASSERT_REENTRANT_RETRY        \
3662         assert(f)
3663 
3664 PERL_CALLCONV void
3665 Perl_reentrant_size(pTHX);
3666 #define PERL_ARGS_ASSERT_REENTRANT_SIZE
3667 
3668 PERL_CALLCONV HV *
3669 Perl_refcounted_he_chain_2hv(pTHX_ const struct refcounted_he *c, U32 flags);
3670 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_CHAIN_2HV
3671 
3672 PERL_CALLCONV SV *
3673 Perl_refcounted_he_fetch_pv(pTHX_ const struct refcounted_he *chain, const char *key, U32 hash, U32 flags);
3674 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PV \
3675         assert(key)
3676 
3677 PERL_CALLCONV SV *
3678 Perl_refcounted_he_fetch_pvn(pTHX_ const struct refcounted_he *chain, const char *keypv, STRLEN keylen, U32 hash, U32 flags);
3679 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PVN \
3680         assert(keypv)
3681 
3682 PERL_CALLCONV SV *
3683 Perl_refcounted_he_fetch_sv(pTHX_ const struct refcounted_he *chain, SV *key, U32 hash, U32 flags);
3684 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_SV \
3685         assert(key)
3686 
3687 PERL_CALLCONV void
3688 Perl_refcounted_he_free(pTHX_ struct refcounted_he *he);
3689 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FREE
3690 
3691 PERL_CALLCONV struct refcounted_he *
3692 Perl_refcounted_he_inc(pTHX_ struct refcounted_he *he);
3693 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_INC
3694 
3695 PERL_CALLCONV struct refcounted_he *
3696 Perl_refcounted_he_new_pv(pTHX_ struct refcounted_he *parent, const char *key, U32 hash, SV *value, U32 flags);
3697 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PV   \
3698         assert(key)
3699 
3700 PERL_CALLCONV struct refcounted_he *
3701 Perl_refcounted_he_new_pvn(pTHX_ struct refcounted_he *parent, const char *keypv, STRLEN keylen, U32 hash, SV *value, U32 flags);
3702 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PVN  \
3703         assert(keypv)
3704 
3705 PERL_CALLCONV struct refcounted_he *
3706 Perl_refcounted_he_new_sv(pTHX_ struct refcounted_he *parent, SV *key, U32 hash, SV *value, U32 flags);
3707 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_SV   \
3708         assert(key)
3709 
3710 PERL_CALLCONV SV *
3711 Perl_reg_named_buff(pTHX_ REGEXP * const rx, SV * const key, SV * const value, const U32 flags);
3712 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF         \
3713         assert(rx)
3714 
3715 PERL_CALLCONV SV *
3716 Perl_reg_named_buff_all(pTHX_ REGEXP * const rx, const U32 flags);
3717 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ALL     \
3718         assert(rx)
3719 
3720 PERL_CALLCONV bool
3721 Perl_reg_named_buff_exists(pTHX_ REGEXP * const rx, SV * const key, const U32 flags);
3722 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_EXISTS  \
3723         assert(rx); assert(key)
3724 
3725 PERL_CALLCONV SV *
3726 Perl_reg_named_buff_fetch(pTHX_ REGEXP * const rx, SV * const namesv, const U32 flags);
3727 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FETCH   \
3728         assert(rx); assert(namesv)
3729 
3730 PERL_CALLCONV SV *
3731 Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const rx, const U32 flags);
3732 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FIRSTKEY \
3733         assert(rx)
3734 
3735 PERL_CALLCONV SV *
3736 Perl_reg_named_buff_iter(pTHX_ REGEXP * const rx, const SV * const lastkey, const U32 flags);
3737 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ITER    \
3738         assert(rx)
3739 
3740 PERL_CALLCONV SV *
3741 Perl_reg_named_buff_nextkey(pTHX_ REGEXP * const rx, const U32 flags);
3742 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_NEXTKEY \
3743         assert(rx)
3744 
3745 PERL_CALLCONV SV *
3746 Perl_reg_named_buff_scalar(pTHX_ REGEXP * const rx, const U32 flags);
3747 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_SCALAR  \
3748         assert(rx)
3749 
3750 PERL_CALLCONV void
3751 Perl_reg_numbered_buff_fetch(pTHX_ REGEXP * const re, const I32 paren, SV * const sv);
3752 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_FETCH \
3753         assert(re)
3754 
3755 PERL_CALLCONV void
3756 Perl_reg_numbered_buff_fetch_flags(pTHX_ REGEXP * const re, const I32 paren, SV * const sv, U32 flags);
3757 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_FETCH_FLAGS \
3758         assert(re)
3759 
3760 PERL_CALLCONV I32
3761 Perl_reg_numbered_buff_length(pTHX_ REGEXP * const rx, const SV * const sv, const I32 paren);
3762 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_LENGTH \
3763         assert(rx); assert(sv)
3764 
3765 PERL_CALLCONV void
3766 Perl_reg_numbered_buff_store(pTHX_ REGEXP * const rx, const I32 paren, SV const * const value);
3767 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_STORE \
3768         assert(rx)
3769 
3770 PERL_CALLCONV SV *
3771 Perl_reg_qr_package(pTHX_ REGEXP * const rx);
3772 #define PERL_ARGS_ASSERT_REG_QR_PACKAGE         \
3773         assert(rx)
3774 
3775 PERL_CALLCONV REGEXP *
3776 Perl_reg_temp_copy(pTHX_ REGEXP *dsv, REGEXP *ssv);
3777 #define PERL_ARGS_ASSERT_REG_TEMP_COPY          \
3778         assert(ssv)
3779 
3780 PERL_CALLCONV void
3781 Perl_regdump(pTHX_ const regexp *r);
3782 #define PERL_ARGS_ASSERT_REGDUMP                \
3783         assert(r)
3784 
3785 PERL_CALLCONV I32
3786 Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *sv, void *data, U32 flags);
3787 #define PERL_ARGS_ASSERT_REGEXEC_FLAGS          \
3788         assert(rx); assert(stringarg); assert(strend); assert(strbeg); assert(sv)
3789 
3790 PERL_CALLCONV void
3791 Perl_regfree_internal(pTHX_ REGEXP * const rx);
3792 #define PERL_ARGS_ASSERT_REGFREE_INTERNAL       \
3793         assert(rx)
3794 
3795 PERL_CALLCONV void
3796 Perl_reginitcolors(pTHX);
3797 #define PERL_ARGS_ASSERT_REGINITCOLORS
3798 
3799 PERL_CALLCONV void
3800 Perl_repeatcpy(char *to, const char *from, SSize_t len, IV count);
3801 #define PERL_ARGS_ASSERT_REPEATCPY              \
3802         assert(to); assert(from)
3803 
3804 PERL_CALLCONV void
3805 Perl_report_evil_fh(pTHX_ const GV *gv)
3806         __attribute__visibility__("hidden");
3807 #define PERL_ARGS_ASSERT_REPORT_EVIL_FH
3808 
3809 PERL_CALLCONV void
3810 Perl_report_uninit(pTHX_ const SV *uninit_sv);
3811 #define PERL_ARGS_ASSERT_REPORT_UNINIT
3812 
3813 PERL_CALLCONV void
3814 Perl_report_wrongway_fh(pTHX_ const GV *gv, const char have)
3815         __attribute__visibility__("hidden");
3816 #define PERL_ARGS_ASSERT_REPORT_WRONGWAY_FH
3817 
3818 PERL_CALLCONV void
3819 Perl_require_pv(pTHX_ const char *pv);
3820 #define PERL_ARGS_ASSERT_REQUIRE_PV             \
3821         assert(pv)
3822 
3823 PERL_CALLCONV void
3824 Perl_resume_compcv(pTHX_ struct suspended_compcv *buffer, bool save);
3825 #define PERL_ARGS_ASSERT_RESUME_COMPCV          \
3826         assert(buffer)
3827 
3828 /* PERL_CALLCONV void
3829 resume_compcv_and_save(pTHX_ struct suspended_compcv *buffer); */
3830 
3831 /* PERL_CALLCONV void
3832 resume_compcv_final(pTHX_ struct suspended_compcv *buffer); */
3833 
3834 PERL_CALLCONV char *
3835 Perl_rninstr(const char *big, const char *bigend, const char *little, const char *lend)
3836         __attribute__warn_unused_result__
3837         __attribute__pure__;
3838 #define PERL_ARGS_ASSERT_RNINSTR                \
3839         assert(big); assert(bigend); assert(little); assert(lend)
3840 
3841 PERL_CALLCONV void
3842 Perl_rpeep(pTHX_ OP *o)
3843         __attribute__visibility__("hidden");
3844 #define PERL_ARGS_ASSERT_RPEEP
3845 
3846 PERL_CALLCONV void
3847 Perl_rpp_free_2_(pTHX_ SV * const sv1, SV * const sv2, const U32 rc1, const U32 rc2);
3848 #define PERL_ARGS_ASSERT_RPP_FREE_2_            \
3849         assert(sv1); assert(sv2)
3850 
3851 PERL_CALLCONV void
3852 Perl_rpp_obliterate_stack_to(pTHX_ I32 ix);
3853 #define PERL_ARGS_ASSERT_RPP_OBLITERATE_STACK_TO
3854 
3855 PERL_CALLCONV Sighandler_t
3856 Perl_rsignal(pTHX_ int i, Sighandler_t t);
3857 #define PERL_ARGS_ASSERT_RSIGNAL
3858 
3859 PERL_CALLCONV int
3860 Perl_rsignal_restore(pTHX_ int i, Sigsave_t *t)
3861         __attribute__visibility__("hidden");
3862 #define PERL_ARGS_ASSERT_RSIGNAL_RESTORE
3863 
3864 PERL_CALLCONV int
3865 Perl_rsignal_save(pTHX_ int i, Sighandler_t t1, Sigsave_t *save)
3866         __attribute__visibility__("hidden");
3867 #define PERL_ARGS_ASSERT_RSIGNAL_SAVE           \
3868         assert(save)
3869 
3870 PERL_CALLCONV Sighandler_t
3871 Perl_rsignal_state(pTHX_ int i);
3872 #define PERL_ARGS_ASSERT_RSIGNAL_STATE
3873 
3874 PERL_CALLCONV int
3875 Perl_runops_debug(pTHX);
3876 #define PERL_ARGS_ASSERT_RUNOPS_DEBUG
3877 
3878 PERL_CALLCONV int
3879 Perl_runops_standard(pTHX);
3880 #define PERL_ARGS_ASSERT_RUNOPS_STANDARD
3881 
3882 PERL_CALLCONV CV *
3883 Perl_rv2cv_op_cv(pTHX_ OP *cvop, U32 flags);
3884 #define PERL_ARGS_ASSERT_RV2CV_OP_CV            \
3885         assert(cvop)
3886 
3887 PERL_CALLCONV void
3888 Perl_rxres_save(pTHX_ void **rsp, REGEXP *rx)
3889         __attribute__visibility__("hidden");
3890 #define PERL_ARGS_ASSERT_RXRES_SAVE             \
3891         assert(rsp); assert(rx)
3892 
3893 PERL_CALLCONV Malloc_t
3894 Perl_safesyscalloc(MEM_SIZE elements, MEM_SIZE size)
3895         __attribute__malloc__
3896         __attribute__warn_unused_result__;
3897 #define PERL_ARGS_ASSERT_SAFESYSCALLOC
3898 
3899 PERL_CALLCONV Free_t
3900 Perl_safesysfree(Malloc_t where);
3901 #define PERL_ARGS_ASSERT_SAFESYSFREE
3902 
3903 PERL_CALLCONV Malloc_t
3904 Perl_safesysmalloc(MEM_SIZE nbytes)
3905         __attribute__malloc__
3906         __attribute__warn_unused_result__;
3907 #define PERL_ARGS_ASSERT_SAFESYSMALLOC
3908 
3909 PERL_CALLCONV Malloc_t
3910 Perl_safesysrealloc(Malloc_t where, MEM_SIZE nbytes)
3911         __attribute__warn_unused_result__;
3912 #define PERL_ARGS_ASSERT_SAFESYSREALLOC
3913 
3914 PERL_CALLCONV void
3915 Perl_save_I16(pTHX_ I16 *intp);
3916 #define PERL_ARGS_ASSERT_SAVE_I16               \
3917         assert(intp)
3918 
3919 PERL_CALLCONV void
3920 Perl_save_I32(pTHX_ I32 *intp);
3921 #define PERL_ARGS_ASSERT_SAVE_I32               \
3922         assert(intp)
3923 
3924 PERL_CALLCONV void
3925 Perl_save_I8(pTHX_ I8 *bytep);
3926 #define PERL_ARGS_ASSERT_SAVE_I8                \
3927         assert(bytep)
3928 
3929 PERL_CALLCONV void
3930 Perl_save_adelete(pTHX_ AV *av, SSize_t key);
3931 #define PERL_ARGS_ASSERT_SAVE_ADELETE           \
3932         assert(av)
3933 
3934 /* PERL_CALLCONV void
3935 save_aelem(pTHX_ AV *av, SSize_t idx, SV **sptr); */
3936 
3937 PERL_CALLCONV void
3938 Perl_save_aelem_flags(pTHX_ AV *av, SSize_t idx, SV **sptr, const U32 flags);
3939 #define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS       \
3940         assert(av); assert(sptr)
3941 
3942 PERL_CALLCONV SSize_t
3943 Perl_save_alloc(pTHX_ SSize_t size, I32 pad);
3944 #define PERL_ARGS_ASSERT_SAVE_ALLOC
3945 
3946 PERL_CALLCONV void
3947 Perl_save_aptr(pTHX_ AV **aptr);
3948 #define PERL_ARGS_ASSERT_SAVE_APTR              \
3949         assert(aptr)
3950 
3951 PERL_CALLCONV AV *
3952 Perl_save_ary(pTHX_ GV *gv);
3953 #define PERL_ARGS_ASSERT_SAVE_ARY               \
3954         assert(gv)
3955 
3956 PERL_CALLCONV void
3957 Perl_save_bool(pTHX_ bool *boolp);
3958 #define PERL_ARGS_ASSERT_SAVE_BOOL              \
3959         assert(boolp)
3960 
3961 PERL_CALLCONV void
3962 Perl_save_clearsv(pTHX_ SV **svp);
3963 #define PERL_ARGS_ASSERT_SAVE_CLEARSV           \
3964         assert(svp)
3965 
3966 PERL_CALLCONV void
3967 Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen);
3968 #define PERL_ARGS_ASSERT_SAVE_DELETE            \
3969         assert(hv); assert(key)
3970 
3971 PERL_CALLCONV void
3972 Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void *p);
3973 #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR        \
3974         assert(p)
3975 
3976 PERL_CALLCONV void
3977 Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void *p);
3978 #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR_X
3979 
3980 PERL_CALLCONV void
3981 Perl_save_freercpv(pTHX_ char *rcpv);
3982 #define PERL_ARGS_ASSERT_SAVE_FREERCPV          \
3983         assert(rcpv)
3984 
3985 PERL_CALLCONV void
3986 Perl_save_generic_pvref(pTHX_ char **str);
3987 #define PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF     \
3988         assert(str)
3989 
3990 PERL_CALLCONV void
3991 Perl_save_generic_svref(pTHX_ SV **sptr);
3992 #define PERL_ARGS_ASSERT_SAVE_GENERIC_SVREF     \
3993         assert(sptr)
3994 
3995 PERL_CALLCONV void
3996 Perl_save_gp(pTHX_ GV *gv, I32 empty);
3997 #define PERL_ARGS_ASSERT_SAVE_GP                \
3998         assert(gv)
3999 
4000 PERL_CALLCONV HV *
4001 Perl_save_hash(pTHX_ GV *gv);
4002 #define PERL_ARGS_ASSERT_SAVE_HASH              \
4003         assert(gv)
4004 
4005 PERL_CALLCONV void
4006 Perl_save_hdelete(pTHX_ HV *hv, SV *keysv);
4007 #define PERL_ARGS_ASSERT_SAVE_HDELETE           \
4008         assert(hv); assert(keysv)
4009 
4010 /* PERL_CALLCONV void
4011 save_helem(pTHX_ HV *hv, SV *key, SV **sptr); */
4012 
4013 PERL_CALLCONV void
4014 Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags);
4015 #define PERL_ARGS_ASSERT_SAVE_HELEM_FLAGS       \
4016         assert(hv); assert(key); assert(sptr)
4017 
4018 PERL_CALLCONV void
4019 Perl_save_hints(pTHX);
4020 #define PERL_ARGS_ASSERT_SAVE_HINTS
4021 
4022 PERL_CALLCONV void
4023 Perl_save_hptr(pTHX_ HV **hptr);
4024 #define PERL_ARGS_ASSERT_SAVE_HPTR              \
4025         assert(hptr)
4026 
4027 PERL_CALLCONV void
4028 Perl_save_int(pTHX_ int *intp);
4029 #define PERL_ARGS_ASSERT_SAVE_INT               \
4030         assert(intp)
4031 
4032 PERL_CALLCONV void
4033 Perl_save_item(pTHX_ SV *item);
4034 #define PERL_ARGS_ASSERT_SAVE_ITEM              \
4035         assert(item)
4036 
4037 PERL_CALLCONV void
4038 Perl_save_iv(pTHX_ IV *ivp);
4039 #define PERL_ARGS_ASSERT_SAVE_IV                \
4040         assert(ivp)
4041 
4042 PERL_CALLCONV void
4043 Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off);
4044 #define PERL_ARGS_ASSERT_SAVE_PADSV_AND_MORTALIZE
4045 
4046 PERL_CALLCONV void
4047 Perl_save_pptr(pTHX_ char **pptr);
4048 #define PERL_ARGS_ASSERT_SAVE_PPTR              \
4049         assert(pptr)
4050 
4051 PERL_CALLCONV void
4052 Perl_save_pushi32ptr(pTHX_ const I32 i, void * const ptr, const int type);
4053 #define PERL_ARGS_ASSERT_SAVE_PUSHI32PTR
4054 
4055 PERL_CALLCONV void
4056 Perl_save_pushptr(pTHX_ void * const ptr, const int type);
4057 #define PERL_ARGS_ASSERT_SAVE_PUSHPTR
4058 
4059 PERL_CALLCONV void
4060 Perl_save_pushptrptr(pTHX_ void * const ptr1, void * const ptr2, const int type);
4061 #define PERL_ARGS_ASSERT_SAVE_PUSHPTRPTR
4062 
4063 PERL_CALLCONV void
4064 Perl_save_rcpv(pTHX_ char **prcpv);
4065 #define PERL_ARGS_ASSERT_SAVE_RCPV              \
4066         assert(prcpv)
4067 
4068 PERL_CALLCONV void
4069 Perl_save_re_context(pTHX);
4070 #define PERL_ARGS_ASSERT_SAVE_RE_CONTEXT
4071 
4072 PERL_CALLCONV SV *
4073 Perl_save_scalar(pTHX_ GV *gv);
4074 #define PERL_ARGS_ASSERT_SAVE_SCALAR            \
4075         assert(gv)
4076 
4077 PERL_CALLCONV void
4078 Perl_save_set_svflags(pTHX_ SV *sv, U32 mask, U32 val);
4079 #define PERL_ARGS_ASSERT_SAVE_SET_SVFLAGS       \
4080         assert(sv)
4081 
4082 PERL_CALLCONV void
4083 Perl_save_shared_pvref(pTHX_ char **str);
4084 #define PERL_ARGS_ASSERT_SAVE_SHARED_PVREF      \
4085         assert(str)
4086 
4087 PERL_CALLCONV void
4088 Perl_save_sptr(pTHX_ SV **sptr);
4089 #define PERL_ARGS_ASSERT_SAVE_SPTR              \
4090         assert(sptr)
4091 
4092 PERL_CALLCONV void
4093 Perl_save_strlen(pTHX_ STRLEN *ptr);
4094 #define PERL_ARGS_ASSERT_SAVE_STRLEN            \
4095         assert(ptr)
4096 
4097 PERL_CALLCONV SV *
4098 Perl_save_svref(pTHX_ SV **sptr);
4099 #define PERL_ARGS_ASSERT_SAVE_SVREF             \
4100         assert(sptr)
4101 
4102 PERL_CALLCONV void
4103 Perl_save_vptr(pTHX_ void *ptr);
4104 #define PERL_ARGS_ASSERT_SAVE_VPTR              \
4105         assert(ptr)
4106 
4107 PERL_CALLCONV char *
4108 Perl_savesharedpv(pTHX_ const char *pv)
4109         __attribute__malloc__
4110         __attribute__warn_unused_result__;
4111 #define PERL_ARGS_ASSERT_SAVESHAREDPV
4112 
4113 PERL_CALLCONV char *
4114 Perl_savesharedpvn(pTHX_ const char * const pv, const STRLEN len)
4115         __attribute__malloc__
4116         __attribute__warn_unused_result__;
4117 #define PERL_ARGS_ASSERT_SAVESHAREDPVN
4118 
4119 PERL_CALLCONV void
4120 Perl_savestack_grow(pTHX);
4121 #define PERL_ARGS_ASSERT_SAVESTACK_GROW
4122 
4123 PERL_CALLCONV void
4124 Perl_savestack_grow_cnt(pTHX_ I32 need);
4125 #define PERL_ARGS_ASSERT_SAVESTACK_GROW_CNT
4126 
4127 PERL_CALLCONV void
4128 Perl_savetmps(pTHX);
4129 #define PERL_ARGS_ASSERT_SAVETMPS
4130 
4131 PERL_CALLCONV OP *
4132 Perl_sawparens(pTHX_ OP *o)
4133         __attribute__visibility__("hidden");
4134 #define PERL_ARGS_ASSERT_SAWPARENS
4135 
4136 PERL_CALLCONV OP *
4137 Perl_scalar(pTHX_ OP *o)
4138         __attribute__visibility__("hidden");
4139 #define PERL_ARGS_ASSERT_SCALAR
4140 
4141 PERL_CALLCONV OP *
4142 Perl_scalarvoid(pTHX_ OP *o)
4143         __attribute__visibility__("hidden");
4144 #define PERL_ARGS_ASSERT_SCALARVOID             \
4145         assert(o)
4146 
4147 PERL_CALLCONV NV
4148 Perl_scan_bin(pTHX_ const char *start, STRLEN len, STRLEN *retlen);
4149 #define PERL_ARGS_ASSERT_SCAN_BIN               \
4150         assert(start); assert(retlen)
4151 
4152 PERL_CALLCONV NV
4153 Perl_scan_hex(pTHX_ const char *start, STRLEN len, STRLEN *retlen);
4154 #define PERL_ARGS_ASSERT_SCAN_HEX               \
4155         assert(start); assert(retlen)
4156 
4157 PERL_CALLCONV char *
4158 Perl_scan_num(pTHX_ const char *s, YYSTYPE *lvalp);
4159 #define PERL_ARGS_ASSERT_SCAN_NUM               \
4160         assert(s); assert(lvalp)
4161 
4162 PERL_CALLCONV NV
4163 Perl_scan_oct(pTHX_ const char *start, STRLEN len, STRLEN *retlen);
4164 #define PERL_ARGS_ASSERT_SCAN_OCT               \
4165         assert(start); assert(retlen)
4166 
4167 PERL_CALLCONV char *
4168 Perl_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, char **delimp)
4169         __attribute__warn_unused_result__;
4170 #define PERL_ARGS_ASSERT_SCAN_STR               \
4171         assert(start)
4172 
4173 PERL_CALLCONV const char *
4174 Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv);
4175 #define PERL_ARGS_ASSERT_SCAN_VERSION           \
4176         assert(s); assert(rv)
4177 
4178 PERL_CALLCONV char *
4179 Perl_scan_vstring(pTHX_ const char *s, const char * const e, SV *sv);
4180 #define PERL_ARGS_ASSERT_SCAN_VSTRING           \
4181         assert(s); assert(e); assert(sv)
4182 
4183 PERL_CALLCONV char *
4184 Perl_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp);
4185 #define PERL_ARGS_ASSERT_SCAN_WORD              \
4186         assert(s); assert(dest); assert(slp)
4187 
4188 PERL_CALLCONV char *
4189 Perl_scan_word6(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp, bool warn_tick);
4190 #define PERL_ARGS_ASSERT_SCAN_WORD6             \
4191         assert(s); assert(dest); assert(slp)
4192 
4193 PERL_CALLCONV U32
4194 Perl_seed(pTHX);
4195 #define PERL_ARGS_ASSERT_SEED
4196 
4197 PERL_CALLCONV void
4198 Perl_set_caret_X(pTHX);
4199 #define PERL_ARGS_ASSERT_SET_CARET_X
4200 
4201 PERL_CALLCONV void
4202 Perl_set_context(void *t);
4203 #define PERL_ARGS_ASSERT_SET_CONTEXT            \
4204         assert(t)
4205 
4206 PERL_CALLCONV void
4207 Perl_set_numeric_standard(pTHX_ const char *file, const line_t caller_line);
4208 #define PERL_ARGS_ASSERT_SET_NUMERIC_STANDARD   \
4209         assert(file)
4210 
4211 PERL_CALLCONV void
4212 Perl_set_numeric_underlying(pTHX_ const char *file, const line_t caller_line);
4213 #define PERL_ARGS_ASSERT_SET_NUMERIC_UNDERLYING \
4214         assert(file)
4215 
4216 PERL_CALLCONV void
4217 Perl_setdefout(pTHX_ GV *gv);
4218 #define PERL_ARGS_ASSERT_SETDEFOUT              \
4219         assert(gv)
4220 
4221 PERL_CALLCONV void
4222 Perl_setfd_cloexec(int fd)
4223         __attribute__visibility__("hidden");
4224 #define PERL_ARGS_ASSERT_SETFD_CLOEXEC
4225 
4226 PERL_CALLCONV void
4227 Perl_setfd_cloexec_for_nonsysfd(pTHX_ int fd)
4228         __attribute__visibility__("hidden");
4229 #define PERL_ARGS_ASSERT_SETFD_CLOEXEC_FOR_NONSYSFD
4230 
4231 PERL_CALLCONV void
4232 Perl_setfd_cloexec_or_inhexec_by_sysfdness(pTHX_ int fd)
4233         __attribute__visibility__("hidden");
4234 #define PERL_ARGS_ASSERT_SETFD_CLOEXEC_OR_INHEXEC_BY_SYSFDNESS
4235 
4236 PERL_CALLCONV void
4237 Perl_setfd_inhexec(int fd)
4238         __attribute__visibility__("hidden");
4239 #define PERL_ARGS_ASSERT_SETFD_INHEXEC
4240 
4241 PERL_CALLCONV void
4242 Perl_setfd_inhexec_for_sysfd(pTHX_ int fd)
4243         __attribute__visibility__("hidden");
4244 #define PERL_ARGS_ASSERT_SETFD_INHEXEC_FOR_SYSFD
4245 
4246 PERL_CALLCONV HEK *
4247 Perl_share_hek(pTHX_ const char *str, SSize_t len, U32 hash);
4248 #define PERL_ARGS_ASSERT_SHARE_HEK              \
4249         assert(str)
4250 
4251 PERL_CALLCONV Signal_t
4252 Perl_sighandler1(int sig)
4253         __attribute__visibility__("hidden");
4254 #define PERL_ARGS_ASSERT_SIGHANDLER1
4255 
4256 PERL_CALLCONV Signal_t
4257 Perl_sighandler3(int sig, Siginfo_t *info, void *uap)
4258         __attribute__visibility__("hidden");
4259 #define PERL_ARGS_ASSERT_SIGHANDLER3
4260 
4261 PERL_CALLCONV char *
4262 Perl_skipspace_flags(pTHX_ char *s, U32 flags)
4263         __attribute__warn_unused_result__;
4264 #define PERL_ARGS_ASSERT_SKIPSPACE_FLAGS        \
4265         assert(s)
4266 
4267 PERL_CALLCONV void
4268 Perl_sortsv(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp);
4269 #define PERL_ARGS_ASSERT_SORTSV                 \
4270         assert(cmp)
4271 
4272 PERL_CALLCONV void
4273 Perl_sortsv_flags(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp, U32 flags);
4274 #define PERL_ARGS_ASSERT_SORTSV_FLAGS           \
4275         assert(cmp)
4276 
4277 PERL_CALLCONV SV **
4278 Perl_stack_grow(pTHX_ SV **sp, SV **p, SSize_t n);
4279 #define PERL_ARGS_ASSERT_STACK_GROW             \
4280         assert(sp); assert(p)
4281 
4282 PERL_CALLCONV PerlIO *
4283 Perl_start_glob(pTHX_ SV *tmpglob, IO *io)
4284         __attribute__visibility__("hidden");
4285 #define PERL_ARGS_ASSERT_START_GLOB             \
4286         assert(tmpglob); assert(io)
4287 
4288 PERL_CALLCONV I32
4289 Perl_start_subparse(pTHX_ I32 is_format, U32 flags);
4290 #define PERL_ARGS_ASSERT_START_SUBPARSE
4291 
4292 PERL_CALLCONV NV
4293 Perl_str_to_version(pTHX_ SV *sv)
4294         __attribute__warn_unused_result__;
4295 #define PERL_ARGS_ASSERT_STR_TO_VERSION         \
4296         assert(sv)
4297 
4298 PERL_CALLCONV void
4299 Perl_sub_crush_depth(pTHX_ CV *cv)
4300         __attribute__visibility__("hidden");
4301 #define PERL_ARGS_ASSERT_SUB_CRUSH_DEPTH        \
4302         assert(cv)
4303 
4304 PERL_CALLCONV void
4305 Perl_suspend_compcv(pTHX_ struct suspended_compcv *buffer);
4306 #define PERL_ARGS_ASSERT_SUSPEND_COMPCV         \
4307         assert(buffer)
4308 
4309 PERL_CALLCONV bool
4310 Perl_sv_2bool_flags(pTHX_ SV *sv, I32 flags);
4311 #define PERL_ARGS_ASSERT_SV_2BOOL_FLAGS         \
4312         assert(sv)
4313 
4314 PERL_CALLCONV CV *
4315 Perl_sv_2cv(pTHX_ SV *sv, HV ** const st, GV ** const gvp, const I32 lref);
4316 #define PERL_ARGS_ASSERT_SV_2CV                 \
4317         assert(st); assert(gvp)
4318 
4319 PERL_CALLCONV IO *
4320 Perl_sv_2io(pTHX_ SV * const sv);
4321 #define PERL_ARGS_ASSERT_SV_2IO                 \
4322         assert(sv)
4323 
4324 PERL_CALLCONV IV
4325 Perl_sv_2iv_flags(pTHX_ SV * const sv, const I32 flags);
4326 #define PERL_ARGS_ASSERT_SV_2IV_FLAGS           \
4327         assert(sv)
4328 
4329 PERL_CALLCONV SV *
4330 Perl_sv_2mortal(pTHX_ SV * const sv);
4331 #define PERL_ARGS_ASSERT_SV_2MORTAL
4332 
4333 PERL_CALLCONV SV *
4334 Perl_sv_2num(pTHX_ SV * const sv)
4335         __attribute__visibility__("hidden");
4336 #define PERL_ARGS_ASSERT_SV_2NUM                \
4337         assert(sv)
4338 
4339 PERL_CALLCONV NV
4340 Perl_sv_2nv_flags(pTHX_ SV * const sv, const I32 flags);
4341 #define PERL_ARGS_ASSERT_SV_2NV_FLAGS           \
4342         assert(sv)
4343 
4344 PERL_CALLCONV char *
4345 Perl_sv_2pv_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags);
4346 #define PERL_ARGS_ASSERT_SV_2PV_FLAGS           \
4347         assert(sv)
4348 
4349 PERL_CALLCONV char *
4350 Perl_sv_2pvbyte_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags);
4351 #define PERL_ARGS_ASSERT_SV_2PVBYTE_FLAGS       \
4352         assert(sv)
4353 
4354 PERL_CALLCONV char *
4355 Perl_sv_2pvutf8_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags);
4356 #define PERL_ARGS_ASSERT_SV_2PVUTF8_FLAGS       \
4357         assert(sv)
4358 
4359 PERL_CALLCONV UV
4360 Perl_sv_2uv_flags(pTHX_ SV * const sv, const I32 flags);
4361 #define PERL_ARGS_ASSERT_SV_2UV_FLAGS           \
4362         assert(sv)
4363 
4364 PERL_CALLCONV void
4365 Perl_sv_backoff(SV * const sv);
4366 #define PERL_ARGS_ASSERT_SV_BACKOFF             \
4367         assert(sv)
4368 
4369 PERL_CALLCONV SV *
4370 Perl_sv_bless(pTHX_ SV * const sv, HV * const stash);
4371 #define PERL_ARGS_ASSERT_SV_BLESS               \
4372         assert(sv); assert(stash)
4373 
4374 PERL_CALLCONV bool
4375 Perl_sv_cat_decode(pTHX_ SV *dsv, SV *encoding, SV *ssv, int *offset, char *tstr, int tlen);
4376 #define PERL_ARGS_ASSERT_SV_CAT_DECODE          \
4377         assert(dsv); assert(encoding); assert(ssv); assert(offset); assert(tstr)
4378 
4379 PERL_CALLCONV void
4380 Perl_sv_catpv(pTHX_ SV * const dsv, const char *sstr);
4381 #define PERL_ARGS_ASSERT_SV_CATPV               \
4382         assert(dsv)
4383 
4384 PERL_CALLCONV void
4385 Perl_sv_catpv_flags(pTHX_ SV *dsv, const char *sstr, const I32 flags);
4386 #define PERL_ARGS_ASSERT_SV_CATPV_FLAGS         \
4387         assert(dsv); assert(sstr)
4388 
4389 PERL_CALLCONV void
4390 Perl_sv_catpv_mg(pTHX_ SV * const dsv, const char * const sstr);
4391 #define PERL_ARGS_ASSERT_SV_CATPV_MG            \
4392         assert(dsv)
4393 
4394 PERL_CALLCONV void
4395 Perl_sv_catpvf(pTHX_ SV * const sv, const char * const pat, ...)
4396         __attribute__format__(__printf__,pTHX_2,pTHX_3);
4397 #define PERL_ARGS_ASSERT_SV_CATPVF              \
4398         assert(sv); assert(pat)
4399 
4400 PERL_CALLCONV void
4401 Perl_sv_catpvf_mg(pTHX_ SV * const sv, const char * const pat, ...)
4402         __attribute__format__(__printf__,pTHX_2,pTHX_3);
4403 #define PERL_ARGS_ASSERT_SV_CATPVF_MG           \
4404         assert(sv); assert(pat)
4405 
4406 PERL_CALLCONV void
4407 Perl_sv_catpvn_flags(pTHX_ SV * const dsv, const char *sstr, const STRLEN len, const I32 flags);
4408 #define PERL_ARGS_ASSERT_SV_CATPVN_FLAGS        \
4409         assert(dsv); assert(sstr)
4410 
4411 PERL_CALLCONV void
4412 Perl_sv_catsv_flags(pTHX_ SV * const dsv, SV * const sstr, const I32 flags);
4413 #define PERL_ARGS_ASSERT_SV_CATSV_FLAGS         \
4414         assert(dsv)
4415 
4416 PERL_CALLCONV void
4417 Perl_sv_chop(pTHX_ SV * const sv, const char * const ptr);
4418 #define PERL_ARGS_ASSERT_SV_CHOP                \
4419         assert(sv)
4420 
4421 PERL_CALLCONV SSize_t
4422 Perl_sv_clean_all(pTHX)
4423         __attribute__visibility__("hidden");
4424 #define PERL_ARGS_ASSERT_SV_CLEAN_ALL
4425 
4426 PERL_CALLCONV void
4427 Perl_sv_clean_objs(pTHX)
4428         __attribute__visibility__("hidden");
4429 #define PERL_ARGS_ASSERT_SV_CLEAN_OBJS
4430 
4431 PERL_CALLCONV void
4432 Perl_sv_clear(pTHX_ SV * const orig_sv);
4433 #define PERL_ARGS_ASSERT_SV_CLEAR               \
4434         assert(orig_sv)
4435 
4436 PERL_CALLCONV I32
4437 Perl_sv_cmp(pTHX_ SV * const sv1, SV * const sv2);
4438 #define PERL_ARGS_ASSERT_SV_CMP
4439 
4440 PERL_CALLCONV I32
4441 Perl_sv_cmp_flags(pTHX_ SV * const sv1, SV * const sv2, const U32 flags);
4442 #define PERL_ARGS_ASSERT_SV_CMP_FLAGS
4443 
4444 PERL_CALLCONV I32
4445 Perl_sv_cmp_locale(pTHX_ SV * const sv1, SV * const sv2);
4446 #define PERL_ARGS_ASSERT_SV_CMP_LOCALE
4447 
4448 PERL_CALLCONV I32
4449 Perl_sv_cmp_locale_flags(pTHX_ SV * const sv1, SV * const sv2, const U32 flags);
4450 #define PERL_ARGS_ASSERT_SV_CMP_LOCALE_FLAGS
4451 
4452 PERL_CALLCONV void
4453 Perl_sv_copypv_flags(pTHX_ SV * const dsv, SV * const ssv, const I32 flags);
4454 #define PERL_ARGS_ASSERT_SV_COPYPV_FLAGS        \
4455         assert(dsv); assert(ssv)
4456 
4457 /* PERL_CALLCONV void
4458 sv_copypv_nomg(pTHX_ SV * const dsv, SV * const ssv); */
4459 
4460 PERL_CALLCONV void
4461 Perl_sv_dec(pTHX_ SV * const sv);
4462 #define PERL_ARGS_ASSERT_SV_DEC
4463 
4464 PERL_CALLCONV void
4465 Perl_sv_dec_nomg(pTHX_ SV * const sv);
4466 #define PERL_ARGS_ASSERT_SV_DEC_NOMG
4467 
4468 PERL_CALLCONV void
4469 Perl_sv_del_backref(pTHX_ SV * const tsv, SV * const sv);
4470 #define PERL_ARGS_ASSERT_SV_DEL_BACKREF         \
4471         assert(tsv); assert(sv)
4472 
4473 PERL_CALLCONV bool
4474 Perl_sv_derived_from(pTHX_ SV *sv, const char * const name)
4475         __attribute__warn_unused_result__;
4476 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM        \
4477         assert(sv); assert(name)
4478 
4479 PERL_CALLCONV bool
4480 Perl_sv_derived_from_hv(pTHX_ SV *sv, HV *hv)
4481         __attribute__warn_unused_result__;
4482 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_HV     \
4483         assert(sv); assert(hv)
4484 
4485 PERL_CALLCONV bool
4486 Perl_sv_derived_from_pv(pTHX_ SV *sv, const char * const name, U32 flags)
4487         __attribute__warn_unused_result__;
4488 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PV     \
4489         assert(sv); assert(name)
4490 
4491 PERL_CALLCONV bool
4492 Perl_sv_derived_from_pvn(pTHX_ SV *sv, const char * const name, const STRLEN len, U32 flags)
4493         __attribute__warn_unused_result__;
4494 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PVN    \
4495         assert(sv); assert(name)
4496 
4497 PERL_CALLCONV bool
4498 Perl_sv_derived_from_sv(pTHX_ SV *sv, SV *namesv, U32 flags)
4499         __attribute__warn_unused_result__;
4500 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_SV     \
4501         assert(sv); assert(namesv)
4502 
4503 PERL_CALLCONV bool
4504 Perl_sv_destroyable(pTHX_ SV *sv);
4505 #define PERL_ARGS_ASSERT_SV_DESTROYABLE
4506 
4507 PERL_CALLCONV bool
4508 Perl_sv_does(pTHX_ SV *sv, const char * const name)
4509         __attribute__warn_unused_result__;
4510 #define PERL_ARGS_ASSERT_SV_DOES                \
4511         assert(sv); assert(name)
4512 
4513 PERL_CALLCONV bool
4514 Perl_sv_does_pv(pTHX_ SV *sv, const char * const name, U32 flags)
4515         __attribute__warn_unused_result__;
4516 #define PERL_ARGS_ASSERT_SV_DOES_PV             \
4517         assert(sv); assert(name)
4518 
4519 PERL_CALLCONV bool
4520 Perl_sv_does_pvn(pTHX_ SV *sv, const char * const name, const STRLEN len, U32 flags)
4521         __attribute__warn_unused_result__;
4522 #define PERL_ARGS_ASSERT_SV_DOES_PVN            \
4523         assert(sv); assert(name)
4524 
4525 PERL_CALLCONV bool
4526 Perl_sv_does_sv(pTHX_ SV *sv, SV *namesv, U32 flags)
4527         __attribute__warn_unused_result__;
4528 #define PERL_ARGS_ASSERT_SV_DOES_SV             \
4529         assert(sv); assert(namesv)
4530 
4531 PERL_CALLCONV void
4532 Perl_sv_dump(pTHX_ SV *sv);
4533 #define PERL_ARGS_ASSERT_SV_DUMP
4534 
4535 PERL_CALLCONV void
4536 Perl_sv_dump_depth(pTHX_ SV *sv, I32 depth);
4537 #define PERL_ARGS_ASSERT_SV_DUMP_DEPTH
4538 
4539 PERL_CALLCONV I32
4540 Perl_sv_eq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags);
4541 #define PERL_ARGS_ASSERT_SV_EQ_FLAGS
4542 
4543 PERL_CALLCONV void
4544 Perl_sv_force_normal_flags(pTHX_ SV * const sv, const U32 flags);
4545 #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS  \
4546         assert(sv)
4547 
4548 PERL_CALLCONV void
4549 Perl_sv_free(pTHX_ SV * const sv);
4550 #define PERL_ARGS_ASSERT_SV_FREE
4551 
4552 PERL_CALLCONV void
4553 Perl_sv_free2(pTHX_ SV * const sv, const U32 refcnt);
4554 #define PERL_ARGS_ASSERT_SV_FREE2               \
4555         assert(sv)
4556 
4557 PERL_CALLCONV void
4558 Perl_sv_free_arenas(pTHX)
4559         __attribute__visibility__("hidden");
4560 #define PERL_ARGS_ASSERT_SV_FREE_ARENAS
4561 
4562 PERL_CALLCONV SV *
4563 Perl_sv_get_backrefs(SV * const sv);
4564 #define PERL_ARGS_ASSERT_SV_GET_BACKREFS        \
4565         assert(sv)
4566 
4567 PERL_CALLCONV char *
4568 Perl_sv_gets(pTHX_ SV * const sv, PerlIO * const fp, I32 append);
4569 #define PERL_ARGS_ASSERT_SV_GETS                \
4570         assert(sv); assert(fp)
4571 
4572 PERL_CALLCONV char *
4573 Perl_sv_grow(pTHX_ SV * const sv, STRLEN newlen);
4574 #define PERL_ARGS_ASSERT_SV_GROW                \
4575         assert(sv)
4576 
4577 PERL_CALLCONV char *
4578 Perl_sv_grow_fresh(pTHX_ SV * const sv, STRLEN newlen);
4579 #define PERL_ARGS_ASSERT_SV_GROW_FRESH          \
4580         assert(sv)
4581 
4582 PERL_CALLCONV void
4583 Perl_sv_inc(pTHX_ SV * const sv);
4584 #define PERL_ARGS_ASSERT_SV_INC
4585 
4586 PERL_CALLCONV void
4587 Perl_sv_inc_nomg(pTHX_ SV * const sv);
4588 #define PERL_ARGS_ASSERT_SV_INC_NOMG
4589 
4590 PERL_CALLCONV void
4591 Perl_sv_insert_flags(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char *little, const STRLEN littlelen, const U32 flags);
4592 #define PERL_ARGS_ASSERT_SV_INSERT_FLAGS        \
4593         assert(bigstr); assert(little)
4594 
4595 PERL_CALLCONV int
4596 Perl_sv_isa(pTHX_ SV *sv, const char * const name);
4597 #define PERL_ARGS_ASSERT_SV_ISA                 \
4598         assert(name)
4599 
4600 PERL_CALLCONV bool
4601 Perl_sv_isa_sv(pTHX_ SV *sv, SV *namesv)
4602         __attribute__warn_unused_result__;
4603 #define PERL_ARGS_ASSERT_SV_ISA_SV              \
4604         assert(sv); assert(namesv)
4605 
4606 PERL_CALLCONV int
4607 Perl_sv_isobject(pTHX_ SV *sv);
4608 #define PERL_ARGS_ASSERT_SV_ISOBJECT
4609 
4610 PERL_CALLCONV SV *
4611 Perl_sv_langinfo(pTHX_ const nl_item item);
4612 #define PERL_ARGS_ASSERT_SV_LANGINFO
4613 
4614 PERL_CALLCONV STRLEN
4615 Perl_sv_len(pTHX_ SV * const sv);
4616 #define PERL_ARGS_ASSERT_SV_LEN
4617 
4618 PERL_CALLCONV STRLEN
4619 Perl_sv_len_utf8(pTHX_ SV * const sv);
4620 #define PERL_ARGS_ASSERT_SV_LEN_UTF8
4621 
4622 PERL_CALLCONV STRLEN
4623 Perl_sv_len_utf8_nomg(pTHX_ SV * const sv);
4624 #define PERL_ARGS_ASSERT_SV_LEN_UTF8_NOMG       \
4625         assert(sv)
4626 
4627 PERL_CALLCONV void
4628 Perl_sv_magic(pTHX_ SV * const sv, SV * const obj, const int how, const char * const name, const I32 namlen);
4629 #define PERL_ARGS_ASSERT_SV_MAGIC               \
4630         assert(sv)
4631 
4632 PERL_CALLCONV MAGIC *
4633 Perl_sv_magicext(pTHX_ SV * const sv, SV * const obj, const int how, const MGVTBL * const vtbl, const char * const name, const I32 namlen);
4634 #define PERL_ARGS_ASSERT_SV_MAGICEXT            \
4635         assert(sv)
4636 
4637 PERL_CALLCONV MAGIC *
4638 Perl_sv_magicext_mglob(pTHX_ SV *sv);
4639 #define PERL_ARGS_ASSERT_SV_MAGICEXT_MGLOB      \
4640         assert(sv)
4641 
4642 PERL_CALLCONV SV *
4643 Perl_sv_mortalcopy_flags(pTHX_ SV * const oldsv, U32 flags)
4644         __attribute__warn_unused_result__;
4645 #define PERL_ARGS_ASSERT_SV_MORTALCOPY_FLAGS
4646 
4647 PERL_CALLCONV SV *
4648 Perl_sv_newmortal(pTHX)
4649         __attribute__warn_unused_result__;
4650 #define PERL_ARGS_ASSERT_SV_NEWMORTAL
4651 
4652 PERL_CALLCONV SV *
4653 Perl_sv_newref(pTHX_ SV * const sv);
4654 #define PERL_ARGS_ASSERT_SV_NEWREF
4655 
4656 PERL_CALLCONV void
4657 Perl_sv_nosharing(pTHX_ SV *sv);
4658 #define PERL_ARGS_ASSERT_SV_NOSHARING
4659 
4660 /* PERL_CALLCONV bool
4661 sv_numeq(pTHX_ SV *sv1, SV *sv2); */
4662 
4663 PERL_CALLCONV bool
4664 Perl_sv_numeq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags);
4665 #define PERL_ARGS_ASSERT_SV_NUMEQ_FLAGS
4666 
4667 PERL_CALLCONV char *
4668 Perl_sv_peek(pTHX_ SV *sv);
4669 #define PERL_ARGS_ASSERT_SV_PEEK
4670 
4671 PERL_CALLCONV void
4672 Perl_sv_pos_b2u(pTHX_ SV * const sv, I32 * const offsetp);
4673 #define PERL_ARGS_ASSERT_SV_POS_B2U             \
4674         assert(offsetp)
4675 
4676 PERL_CALLCONV STRLEN
4677 Perl_sv_pos_b2u_flags(pTHX_ SV * const sv, STRLEN const offset, U32 flags);
4678 #define PERL_ARGS_ASSERT_SV_POS_B2U_FLAGS       \
4679         assert(sv)
4680 
4681 PERL_CALLCONV void
4682 Perl_sv_pos_u2b(pTHX_ SV * const sv, I32 * const offsetp, I32 * const lenp);
4683 #define PERL_ARGS_ASSERT_SV_POS_U2B             \
4684         assert(offsetp)
4685 
4686 PERL_CALLCONV STRLEN
4687 Perl_sv_pos_u2b_flags(pTHX_ SV * const sv, STRLEN uoffset, STRLEN * const lenp, U32 flags);
4688 #define PERL_ARGS_ASSERT_SV_POS_U2B_FLAGS       \
4689         assert(sv)
4690 
4691 PERL_CALLCONV char *
4692 Perl_sv_pvbyten_force(pTHX_ SV * const sv, STRLEN * const lp);
4693 #define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE       \
4694         assert(sv)
4695 
4696 PERL_CALLCONV char *
4697 Perl_sv_pvn_force_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags);
4698 #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS     \
4699         assert(sv)
4700 
4701 PERL_CALLCONV char *
4702 Perl_sv_pvutf8n_force(pTHX_ SV * const sv, STRLEN * const lp);
4703 #define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE       \
4704         assert(sv)
4705 
4706 PERL_CALLCONV char *
4707 Perl_sv_recode_to_utf8(pTHX_ SV *sv, SV *encoding);
4708 #define PERL_ARGS_ASSERT_SV_RECODE_TO_UTF8      \
4709         assert(sv); assert(encoding)
4710 
4711 PERL_CALLCONV SV *
4712 Perl_sv_ref(pTHX_ SV *dst, const SV * const sv, const int ob);
4713 #define PERL_ARGS_ASSERT_SV_REF                 \
4714         assert(sv)
4715 
4716 PERL_CALLCONV const char *
4717 Perl_sv_reftype(pTHX_ const SV * const sv, const int ob)
4718         __attribute__warn_unused_result__;
4719 #define PERL_ARGS_ASSERT_SV_REFTYPE             \
4720         assert(sv)
4721 
4722 PERL_CALLCONV void
4723 Perl_sv_replace(pTHX_ SV * const sv, SV * const nsv);
4724 #define PERL_ARGS_ASSERT_SV_REPLACE             \
4725         assert(sv); assert(nsv)
4726 
4727 PERL_CALLCONV void
4728 Perl_sv_report_used(pTHX);
4729 #define PERL_ARGS_ASSERT_SV_REPORT_USED
4730 
4731 PERL_CALLCONV void
4732 Perl_sv_reset(pTHX_ const char *s, HV * const stash);
4733 #define PERL_ARGS_ASSERT_SV_RESET               \
4734         assert(s)
4735 
4736 PERL_CALLCONV void
4737 Perl_sv_resetpvn(pTHX_ const char *s, STRLEN len, HV * const stash)
4738         __attribute__visibility__("hidden");
4739 #define PERL_ARGS_ASSERT_SV_RESETPVN
4740 
4741 PERL_CALLCONV SV *
4742 Perl_sv_rvunweaken(pTHX_ SV * const sv);
4743 #define PERL_ARGS_ASSERT_SV_RVUNWEAKEN          \
4744         assert(sv)
4745 
4746 PERL_CALLCONV SV *
4747 Perl_sv_rvweaken(pTHX_ SV * const sv);
4748 #define PERL_ARGS_ASSERT_SV_RVWEAKEN            \
4749         assert(sv)
4750 
4751 PERL_CALLCONV void
4752 Perl_sv_set_bool(pTHX_ SV *sv, const bool bool_val);
4753 #define PERL_ARGS_ASSERT_SV_SET_BOOL            \
4754         assert(sv)
4755 
4756 PERL_CALLCONV void
4757 Perl_sv_set_false(pTHX_ SV *sv);
4758 #define PERL_ARGS_ASSERT_SV_SET_FALSE           \
4759         assert(sv)
4760 
4761 PERL_CALLCONV void
4762 Perl_sv_set_true(pTHX_ SV *sv);
4763 #define PERL_ARGS_ASSERT_SV_SET_TRUE            \
4764         assert(sv)
4765 
4766 PERL_CALLCONV void
4767 Perl_sv_set_undef(pTHX_ SV *sv);
4768 #define PERL_ARGS_ASSERT_SV_SET_UNDEF           \
4769         assert(sv)
4770 
4771 PERL_CALLCONV void
4772 Perl_sv_sethek(pTHX_ SV * const sv, const HEK * const hek);
4773 #define PERL_ARGS_ASSERT_SV_SETHEK              \
4774         assert(sv)
4775 
4776 PERL_CALLCONV void
4777 Perl_sv_setiv(pTHX_ SV * const sv, const IV num);
4778 #define PERL_ARGS_ASSERT_SV_SETIV               \
4779         assert(sv)
4780 
4781 PERL_CALLCONV void
4782 Perl_sv_setiv_mg(pTHX_ SV * const sv, const IV i);
4783 #define PERL_ARGS_ASSERT_SV_SETIV_MG            \
4784         assert(sv)
4785 
4786 PERL_CALLCONV void
4787 Perl_sv_setnv(pTHX_ SV * const sv, const NV num);
4788 #define PERL_ARGS_ASSERT_SV_SETNV               \
4789         assert(sv)
4790 
4791 PERL_CALLCONV void
4792 Perl_sv_setnv_mg(pTHX_ SV * const sv, const NV num);
4793 #define PERL_ARGS_ASSERT_SV_SETNV_MG            \
4794         assert(sv)
4795 
4796 PERL_CALLCONV void
4797 Perl_sv_setpv(pTHX_ SV * const sv, const char * const ptr);
4798 #define PERL_ARGS_ASSERT_SV_SETPV               \
4799         assert(sv)
4800 
4801 PERL_CALLCONV char  *
4802 Perl_sv_setpv_bufsize(pTHX_ SV * const sv, const STRLEN cur, const STRLEN len);
4803 #define PERL_ARGS_ASSERT_SV_SETPV_BUFSIZE       \
4804         assert(sv)
4805 
4806 PERL_CALLCONV void
4807 Perl_sv_setpv_mg(pTHX_ SV * const sv, const char * const ptr);
4808 #define PERL_ARGS_ASSERT_SV_SETPV_MG            \
4809         assert(sv)
4810 
4811 PERL_CALLCONV void
4812 Perl_sv_setpvf(pTHX_ SV * const sv, const char * const pat, ...)
4813         __attribute__format__(__printf__,pTHX_2,pTHX_3);
4814 #define PERL_ARGS_ASSERT_SV_SETPVF              \
4815         assert(sv); assert(pat)
4816 
4817 PERL_CALLCONV void
4818 Perl_sv_setpvf_mg(pTHX_ SV * const sv, const char * const pat, ...)
4819         __attribute__format__(__printf__,pTHX_2,pTHX_3);
4820 #define PERL_ARGS_ASSERT_SV_SETPVF_MG           \
4821         assert(sv); assert(pat)
4822 
4823 PERL_CALLCONV void
4824 Perl_sv_setpvn(pTHX_ SV * const sv, const char * const ptr, const STRLEN len);
4825 #define PERL_ARGS_ASSERT_SV_SETPVN              \
4826         assert(sv)
4827 
4828 PERL_CALLCONV void
4829 Perl_sv_setpvn_fresh(pTHX_ SV * const sv, const char * const ptr, const STRLEN len);
4830 #define PERL_ARGS_ASSERT_SV_SETPVN_FRESH        \
4831         assert(sv)
4832 
4833 PERL_CALLCONV void
4834 Perl_sv_setpvn_mg(pTHX_ SV * const sv, const char * const ptr, const STRLEN len);
4835 #define PERL_ARGS_ASSERT_SV_SETPVN_MG           \
4836         assert(sv); assert(ptr)
4837 
4838 PERL_CALLCONV SV *
4839 Perl_sv_setref_iv(pTHX_ SV * const rv, const char * const classname, const IV iv);
4840 #define PERL_ARGS_ASSERT_SV_SETREF_IV           \
4841         assert(rv)
4842 
4843 PERL_CALLCONV SV *
4844 Perl_sv_setref_nv(pTHX_ SV * const rv, const char * const classname, const NV nv);
4845 #define PERL_ARGS_ASSERT_SV_SETREF_NV           \
4846         assert(rv)
4847 
4848 PERL_CALLCONV SV *
4849 Perl_sv_setref_pv(pTHX_ SV * const rv, const char * const classname, void * const pv);
4850 #define PERL_ARGS_ASSERT_SV_SETREF_PV           \
4851         assert(rv)
4852 
4853 PERL_CALLCONV SV *
4854 Perl_sv_setref_pvn(pTHX_ SV * const rv, const char * const classname, const char * const pv, const STRLEN n);
4855 #define PERL_ARGS_ASSERT_SV_SETREF_PVN          \
4856         assert(rv); assert(pv)
4857 
4858 PERL_CALLCONV SV *
4859 Perl_sv_setref_uv(pTHX_ SV * const rv, const char * const classname, const UV uv);
4860 #define PERL_ARGS_ASSERT_SV_SETREF_UV           \
4861         assert(rv)
4862 
4863 PERL_CALLCONV void
4864 Perl_sv_setrv_inc(pTHX_ SV * const sv, SV * const ref);
4865 #define PERL_ARGS_ASSERT_SV_SETRV_INC           \
4866         assert(sv); assert(ref)
4867 
4868 PERL_CALLCONV void
4869 Perl_sv_setrv_inc_mg(pTHX_ SV * const sv, SV * const ref);
4870 #define PERL_ARGS_ASSERT_SV_SETRV_INC_MG        \
4871         assert(sv); assert(ref)
4872 
4873 PERL_CALLCONV void
4874 Perl_sv_setrv_noinc(pTHX_ SV * const sv, SV * const ref);
4875 #define PERL_ARGS_ASSERT_SV_SETRV_NOINC         \
4876         assert(sv); assert(ref)
4877 
4878 PERL_CALLCONV void
4879 Perl_sv_setrv_noinc_mg(pTHX_ SV * const sv, SV * const ref);
4880 #define PERL_ARGS_ASSERT_SV_SETRV_NOINC_MG      \
4881         assert(sv); assert(ref)
4882 
4883 PERL_CALLCONV void
4884 Perl_sv_setsv_flags(pTHX_ SV *dsv, SV *ssv, const I32 flags);
4885 #define PERL_ARGS_ASSERT_SV_SETSV_FLAGS         \
4886         assert(dsv)
4887 
4888 PERL_CALLCONV void
4889 Perl_sv_setsv_mg(pTHX_ SV * const dsv, SV * const ssv);
4890 #define PERL_ARGS_ASSERT_SV_SETSV_MG            \
4891         assert(dsv)
4892 
4893 PERL_CALLCONV void
4894 Perl_sv_setuv(pTHX_ SV * const sv, const UV num);
4895 #define PERL_ARGS_ASSERT_SV_SETUV               \
4896         assert(sv)
4897 
4898 PERL_CALLCONV void
4899 Perl_sv_setuv_mg(pTHX_ SV * const sv, const UV u);
4900 #define PERL_ARGS_ASSERT_SV_SETUV_MG            \
4901         assert(sv)
4902 
4903 /* PERL_CALLCONV bool
4904 sv_streq(pTHX_ SV *sv1, SV *sv2); */
4905 
4906 PERL_CALLCONV bool
4907 Perl_sv_streq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags);
4908 #define PERL_ARGS_ASSERT_SV_STREQ_FLAGS
4909 
4910 PERL_CALLCONV SV *
4911 Perl_sv_strftime_ints(pTHX_ SV *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst);
4912 #define PERL_ARGS_ASSERT_SV_STRFTIME_INTS       \
4913         assert(fmt)
4914 
4915 PERL_CALLCONV SV *
4916 Perl_sv_strftime_tm(pTHX_ SV *fmt, const struct tm *mytm);
4917 #define PERL_ARGS_ASSERT_SV_STRFTIME_TM         \
4918         assert(fmt); assert(mytm)
4919 
4920 PERL_CALLCONV SV *
4921 Perl_sv_string_from_errnum(pTHX_ int errnum, SV *tgtsv);
4922 #define PERL_ARGS_ASSERT_SV_STRING_FROM_ERRNUM
4923 
4924 PERL_CALLCONV bool
4925 Perl_sv_tainted(pTHX_ SV * const sv)
4926         __attribute__warn_unused_result__;
4927 #define PERL_ARGS_ASSERT_SV_TAINTED             \
4928         assert(sv)
4929 
4930 PERL_CALLCONV I32
4931 Perl_sv_true(pTHX_ SV * const sv);
4932 #define PERL_ARGS_ASSERT_SV_TRUE
4933 
4934 PERL_CALLCONV char *
4935 Perl_sv_uni_display(pTHX_ SV *dsv, SV *ssv, STRLEN pvlim, UV flags)
4936         __attribute__warn_unused_result__;
4937 #define PERL_ARGS_ASSERT_SV_UNI_DISPLAY         \
4938         assert(dsv); assert(ssv)
4939 
4940 PERL_CALLCONV int
4941 Perl_sv_unmagic(pTHX_ SV * const sv, const int type);
4942 #define PERL_ARGS_ASSERT_SV_UNMAGIC             \
4943         assert(sv)
4944 
4945 PERL_CALLCONV int
4946 Perl_sv_unmagicext(pTHX_ SV * const sv, const int type, const MGVTBL *vtbl);
4947 #define PERL_ARGS_ASSERT_SV_UNMAGICEXT          \
4948         assert(sv)
4949 
4950 PERL_CALLCONV void
4951 Perl_sv_unref_flags(pTHX_ SV * const ref, const U32 flags);
4952 #define PERL_ARGS_ASSERT_SV_UNREF_FLAGS         \
4953         assert(ref)
4954 
4955 PERL_CALLCONV void
4956 Perl_sv_untaint(pTHX_ SV * const sv);
4957 #define PERL_ARGS_ASSERT_SV_UNTAINT             \
4958         assert(sv)
4959 
4960 PERL_CALLCONV void
4961 Perl_sv_upgrade(pTHX_ SV * const sv, svtype new_type);
4962 #define PERL_ARGS_ASSERT_SV_UPGRADE             \
4963         assert(sv)
4964 
4965 PERL_CALLCONV void
4966 Perl_sv_usepvn_flags(pTHX_ SV * const sv, char *ptr, const STRLEN len, const U32 flags);
4967 #define PERL_ARGS_ASSERT_SV_USEPVN_FLAGS        \
4968         assert(sv)
4969 
4970 PERL_CALLCONV bool
4971 Perl_sv_utf8_decode(pTHX_ SV * const sv);
4972 #define PERL_ARGS_ASSERT_SV_UTF8_DECODE         \
4973         assert(sv)
4974 
4975 PERL_CALLCONV bool
4976 Perl_sv_utf8_downgrade_flags(pTHX_ SV * const sv, const bool fail_ok, const U32 flags);
4977 #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_FLAGS \
4978         assert(sv)
4979 
4980 /* PERL_CALLCONV bool
4981 sv_utf8_downgrade_nomg(pTHX_ SV * const sv, const bool fail_ok); */
4982 
4983 PERL_CALLCONV void
4984 Perl_sv_utf8_encode(pTHX_ SV * const sv);
4985 #define PERL_ARGS_ASSERT_SV_UTF8_ENCODE         \
4986         assert(sv)
4987 
4988 /* PERL_CALLCONV STRLEN
4989 sv_utf8_upgrade_flags(pTHX_ SV * const sv, const I32 flags); */
4990 
4991 PERL_CALLCONV STRLEN
4992 Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV * const sv, const I32 flags, STRLEN extra);
4993 #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW \
4994         assert(sv)
4995 
4996 /* PERL_CALLCONV STRLEN
4997 sv_utf8_upgrade_nomg(pTHX_ SV *sv); */
4998 
4999 PERL_CALLCONV void
5000 Perl_sv_vcatpvf(pTHX_ SV * const sv, const char * const pat, va_list * const args);
5001 #define PERL_ARGS_ASSERT_SV_VCATPVF             \
5002         assert(sv); assert(pat)
5003 
5004 PERL_CALLCONV void
5005 Perl_sv_vcatpvf_mg(pTHX_ SV * const sv, const char * const pat, va_list * const args);
5006 #define PERL_ARGS_ASSERT_SV_VCATPVF_MG          \
5007         assert(sv); assert(pat)
5008 
5009 PERL_CALLCONV void
5010 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);
5011 #define PERL_ARGS_ASSERT_SV_VCATPVFN            \
5012         assert(sv); assert(pat)
5013 
5014 PERL_CALLCONV void
5015 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);
5016 #define PERL_ARGS_ASSERT_SV_VCATPVFN_FLAGS      \
5017         assert(sv); assert(pat)
5018 
5019 PERL_CALLCONV void
5020 Perl_sv_vsetpvf(pTHX_ SV * const sv, const char * const pat, va_list * const args);
5021 #define PERL_ARGS_ASSERT_SV_VSETPVF             \
5022         assert(sv); assert(pat)
5023 
5024 PERL_CALLCONV void
5025 Perl_sv_vsetpvf_mg(pTHX_ SV * const sv, const char * const pat, va_list * const args);
5026 #define PERL_ARGS_ASSERT_SV_VSETPVF_MG          \
5027         assert(sv); assert(pat)
5028 
5029 PERL_CALLCONV void
5030 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);
5031 #define PERL_ARGS_ASSERT_SV_VSETPVFN            \
5032         assert(sv); assert(pat)
5033 
5034 PERL_CALLCONV void
5035 Perl_switch_to_global_locale(pTHX);
5036 #define PERL_ARGS_ASSERT_SWITCH_TO_GLOBAL_LOCALE
5037 
5038 PERL_CALLCONV bool
5039 Perl_sync_locale(pTHX);
5040 #define PERL_ARGS_ASSERT_SYNC_LOCALE
5041 
5042 PERL_CALLCONV void
5043 Perl_sys_init(int *argc, char ***argv);
5044 #define PERL_ARGS_ASSERT_SYS_INIT               \
5045         assert(argc); assert(argv)
5046 
5047 PERL_CALLCONV void
5048 Perl_sys_init3(int *argc, char ***argv, char ***env);
5049 #define PERL_ARGS_ASSERT_SYS_INIT3              \
5050         assert(argc); assert(argv); assert(env)
5051 
5052 PERL_CALLCONV void
5053 Perl_sys_term(void);
5054 #define PERL_ARGS_ASSERT_SYS_TERM
5055 
5056 PERL_CALLCONV void
5057 Perl_taint_env(pTHX);
5058 #define PERL_ARGS_ASSERT_TAINT_ENV
5059 
5060 PERL_CALLCONV void
5061 Perl_taint_proper(pTHX_ const char *f, const char * const s);
5062 #define PERL_ARGS_ASSERT_TAINT_PROPER           \
5063         assert(s)
5064 
5065 PERL_CALLCONV OP *
5066 Perl_tied_method(pTHX_ SV *methname, SV **mark, SV * const sv, const MAGIC * const mg, const U32 flags, U32 argc, ...)
5067         __attribute__visibility__("hidden");
5068 #define PERL_ARGS_ASSERT_TIED_METHOD            \
5069         assert(methname); assert(mark); assert(sv); assert(mg)
5070 
5071 PERL_CALLCONV SSize_t
5072 Perl_tmps_grow_p(pTHX_ SSize_t ix);
5073 #define PERL_ARGS_ASSERT_TMPS_GROW_P
5074 
5075 /* PERL_CALLCONV UV
5076 to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp); */
5077 
5078 PERL_CALLCONV UV
5079 Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp);
5080 #define PERL_ARGS_ASSERT_TO_UNI_LOWER           \
5081         assert(p); assert(lenp)
5082 
5083 PERL_CALLCONV UV
5084 Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp);
5085 #define PERL_ARGS_ASSERT_TO_UNI_TITLE           \
5086         assert(p); assert(lenp)
5087 
5088 PERL_CALLCONV UV
5089 Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp);
5090 #define PERL_ARGS_ASSERT_TO_UNI_UPPER           \
5091         assert(p); assert(lenp)
5092 
5093 PERL_CALLCONV bool
5094 Perl_try_amagic_bin(pTHX_ int method, int flags);
5095 #define PERL_ARGS_ASSERT_TRY_AMAGIC_BIN
5096 
5097 PERL_CALLCONV bool
5098 Perl_try_amagic_un(pTHX_ int method, int flags);
5099 #define PERL_ARGS_ASSERT_TRY_AMAGIC_UN
5100 
5101 PERL_CALLCONV SSize_t
5102 Perl_unpackstring(pTHX_ const char *pat, const char *patend, const char *s, const char *strend, U32 flags);
5103 #define PERL_ARGS_ASSERT_UNPACKSTRING           \
5104         assert(pat); assert(patend); assert(s); assert(strend)
5105 
5106 PERL_CALLCONV void
5107 Perl_unshare_hek(pTHX_ HEK *hek);
5108 #define PERL_ARGS_ASSERT_UNSHARE_HEK
5109 
5110 PERL_CALLCONV void
5111 Perl_unsharepvn(pTHX_ const char *sv, I32 len, U32 hash);
5112 #define PERL_ARGS_ASSERT_UNSHAREPVN
5113 
5114 PERL_CALLCONV SV *
5115 Perl_upg_version(pTHX_ SV *ver, bool qv);
5116 #define PERL_ARGS_ASSERT_UPG_VERSION            \
5117         assert(ver)
5118 
5119 PERL_CALLCONV U8 *
5120 Perl_utf16_to_utf8(pTHX_ U8 *p, U8 *d, Size_t bytelen, Size_t *newlen);
5121 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8          \
5122         assert(p); assert(d); assert(newlen)
5123 
5124 PERL_CALLCONV U8 *
5125 Perl_utf16_to_utf8_base(pTHX_ U8 *p, U8 *d, Size_t bytelen, Size_t *newlen, const bool high, const bool low);
5126 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8_BASE     \
5127         assert(p); assert(d); assert(newlen)
5128 
5129 PERL_CALLCONV U8 *
5130 Perl_utf16_to_utf8_reversed(pTHX_ U8 *p, U8 *d, Size_t bytelen, Size_t *newlen);
5131 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8_REVERSED \
5132         assert(p); assert(d); assert(newlen)
5133 
5134 PERL_CALLCONV STRLEN
5135 Perl_utf8_length(pTHX_ const U8 *s0, const U8 *e)
5136         __attribute__warn_unused_result__;
5137 #define PERL_ARGS_ASSERT_UTF8_LENGTH            \
5138         assert(s0); assert(e)
5139 
5140 PERL_CALLCONV U8 *
5141 Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *lenp);
5142 #define PERL_ARGS_ASSERT_UTF8_TO_BYTES          \
5143         assert(s); assert(lenp)
5144 
5145 PERL_CALLCONV U8 *
5146 Perl_utf8_to_utf16_base(pTHX_ U8 *s, U8 *d, Size_t bytelen, Size_t *newlen, const bool high, const bool low);
5147 #define PERL_ARGS_ASSERT_UTF8_TO_UTF16_BASE     \
5148         assert(s); assert(d); assert(newlen)
5149 
5150 PERL_CALLCONV UV
5151 Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen);
5152 #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF      \
5153         assert(s); assert(send)
5154 
5155 PERL_CALLCONV UV
5156 Perl_utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags);
5157 #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR         \
5158         assert(s)
5159 
5160 PERL_CALLCONV UV
5161 Perl_utf8n_to_uvchr_error(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 *errors);
5162 #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_ERROR   \
5163         assert(s)
5164 
5165 PERL_CALLCONV void
5166 Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
5167         __attribute__visibility__("hidden");
5168 #define PERL_ARGS_ASSERT_UTILIZE                \
5169         assert(idop)
5170 
5171 /* PERL_CALLCONV U8 *
5172 uvchr_to_utf8(pTHX_ U8 *d, UV uv); */
5173 
5174 /* PERL_CALLCONV U8 *
5175 uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); */
5176 
5177 /* PERL_CALLCONV U8 *
5178 uvchr_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs); */
5179 
5180 PERL_CALLCONV U8 *
5181 Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags);
5182 #define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS \
5183         assert(d)
5184 
5185 PERL_CALLCONV U8 *
5186 Perl_uvoffuni_to_utf8_flags_msgs(pTHX_ U8 *d, UV input_uv, const UV flags, HV **msgs);
5187 #define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS_MSGS \
5188         assert(d)
5189 
5190 PERL_CALLCONV bool
5191 Perl_validate_proto(pTHX_ SV *name, SV *proto, bool warn, bool curstash);
5192 #define PERL_ARGS_ASSERT_VALIDATE_PROTO         \
5193         assert(name)
5194 
5195 PERL_CALLCONV int
5196 Perl_vcmp(pTHX_ SV *lhv, SV *rhv);
5197 #define PERL_ARGS_ASSERT_VCMP                   \
5198         assert(lhv); assert(rhv)
5199 
5200 PERL_CALLCONV_NO_RET void
5201 Perl_vcroak(pTHX_ const char *pat, va_list *args)
5202         __attribute__noreturn__;
5203 #define PERL_ARGS_ASSERT_VCROAK
5204 
5205 PERL_CALLCONV void
5206 Perl_vdeb(pTHX_ const char *pat, va_list *args);
5207 #define PERL_ARGS_ASSERT_VDEB                   \
5208         assert(pat)
5209 
5210 PERL_CALLCONV void
5211 Perl_vfatal_warner(pTHX_ U32 err, const char *pat, va_list *args);
5212 #define PERL_ARGS_ASSERT_VFATAL_WARNER          \
5213         assert(pat)
5214 
5215 PERL_CALLCONV char *
5216 Perl_vform(pTHX_ const char *pat, va_list *args);
5217 #define PERL_ARGS_ASSERT_VFORM                  \
5218         assert(pat)
5219 
5220 PERL_CALLCONV void
5221 Perl_vivify_defelem(pTHX_ SV *sv);
5222 #define PERL_ARGS_ASSERT_VIVIFY_DEFELEM         \
5223         assert(sv)
5224 
5225 PERL_CALLCONV SV *
5226 Perl_vivify_ref(pTHX_ SV *sv, U32 to_what)
5227         __attribute__warn_unused_result__
5228         __attribute__visibility__("hidden");
5229 #define PERL_ARGS_ASSERT_VIVIFY_REF             \
5230         assert(sv)
5231 
5232 PERL_CALLCONV void
5233 Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args);
5234 #define PERL_ARGS_ASSERT_VLOAD_MODULE           \
5235         assert(name)
5236 
5237 PERL_CALLCONV SV *
5238 Perl_vmess(pTHX_ const char *pat, va_list *args);
5239 #define PERL_ARGS_ASSERT_VMESS                  \
5240         assert(pat)
5241 
5242 PERL_CALLCONV SV *
5243 Perl_vnewSVpvf(pTHX_ const char * const pat, va_list * const args)
5244         __attribute__warn_unused_result__;
5245 #define PERL_ARGS_ASSERT_VNEWSVPVF              \
5246         assert(pat)
5247 
5248 PERL_CALLCONV SV *
5249 Perl_vnormal(pTHX_ SV *vs);
5250 #define PERL_ARGS_ASSERT_VNORMAL                \
5251         assert(vs)
5252 
5253 PERL_CALLCONV SV *
5254 Perl_vnumify(pTHX_ SV *vs);
5255 #define PERL_ARGS_ASSERT_VNUMIFY                \
5256         assert(vs)
5257 
5258 PERL_CALLCONV SV *
5259 Perl_vstringify(pTHX_ SV *vs);
5260 #define PERL_ARGS_ASSERT_VSTRINGIFY             \
5261         assert(vs)
5262 
5263 PERL_CALLCONV SV *
5264 Perl_vverify(pTHX_ SV *vs);
5265 #define PERL_ARGS_ASSERT_VVERIFY                \
5266         assert(vs)
5267 
5268 PERL_CALLCONV void
5269 Perl_vwarn(pTHX_ const char *pat, va_list *args);
5270 #define PERL_ARGS_ASSERT_VWARN                  \
5271         assert(pat)
5272 
5273 PERL_CALLCONV void
5274 Perl_vwarner(pTHX_ U32 err, const char *pat, va_list *args);
5275 #define PERL_ARGS_ASSERT_VWARNER                \
5276         assert(pat)
5277 
5278 PERL_CALLCONV I32
5279 Perl_wait4pid(pTHX_ Pid_t pid, int *statusp, int flags)
5280         __attribute__visibility__("hidden");
5281 #define PERL_ARGS_ASSERT_WAIT4PID               \
5282         assert(statusp)
5283 
5284 PERL_CALLCONV void
5285 Perl_warn(pTHX_ const char *pat, ...)
5286         __attribute__format__(__printf__,pTHX_1,pTHX_2);
5287 #define PERL_ARGS_ASSERT_WARN                   \
5288         assert(pat)
5289 
5290 PERL_CALLCONV void
5291 Perl_warn_sv(pTHX_ SV *baseex);
5292 #define PERL_ARGS_ASSERT_WARN_SV                \
5293         assert(baseex)
5294 
5295 PERL_CALLCONV void
5296 Perl_warner(pTHX_ U32 err, const char *pat, ...)
5297         __attribute__format__(__printf__,pTHX_2,pTHX_3);
5298 #define PERL_ARGS_ASSERT_WARNER                 \
5299         assert(pat)
5300 
5301 PERL_CALLCONV I32
5302 Perl_was_lvalue_sub(pTHX)
5303         __attribute__warn_unused_result__;
5304 #define PERL_ARGS_ASSERT_WAS_LVALUE_SUB
5305 
5306 PERL_CALLCONV void
5307 Perl_watch(pTHX_ char **addr)
5308         __attribute__visibility__("hidden");
5309 #define PERL_ARGS_ASSERT_WATCH                  \
5310         assert(addr)
5311 
5312 /* PERL_CALLCONV I32
5313 whichsig(pTHX_ const char *sig); */
5314 
5315 PERL_CALLCONV I32
5316 Perl_whichsig_pv(pTHX_ const char *sig);
5317 #define PERL_ARGS_ASSERT_WHICHSIG_PV            \
5318         assert(sig)
5319 
5320 PERL_CALLCONV I32
5321 Perl_whichsig_pvn(pTHX_ const char *sig, STRLEN len);
5322 #define PERL_ARGS_ASSERT_WHICHSIG_PVN           \
5323         assert(sig)
5324 
5325 PERL_CALLCONV I32
5326 Perl_whichsig_sv(pTHX_ SV *sigsv);
5327 #define PERL_ARGS_ASSERT_WHICHSIG_SV            \
5328         assert(sigsv)
5329 
5330 PERL_CALLCONV void
5331 Perl_wrap_infix_plugin(pTHX_ Perl_infix_plugin_t new_plugin, Perl_infix_plugin_t *old_plugin_p);
5332 #define PERL_ARGS_ASSERT_WRAP_INFIX_PLUGIN      \
5333         assert(new_plugin); assert(old_plugin_p)
5334 
5335 PERL_CALLCONV void
5336 Perl_wrap_keyword_plugin(pTHX_ Perl_keyword_plugin_t new_plugin, Perl_keyword_plugin_t *old_plugin_p);
5337 #define PERL_ARGS_ASSERT_WRAP_KEYWORD_PLUGIN    \
5338         assert(new_plugin); assert(old_plugin_p)
5339 
5340 PERL_CALLCONV void
5341 Perl_wrap_op_checker(pTHX_ Optype opcode, Perl_check_t new_checker, Perl_check_t *old_checker_p);
5342 #define PERL_ARGS_ASSERT_WRAP_OP_CHECKER        \
5343         assert(new_checker); assert(old_checker_p)
5344 
5345 PERL_CALLCONV void
5346 Perl_write_to_stderr(pTHX_ SV *msv)
5347         __attribute__visibility__("hidden");
5348 #define PERL_ARGS_ASSERT_WRITE_TO_STDERR        \
5349         assert(msv)
5350 
5351 PERL_CALLCONV void
5352 Perl_xs_boot_epilog(pTHX_ const SSize_t ax);
5353 #define PERL_ARGS_ASSERT_XS_BOOT_EPILOG
5354 
5355 PERL_CALLCONV Stack_off_t
5356 Perl_xs_handshake(const U32 key, void *v_my_perl, const char *file, ...);
5357 #define PERL_ARGS_ASSERT_XS_HANDSHAKE           \
5358         assert(v_my_perl); assert(file)
5359 
5360 PERL_CALLCONV int
5361 Perl_yyerror(pTHX_ const char * const s)
5362         __attribute__visibility__("hidden");
5363 #define PERL_ARGS_ASSERT_YYERROR                \
5364         assert(s)
5365 
5366 PERL_CALLCONV int
5367 Perl_yyerror_pv(pTHX_ const char * const s, U32 flags)
5368         __attribute__visibility__("hidden");
5369 #define PERL_ARGS_ASSERT_YYERROR_PV             \
5370         assert(s)
5371 
5372 PERL_CALLCONV int
5373 Perl_yyerror_pvn(pTHX_ const char * const s, STRLEN len, U32 flags)
5374         __attribute__visibility__("hidden");
5375 #define PERL_ARGS_ASSERT_YYERROR_PVN
5376 
5377 PERL_CALLCONV int
5378 Perl_yylex(pTHX);
5379 #define PERL_ARGS_ASSERT_YYLEX
5380 
5381 PERL_CALLCONV int
5382 Perl_yyparse(pTHX_ int gramtype)
5383         __attribute__visibility__("hidden");
5384 #define PERL_ARGS_ASSERT_YYPARSE
5385 
5386 PERL_CALLCONV void
5387 Perl_yyquit(pTHX)
5388         __attribute__visibility__("hidden");
5389 #define PERL_ARGS_ASSERT_YYQUIT
5390 
5391 PERL_CALLCONV void
5392 Perl_yyunlex(pTHX)
5393         __attribute__visibility__("hidden");
5394 #define PERL_ARGS_ASSERT_YYUNLEX
5395 
5396 #if defined(DEBUGGING)
5397 PERL_CALLCONV int
5398 Perl_get_debug_opts(pTHX_ const char **s, bool givehelp)
5399         __attribute__warn_unused_result__
5400         __attribute__visibility__("hidden");
5401 # define PERL_ARGS_ASSERT_GET_DEBUG_OPTS        \
5402         assert(s)
5403 
5404 PERL_CALLCONV void
5405 Perl_hv_assert(pTHX_ HV *hv);
5406 # define PERL_ARGS_ASSERT_HV_ASSERT             \
5407         assert(hv)
5408 
5409 PERL_CALLCONV void
5410 Perl_pad_setsv(pTHX_ PADOFFSET po, SV *sv);
5411 # define PERL_ARGS_ASSERT_PAD_SETSV             \
5412         assert(sv)
5413 
5414 PERL_CALLCONV SV *
5415 Perl_pad_sv(pTHX_ PADOFFSET po);
5416 # define PERL_ARGS_ASSERT_PAD_SV
5417 
5418 PERL_CALLCONV void
5419 Perl_set_padlist(CV *cv, PADLIST *padlist);
5420 # define PERL_ARGS_ASSERT_SET_PADLIST           \
5421         assert(cv)
5422 
5423 #endif /* defined(DEBUGGING) */
5424 #if defined(DEBUG_LEAKING_SCALARS_FORK_DUMP)
5425 PERL_CALLCONV void
5426 Perl_dump_sv_child(pTHX_ SV *sv)
5427         __attribute__visibility__("hidden");
5428 # define PERL_ARGS_ASSERT_DUMP_SV_CHILD         \
5429         assert(sv)
5430 
5431 #endif
5432 #if !defined(EBCDIC)
5433 
5434 # if !defined(PERL_NO_INLINE_FUNCTIONS)
5435 PERL_STATIC_INLINE unsigned int
5436 Perl_variant_byte_number(PERL_UINTMAX_T word)
5437         __attribute__warn_unused_result__;
5438 #   define PERL_ARGS_ASSERT_VARIANT_BYTE_NUMBER
5439 
5440 # endif
5441 #endif
5442 #if defined(F_FREESP) && !defined(HAS_CHSIZE) && !defined(HAS_TRUNCATE)
5443 PERL_CALLCONV I32
5444 Perl_my_chsize(pTHX_ int fd, Off_t length)
5445         __attribute__warn_unused_result__;
5446 # define PERL_ARGS_ASSERT_MY_CHSIZE
5447 
5448 #endif
5449 #if !defined(HAS_GETENV_LEN)
5450 PERL_CALLCONV char *
5451 Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len)
5452         __attribute__visibility__("hidden");
5453 # define PERL_ARGS_ASSERT_GETENV_LEN            \
5454         assert(env_elem); assert(len)
5455 
5456 #endif
5457 #if !defined(HAS_MKOSTEMP)
5458 PERL_CALLCONV int
5459 Perl_my_mkostemp(char *templte, int flags)
5460         __attribute__visibility__("hidden");
5461 # define PERL_ARGS_ASSERT_MY_MKOSTEMP           \
5462         assert(templte)
5463 
5464 #endif
5465 #if !defined(HAS_MKSTEMP)
5466 PERL_CALLCONV int
5467 Perl_my_mkstemp(char *templte)
5468         __attribute__visibility__("hidden");
5469 # define PERL_ARGS_ASSERT_MY_MKSTEMP            \
5470         assert(templte)
5471 
5472 #endif
5473 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
5474 PERL_CALLCONV I32
5475 Perl_do_ipcctl(pTHX_ I32 optype, SV **mark, SV **sp)
5476         __attribute__visibility__("hidden");
5477 # define PERL_ARGS_ASSERT_DO_IPCCTL             \
5478         assert(mark); assert(sp)
5479 
5480 PERL_CALLCONV I32
5481 Perl_do_ipcget(pTHX_ I32 optype, SV **mark, SV **sp)
5482         __attribute__visibility__("hidden");
5483 # define PERL_ARGS_ASSERT_DO_IPCGET             \
5484         assert(mark); assert(sp)
5485 
5486 PERL_CALLCONV SSize_t
5487 Perl_do_msgrcv(pTHX_ SV **mark, SV **sp)
5488         __attribute__visibility__("hidden");
5489 # define PERL_ARGS_ASSERT_DO_MSGRCV             \
5490         assert(mark); assert(sp)
5491 
5492 PERL_CALLCONV I32
5493 Perl_do_msgsnd(pTHX_ SV **mark, SV **sp)
5494         __attribute__visibility__("hidden");
5495 # define PERL_ARGS_ASSERT_DO_MSGSND             \
5496         assert(mark); assert(sp)
5497 
5498 PERL_CALLCONV I32
5499 Perl_do_semop(pTHX_ SV **mark, SV **sp)
5500         __attribute__visibility__("hidden");
5501 # define PERL_ARGS_ASSERT_DO_SEMOP              \
5502         assert(mark); assert(sp)
5503 
5504 PERL_CALLCONV I32
5505 Perl_do_shmio(pTHX_ I32 optype, SV **mark, SV **sp)
5506         __attribute__visibility__("hidden");
5507 # define PERL_ARGS_ASSERT_DO_SHMIO              \
5508         assert(mark); assert(sp)
5509 
5510 #endif /* defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) */
5511 #if defined(HAS_PIPE)
5512 PERL_CALLCONV int
5513 Perl_PerlProc_pipe_cloexec(pTHX_ int *pipefd)
5514         __attribute__warn_unused_result__
5515         __attribute__visibility__("hidden");
5516 # define PERL_ARGS_ASSERT_PERLPROC_PIPE_CLOEXEC \
5517         assert(pipefd)
5518 
5519 #endif
5520 #if !defined(HAS_RENAME)
5521 PERL_CALLCONV I32
5522 Perl_same_dirent(pTHX_ const char *a, const char *b)
5523         __attribute__visibility__("hidden");
5524 # define PERL_ARGS_ASSERT_SAME_DIRENT           \
5525         assert(a); assert(b)
5526 
5527 #endif
5528 #if !defined(HAS_SIGNBIT)
5529 PERL_CALLCONV int
5530 Perl_signbit(NV f)
5531         __attribute__warn_unused_result__
5532         __attribute__pure__;
5533 # define PERL_ARGS_ASSERT_PERL_SIGNBIT
5534 
5535 #endif
5536 #if defined(HAS_SOCKET)
5537 PERL_CALLCONV int
5538 Perl_PerlSock_accept_cloexec(pTHX_ int listenfd, struct sockaddr *addr, Sock_size_t *addrlen)
5539         __attribute__warn_unused_result__
5540         __attribute__visibility__("hidden");
5541 # define PERL_ARGS_ASSERT_PERLSOCK_ACCEPT_CLOEXEC
5542 
5543 PERL_CALLCONV int
5544 Perl_PerlSock_socket_cloexec(pTHX_ int domain, int type, int protocol)
5545         __attribute__warn_unused_result__
5546         __attribute__visibility__("hidden");
5547 # define PERL_ARGS_ASSERT_PERLSOCK_SOCKET_CLOEXEC
5548 
5549 #endif /* defined(HAS_SOCKET) */
5550 #if   defined(HAS_SOCKETPAIR) ||                                     \
5551     ( defined(AF_INET) && defined(HAS_SOCKET) && defined(PF_INET) && \
5552       defined(SOCK_DGRAM) )
5553 PERL_CALLCONV int
5554 Perl_PerlSock_socketpair_cloexec(pTHX_ int domain, int type, int protocol, int *pairfd)
5555         __attribute__warn_unused_result__
5556         __attribute__visibility__("hidden");
5557 # define PERL_ARGS_ASSERT_PERLSOCK_SOCKETPAIR_CLOEXEC \
5558         assert(pairfd)
5559 
5560 #endif
5561 #if !defined(HAS_STRLCPY)
5562 STATIC Size_t
5563 Perl_my_strlcpy(char *dst, const char *src, Size_t size);
5564 # define PERL_ARGS_ASSERT_MY_STRLCPY
5565 
5566 #endif
5567 #if defined(HAVE_INTERP_INTERN)
5568 PERL_CALLCONV void
5569 Perl_sys_intern_clear(pTHX);
5570 # define PERL_ARGS_ASSERT_SYS_INTERN_CLEAR
5571 
5572 PERL_CALLCONV void
5573 Perl_sys_intern_init(pTHX);
5574 # define PERL_ARGS_ASSERT_SYS_INTERN_INIT
5575 
5576 # if defined(USE_ITHREADS)
5577 PERL_CALLCONV void
5578 Perl_sys_intern_dup(pTHX_ struct interp_intern *src, struct interp_intern *dst);
5579 #   define PERL_ARGS_ASSERT_SYS_INTERN_DUP      \
5580         assert(src); assert(dst)
5581 
5582 # endif
5583 #endif /* defined(HAVE_INTERP_INTERN) */
5584 #if defined(_MSC_VER)
5585 PERL_CALLCONV int
5586 Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg)
5587         __attribute__visibility__("hidden");
5588 # define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET    \
5589         assert(sv); assert(mg)
5590 
5591 #else
5592 PERL_CALLCONV_NO_RET int
5593 Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg)
5594         __attribute__noreturn__
5595         __attribute__visibility__("hidden");
5596 # define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET    \
5597         assert(sv); assert(mg)
5598 
5599 #endif
5600 #if defined(MULTIPLICITY)
5601 PERL_CALLCONV_NO_RET void
5602 Perl_croak_nocontext(const char *pat, ...)
5603         __attribute__noreturn__
5604         __attribute__format__null_ok__(__printf__,1,2);
5605 # define PERL_ARGS_ASSERT_CROAK_NOCONTEXT
5606 
5607 PERL_CALLCONV void
5608 Perl_deb_nocontext(const char *pat, ...)
5609         __attribute__format__(__printf__,1,2);
5610 # define PERL_ARGS_ASSERT_DEB_NOCONTEXT         \
5611         assert(pat)
5612 
5613 PERL_CALLCONV_NO_RET OP *
5614 Perl_die_nocontext(const char *pat, ...)
5615         __attribute__noreturn__
5616         __attribute__format__null_ok__(__printf__,1,2);
5617 # define PERL_ARGS_ASSERT_DIE_NOCONTEXT
5618 
5619 PERL_CALLCONV char *
5620 Perl_form_nocontext(const char *pat, ...)
5621         __attribute__format__(__printf__,1,2);
5622 # define PERL_ARGS_ASSERT_FORM_NOCONTEXT        \
5623         assert(pat)
5624 
5625 PERL_CALLCONV void
5626 Perl_load_module_nocontext(U32 flags, SV *name, SV *ver, ...);
5627 # define PERL_ARGS_ASSERT_LOAD_MODULE_NOCONTEXT \
5628         assert(name)
5629 
5630 PERL_CALLCONV SV *
5631 Perl_mess_nocontext(const char *pat, ...)
5632         __attribute__format__(__printf__,1,2);
5633 # define PERL_ARGS_ASSERT_MESS_NOCONTEXT        \
5634         assert(pat)
5635 
5636 PERL_CALLCONV void *
5637 Perl_my_cxt_init(pTHX_ int *indexp, size_t size);
5638 # define PERL_ARGS_ASSERT_MY_CXT_INIT           \
5639         assert(indexp)
5640 
5641 PERL_CALLCONV SV *
5642 Perl_newSVpvf_nocontext(const char * const pat, ...)
5643         __attribute__format__(__printf__,1,2);
5644 # define PERL_ARGS_ASSERT_NEWSVPVF_NOCONTEXT    \
5645         assert(pat)
5646 
5647 PERL_CALLCONV void
5648 Perl_sv_catpvf_mg_nocontext(SV * const sv, const char * const pat, ...)
5649         __attribute__format__(__printf__,2,3);
5650 # define PERL_ARGS_ASSERT_SV_CATPVF_MG_NOCONTEXT \
5651         assert(sv); assert(pat)
5652 
5653 PERL_CALLCONV void
5654 Perl_sv_catpvf_nocontext(SV * const sv, const char * const pat, ...)
5655         __attribute__format__(__printf__,2,3);
5656 # define PERL_ARGS_ASSERT_SV_CATPVF_NOCONTEXT   \
5657         assert(sv); assert(pat)
5658 
5659 PERL_CALLCONV void
5660 Perl_sv_setpvf_mg_nocontext(SV * const sv, const char * const pat, ...)
5661         __attribute__format__(__printf__,2,3);
5662 # define PERL_ARGS_ASSERT_SV_SETPVF_MG_NOCONTEXT \
5663         assert(sv); assert(pat)
5664 
5665 PERL_CALLCONV void
5666 Perl_sv_setpvf_nocontext(SV * const sv, const char * const pat, ...)
5667         __attribute__format__(__printf__,2,3);
5668 # define PERL_ARGS_ASSERT_SV_SETPVF_NOCONTEXT   \
5669         assert(sv); assert(pat)
5670 
5671 PERL_CALLCONV void
5672 Perl_warn_nocontext(const char *pat, ...)
5673         __attribute__format__(__printf__,1,2);
5674 # define PERL_ARGS_ASSERT_WARN_NOCONTEXT        \
5675         assert(pat)
5676 
5677 PERL_CALLCONV void
5678 Perl_warner_nocontext(U32 err, const char *pat, ...)
5679         __attribute__format__(__printf__,2,3);
5680 # define PERL_ARGS_ASSERT_WARNER_NOCONTEXT      \
5681         assert(pat)
5682 
5683 #endif /* defined(MULTIPLICITY) */
5684 #if defined(MYMALLOC)
5685 PERL_CALLCONV void
5686 Perl_dump_mstats(pTHX_ const char *s);
5687 # define PERL_ARGS_ASSERT_DUMP_MSTATS           \
5688         assert(s)
5689 
5690 PERL_CALLCONV int
5691 Perl_get_mstats(pTHX_ perl_mstats_t *buf, int buflen, int level);
5692 # define PERL_ARGS_ASSERT_GET_MSTATS            \
5693         assert(buf)
5694 
5695 PERL_CALLCONV MEM_SIZE
5696 Perl_malloc_good_size(size_t nbytes)
5697         __attribute__warn_unused_result__
5698         __attribute__visibility__("hidden");
5699 # define PERL_ARGS_ASSERT_MALLOC_GOOD_SIZE
5700 
5701 PERL_CALLCONV MEM_SIZE
5702 Perl_malloced_size(void *p)
5703         __attribute__warn_unused_result__
5704         __attribute__visibility__("hidden");
5705 # define PERL_ARGS_ASSERT_MALLOCED_SIZE         \
5706         assert(p)
5707 
5708 #endif /* defined(MYMALLOC) */
5709 #if !defined(NO_MATHOMS)
5710 PERL_CALLCONV bool
5711 Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp);
5712 # define PERL_ARGS_ASSERT_DO_AEXEC              \
5713         assert(mark); assert(sp)
5714 
5715 PERL_CALLCONV bool
5716 Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp);
5717 # define PERL_ARGS_ASSERT_DO_OPEN               \
5718         assert(gv); assert(name)
5719 
5720 PERL_CALLCONV GV *
5721 Perl_gv_AVadd(pTHX_ GV *gv);
5722 # define PERL_ARGS_ASSERT_GV_AVADD
5723 
5724 PERL_CALLCONV GV *
5725 Perl_gv_HVadd(pTHX_ GV *gv);
5726 # define PERL_ARGS_ASSERT_GV_HVADD
5727 
5728 PERL_CALLCONV GV *
5729 Perl_gv_IOadd(pTHX_ GV *gv);
5730 # define PERL_ARGS_ASSERT_GV_IOADD
5731 
5732 PERL_CALLCONV void
5733 Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix);
5734 # define PERL_ARGS_ASSERT_GV_EFULLNAME3         \
5735         assert(sv); assert(gv)
5736 
5737 PERL_CALLCONV GV *
5738 Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name);
5739 # define PERL_ARGS_ASSERT_GV_FETCHMETHOD        \
5740         assert(stash); assert(name)
5741 
5742 PERL_CALLCONV void
5743 Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix);
5744 # define PERL_ARGS_ASSERT_GV_FULLNAME3          \
5745         assert(sv); assert(gv)
5746 
5747 PERL_CALLCONV SV *
5748 Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags);
5749 # define PERL_ARGS_ASSERT_HV_DELETE             \
5750         assert(key)
5751 
5752 PERL_CALLCONV SV *
5753 Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash);
5754 # define PERL_ARGS_ASSERT_HV_DELETE_ENT         \
5755         assert(keysv)
5756 
5757 PERL_CALLCONV bool
5758 Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen)
5759         __attribute__warn_unused_result__;
5760 # define PERL_ARGS_ASSERT_HV_EXISTS             \
5761         assert(key)
5762 
5763 PERL_CALLCONV bool
5764 Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash)
5765         __attribute__warn_unused_result__;
5766 # define PERL_ARGS_ASSERT_HV_EXISTS_ENT         \
5767         assert(keysv)
5768 
5769 PERL_CALLCONV SV **
5770 Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval);
5771 # define PERL_ARGS_ASSERT_HV_FETCH              \
5772         assert(key)
5773 
5774 PERL_CALLCONV HE *
5775 Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash);
5776 # define PERL_ARGS_ASSERT_HV_FETCH_ENT          \
5777         assert(keysv)
5778 
5779 PERL_CALLCONV HE *
5780 Perl_hv_iternext(pTHX_ HV *hv)
5781         __attribute__warn_unused_result__;
5782 # define PERL_ARGS_ASSERT_HV_ITERNEXT           \
5783         assert(hv)
5784 
5785 PERL_CALLCONV void
5786 Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how);
5787 # define PERL_ARGS_ASSERT_HV_MAGIC              \
5788         assert(hv)
5789 
5790 PERL_CALLCONV SV **
5791 Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash);
5792 # define PERL_ARGS_ASSERT_HV_STORE
5793 
5794 PERL_CALLCONV HE *
5795 Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash);
5796 # define PERL_ARGS_ASSERT_HV_STORE_ENT
5797 
5798 PERL_CALLCONV SV **
5799 Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags);
5800 # define PERL_ARGS_ASSERT_HV_STORE_FLAGS
5801 
5802 PERL_CALLCONV char *
5803 Perl_instr(const char *big, const char *little)
5804         __attribute__warn_unused_result__
5805         __attribute__pure__;
5806 # define PERL_ARGS_ASSERT_INSTR                 \
5807         assert(big); assert(little)
5808 
5809 PERL_CALLCONV STRLEN
5810 Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end);
5811 # define PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF      \
5812         assert(buf); assert(buf_end)
5813 
5814 PERL_CALLCONV bool
5815 Perl_is_utf8_string_loc(const U8 *s, const STRLEN len, const U8 **ep);
5816 # define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC    \
5817         assert(s); assert(ep)
5818 
5819 PERL_CALLCONV AV *
5820 Perl_newAV(pTHX)
5821         __attribute__warn_unused_result__;
5822 # define PERL_ARGS_ASSERT_NEWAV
5823 
5824 PERL_CALLCONV HV *
5825 Perl_newHV(pTHX)
5826         __attribute__warn_unused_result__;
5827 # define PERL_ARGS_ASSERT_NEWHV
5828 
5829 PERL_CALLCONV IO *
5830 Perl_newIO(pTHX)
5831         __attribute__warn_unused_result__;
5832 # define PERL_ARGS_ASSERT_NEWIO
5833 
5834 PERL_CALLCONV CV *
5835 Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block);
5836 # define PERL_ARGS_ASSERT_NEWSUB
5837 
5838 PERL_CALLCONV SV *
5839 Perl_newSVsv(pTHX_ SV * const old)
5840         __attribute__warn_unused_result__;
5841 # define PERL_ARGS_ASSERT_NEWSVSV
5842 
5843 PERL_CALLCONV void
5844 Perl_save_freeop(pTHX_ OP *o);
5845 # define PERL_ARGS_ASSERT_SAVE_FREEOP
5846 
5847 PERL_CALLCONV void
5848 Perl_save_freepv(pTHX_ char *pv);
5849 # define PERL_ARGS_ASSERT_SAVE_FREEPV
5850 
5851 PERL_CALLCONV void
5852 Perl_save_freesv(pTHX_ SV *sv);
5853 # define PERL_ARGS_ASSERT_SAVE_FREESV
5854 
5855 PERL_CALLCONV void
5856 Perl_save_mortalizesv(pTHX_ SV *sv);
5857 # define PERL_ARGS_ASSERT_SAVE_MORTALIZESV      \
5858         assert(sv)
5859 
5860 PERL_CALLCONV void
5861 Perl_save_op(pTHX);
5862 # define PERL_ARGS_ASSERT_SAVE_OP
5863 
5864 PERL_CALLCONV bool
5865 Perl_sv_2bool(pTHX_ SV * const sv);
5866 # define PERL_ARGS_ASSERT_SV_2BOOL              \
5867         assert(sv)
5868 
5869 PERL_CALLCONV IV
5870 Perl_sv_2iv(pTHX_ SV *sv);
5871 # define PERL_ARGS_ASSERT_SV_2IV                \
5872         assert(sv)
5873 
5874 PERL_CALLCONV char *
5875 Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp);
5876 # define PERL_ARGS_ASSERT_SV_2PV                \
5877         assert(sv)
5878 
5879 PERL_CALLCONV char *
5880 Perl_sv_2pv_nolen(pTHX_ SV *sv)
5881         __attribute__warn_unused_result__;
5882 # define PERL_ARGS_ASSERT_SV_2PV_NOLEN          \
5883         assert(sv)
5884 
5885 PERL_CALLCONV char *
5886 Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN * const lp);
5887 # define PERL_ARGS_ASSERT_SV_2PVBYTE            \
5888         assert(sv)
5889 
5890 PERL_CALLCONV char *
5891 Perl_sv_2pvbyte_nolen(pTHX_ SV *sv)
5892         __attribute__warn_unused_result__;
5893 # define PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN      \
5894         assert(sv)
5895 
5896 PERL_CALLCONV char *
5897 Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN * const lp);
5898 # define PERL_ARGS_ASSERT_SV_2PVUTF8            \
5899         assert(sv)
5900 
5901 PERL_CALLCONV char *
5902 Perl_sv_2pvutf8_nolen(pTHX_ SV *sv)
5903         __attribute__warn_unused_result__;
5904 # define PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN      \
5905         assert(sv)
5906 
5907 PERL_CALLCONV UV
5908 Perl_sv_2uv(pTHX_ SV *sv);
5909 # define PERL_ARGS_ASSERT_SV_2UV                \
5910         assert(sv)
5911 
5912 PERL_CALLCONV void
5913 Perl_sv_catpvn(pTHX_ SV *dsv, const char *sstr, STRLEN len);
5914 # define PERL_ARGS_ASSERT_SV_CATPVN             \
5915         assert(dsv); assert(sstr)
5916 
5917 PERL_CALLCONV void
5918 Perl_sv_catpvn_mg(pTHX_ SV *dsv, const char *sstr, STRLEN len);
5919 # define PERL_ARGS_ASSERT_SV_CATPVN_MG          \
5920         assert(dsv); assert(sstr)
5921 
5922 PERL_CALLCONV void
5923 Perl_sv_catsv(pTHX_ SV *dsv, SV *sstr);
5924 # define PERL_ARGS_ASSERT_SV_CATSV              \
5925         assert(dsv)
5926 
5927 PERL_CALLCONV void
5928 Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *sstr);
5929 # define PERL_ARGS_ASSERT_SV_CATSV_MG           \
5930         assert(dsv)
5931 
5932 PERL_CALLCONV void
5933 Perl_sv_copypv(pTHX_ SV * const dsv, SV * const ssv);
5934 # define PERL_ARGS_ASSERT_SV_COPYPV             \
5935         assert(dsv); assert(ssv)
5936 
5937 PERL_CALLCONV I32
5938 Perl_sv_eq(pTHX_ SV *sv1, SV *sv2);
5939 # define PERL_ARGS_ASSERT_SV_EQ
5940 
5941 PERL_CALLCONV void
5942 Perl_sv_force_normal(pTHX_ SV *sv);
5943 # define PERL_ARGS_ASSERT_SV_FORCE_NORMAL       \
5944         assert(sv)
5945 
5946 PERL_CALLCONV void
5947 Perl_sv_insert(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char * const little, const STRLEN littlelen);
5948 # define PERL_ARGS_ASSERT_SV_INSERT             \
5949         assert(bigstr); assert(little)
5950 
5951 PERL_CALLCONV SV *
5952 Perl_sv_mortalcopy(pTHX_ SV * const oldsv)
5953         __attribute__warn_unused_result__;
5954 # define PERL_ARGS_ASSERT_SV_MORTALCOPY
5955 
5956 PERL_CALLCONV void
5957 Perl_sv_nolocking(pTHX_ SV *sv)
5958         __attribute__deprecated__;
5959 # define PERL_ARGS_ASSERT_SV_NOLOCKING
5960 
5961 PERL_CALLCONV void
5962 Perl_sv_nounlocking(pTHX_ SV *sv)
5963         __attribute__deprecated__;
5964 # define PERL_ARGS_ASSERT_SV_NOUNLOCKING
5965 
5966 PERL_CALLCONV char *
5967 Perl_sv_pv(pTHX_ SV *sv)
5968         __attribute__warn_unused_result__;
5969 # define PERL_ARGS_ASSERT_SV_PV                 \
5970         assert(sv)
5971 
5972 PERL_CALLCONV char *
5973 Perl_sv_pvbyte(pTHX_ SV *sv)
5974         __attribute__warn_unused_result__;
5975 # define PERL_ARGS_ASSERT_SV_PVBYTE             \
5976         assert(sv)
5977 
5978 PERL_CALLCONV char *
5979 Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp);
5980 # define PERL_ARGS_ASSERT_SV_PVN_FORCE          \
5981         assert(sv)
5982 
5983 PERL_CALLCONV char *
5984 Perl_sv_pvutf8(pTHX_ SV *sv)
5985         __attribute__warn_unused_result__;
5986 # define PERL_ARGS_ASSERT_SV_PVUTF8             \
5987         assert(sv)
5988 
5989 PERL_CALLCONV void
5990 Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv);
5991 # define PERL_ARGS_ASSERT_SV_SETSV              \
5992         assert(dsv)
5993 
5994 PERL_CALLCONV void
5995 Perl_sv_taint(pTHX_ SV *sv);
5996 # define PERL_ARGS_ASSERT_SV_TAINT              \
5997         assert(sv)
5998 
5999 PERL_CALLCONV void
6000 Perl_sv_unref(pTHX_ SV *sv);
6001 # define PERL_ARGS_ASSERT_SV_UNREF              \
6002         assert(sv)
6003 
6004 PERL_CALLCONV void
6005 Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len);
6006 # define PERL_ARGS_ASSERT_SV_USEPVN             \
6007         assert(sv)
6008 
6009 PERL_CALLCONV void
6010 Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len);
6011 # define PERL_ARGS_ASSERT_SV_USEPVN_MG          \
6012         assert(sv)
6013 
6014 PERL_CALLCONV bool
6015 Perl_sv_utf8_downgrade(pTHX_ SV * const sv, const bool fail_ok);
6016 # define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE     \
6017         assert(sv)
6018 
6019 PERL_CALLCONV STRLEN
6020 Perl_sv_utf8_upgrade(pTHX_ SV *sv);
6021 # define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE       \
6022         assert(sv)
6023 
6024 PERL_CALLCONV UV
6025 Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen)
6026         __attribute__deprecated__;
6027 # define PERL_ARGS_ASSERT_UTF8_TO_UVCHR         \
6028         assert(s)
6029 
6030 PERL_CALLCONV UV
6031 Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
6032         __attribute__deprecated__;
6033 # define PERL_ARGS_ASSERT_UTF8_TO_UVUNI         \
6034         assert(s)
6035 
6036 PERL_CALLCONV UV
6037 Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)
6038         __attribute__deprecated__;
6039 # define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI        \
6040         assert(s)
6041 
6042 PERL_CALLCONV U8 *
6043 Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv)
6044         __attribute__deprecated__;
6045 # define PERL_ARGS_ASSERT_UVUNI_TO_UTF8         \
6046         assert(d)
6047 
6048 # if defined(PERL_DONT_CREATE_GVSV)
6049 PERL_CALLCONV GV *
6050 Perl_gv_SVadd(pTHX_ GV *gv);
6051 #   define PERL_ARGS_ASSERT_GV_SVADD
6052 
6053 # endif
6054 # if defined(PERL_IN_MATHOMS_C) || defined(PERL_IN_OP_C) || \
6055      defined(PERL_IN_PERLY_C)   || defined(PERL_IN_TOKE_C)
6056 PERL_CALLCONV OP *
6057 Perl_ref(pTHX_ OP *o, I32 type);
6058 #   define PERL_ARGS_ASSERT_REF
6059 
6060 # endif
6061 # if defined(USE_LOCALE_COLLATE)
6062 PERL_CALLCONV char *
6063 Perl_sv_collxfrm(pTHX_ SV * const sv, STRLEN * const nxp);
6064 #   define PERL_ARGS_ASSERT_SV_COLLXFRM         \
6065         assert(sv); assert(nxp)
6066 
6067 # endif
6068 #endif /* !defined(NO_MATHOMS) */
6069 #if defined(PERL_ANY_COW)
6070 PERL_CALLCONV SV *
6071 Perl_sv_setsv_cow(pTHX_ SV *dsv, SV *ssv);
6072 # define PERL_ARGS_ASSERT_SV_SETSV_COW          \
6073         assert(ssv)
6074 
6075 #endif
6076 #if defined(PERL_CORE)
6077 PERL_CALLCONV void
6078 Perl_opslab_force_free(pTHX_ OPSLAB *slab)
6079         __attribute__visibility__("hidden");
6080 # define PERL_ARGS_ASSERT_OPSLAB_FORCE_FREE     \
6081         assert(slab)
6082 
6083 PERL_CALLCONV void
6084 Perl_opslab_free(pTHX_ OPSLAB *slab)
6085         __attribute__visibility__("hidden");
6086 # define PERL_ARGS_ASSERT_OPSLAB_FREE           \
6087         assert(slab)
6088 
6089 PERL_CALLCONV void
6090 Perl_opslab_free_nopad(pTHX_ OPSLAB *slab)
6091         __attribute__visibility__("hidden");
6092 # define PERL_ARGS_ASSERT_OPSLAB_FREE_NOPAD     \
6093         assert(slab)
6094 
6095 PERL_CALLCONV void
6096 Perl_parser_free_nexttoke_ops(pTHX_ yy_parser *parser, OPSLAB *slab)
6097         __attribute__visibility__("hidden");
6098 # define PERL_ARGS_ASSERT_PARSER_FREE_NEXTTOKE_OPS \
6099         assert(parser); assert(slab)
6100 
6101 # if defined(PERL_DEBUG_READONLY_OPS)
6102 PERL_CALLCONV void
6103 Perl_Slab_to_ro(pTHX_ OPSLAB *slab);
6104 #   define PERL_ARGS_ASSERT_SLAB_TO_RO          \
6105         assert(slab)
6106 
6107 PERL_CALLCONV void
6108 Perl_Slab_to_rw(pTHX_ OPSLAB * const slab);
6109 #   define PERL_ARGS_ASSERT_SLAB_TO_RW          \
6110         assert(slab)
6111 
6112 # endif /* defined(PERL_DEBUG_READONLY_OPS) */
6113 # if !defined(PERL_NO_INLINE_FUNCTIONS)
6114 PERL_STATIC_INLINE bool
6115 S_should_warn_nl(const char *pv)
6116         __attribute__warn_unused_result__;
6117 #   define PERL_ARGS_ASSERT_SHOULD_WARN_NL      \
6118         assert(pv)
6119 
6120 # endif
6121 #endif /* defined(PERL_CORE) */
6122 #if defined(PERL_CORE) || defined(PERL_EXT)
6123 PERL_CALLCONV bool
6124 Perl_isSCRIPT_RUN(pTHX_ const U8 *s, const U8 *send, const bool utf8_target)
6125         __attribute__warn_unused_result__;
6126 # define PERL_ARGS_ASSERT_ISSCRIPT_RUN          \
6127         assert(s); assert(send)
6128 
6129 #endif /* defined(PERL_CORE) || defined(PERL_EXT) */
6130 #if defined(PERL_CORE) || defined(PERL_USE_VOLATILE_API)
6131 PERL_CALLCONV void
6132 Perl_finalize_optree(pTHX_ OP *o);
6133 # define PERL_ARGS_ASSERT_FINALIZE_OPTREE       \
6134         assert(o)
6135 
6136 PERL_CALLCONV void
6137 Perl_optimize_optree(pTHX_ OP *o);
6138 # define PERL_ARGS_ASSERT_OPTIMIZE_OPTREE       \
6139         assert(o)
6140 
6141 #endif /* defined(PERL_CORE) || defined(PERL_USE_VOLATILE_API) */
6142 #if defined(PERL_DEBUG_READONLY_COW)
6143 PERL_CALLCONV void
6144 Perl_sv_buf_to_ro(pTHX_ SV *sv)
6145         __attribute__visibility__("hidden");
6146 # define PERL_ARGS_ASSERT_SV_BUF_TO_RO          \
6147         assert(sv)
6148 
6149 #endif
6150 #if defined(PERL_DEBUG_READONLY_OPS)
6151 PERL_CALLCONV PADOFFSET
6152 Perl_op_refcnt_dec(pTHX_ OP *o);
6153 # define PERL_ARGS_ASSERT_OP_REFCNT_DEC         \
6154         assert(o)
6155 
6156 PERL_CALLCONV OP *
6157 Perl_op_refcnt_inc(pTHX_ OP *o);
6158 # define PERL_ARGS_ASSERT_OP_REFCNT_INC
6159 
6160 #endif /* defined(PERL_DEBUG_READONLY_OPS) */
6161 #if defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION)
6162 PERL_CALLCONV bool
6163 Perl_do_exec(pTHX_ const char *cmd)
6164         __attribute__visibility__("hidden");
6165 # define PERL_ARGS_ASSERT_DO_EXEC               \
6166         assert(cmd)
6167 
6168 #else
6169 PERL_CALLCONV bool
6170 Perl_do_exec(pTHX_ const char *cmd)
6171         __attribute__visibility__("hidden");
6172 # define PERL_ARGS_ASSERT_DO_EXEC               \
6173         assert(cmd)
6174 
6175 #endif
6176 #if defined(PERL_IMPLICIT_SYS)
6177 PERL_CALLCONV PerlInterpreter *
6178 perl_alloc_using(struct IPerlMem *ipM, struct IPerlMem *ipMS, struct IPerlMem *ipMP, struct IPerlEnv *ipE, struct IPerlStdIO *ipStd, struct IPerlLIO *ipLIO, struct IPerlDir *ipD, struct IPerlSock *ipS, struct IPerlProc *ipP);
6179 # define PERL_ARGS_ASSERT_PERL_ALLOC_USING      \
6180         assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); \
6181         assert(ipLIO); assert(ipD); assert(ipS); assert(ipP)
6182 
6183 # if defined(USE_ITHREADS)
6184 PERL_CALLCONV PerlInterpreter *
6185 perl_clone_using(PerlInterpreter *proto_perl, UV flags, struct IPerlMem *ipM, struct IPerlMem *ipMS, struct IPerlMem *ipMP, struct IPerlEnv *ipE, struct IPerlStdIO *ipStd, struct IPerlLIO *ipLIO, struct IPerlDir *ipD, struct IPerlSock *ipS, struct IPerlProc *ipP);
6186 #   define PERL_ARGS_ASSERT_PERL_CLONE_USING    \
6187         assert(proto_perl); assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); \
6188         assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP)
6189 
6190 # endif
6191 #else /* if !defined(PERL_IMPLICIT_SYS) */
6192 PERL_CALLCONV I32
6193 Perl_my_pclose(pTHX_ PerlIO *ptr);
6194 # define PERL_ARGS_ASSERT_MY_PCLOSE
6195 
6196 PERL_CALLCONV PerlIO *
6197 Perl_my_popen(pTHX_ const char *cmd, const char *mode);
6198 # define PERL_ARGS_ASSERT_MY_POPEN              \
6199         assert(cmd); assert(mode)
6200 
6201 #endif /* !defined(PERL_IMPLICIT_SYS) */
6202 #if defined(PERL_IN_AV_C)
6203 STATIC MAGIC *
6204 S_get_aux_mg(pTHX_ AV *av);
6205 # define PERL_ARGS_ASSERT_GET_AUX_MG            \
6206         assert(av)
6207 
6208 #endif
6209 #if defined(PERL_IN_BUILTIN_C) || defined(PERL_IN_OP_C)
6210 PERL_CALLCONV void
6211 Perl_finish_export_lexical(pTHX)
6212         __attribute__visibility__("hidden");
6213 # define PERL_ARGS_ASSERT_FINISH_EXPORT_LEXICAL
6214 
6215 PERL_CALLCONV void
6216 Perl_import_builtin_bundle(pTHX_ U16 ver)
6217         __attribute__visibility__("hidden");
6218 # define PERL_ARGS_ASSERT_IMPORT_BUILTIN_BUNDLE
6219 
6220 PERL_CALLCONV void
6221 Perl_prepare_export_lexical(pTHX)
6222         __attribute__visibility__("hidden");
6223 # define PERL_ARGS_ASSERT_PREPARE_EXPORT_LEXICAL
6224 
6225 #endif /* defined(PERL_IN_BUILTIN_C) || defined(PERL_IN_OP_C) */
6226 #if defined(PERL_IN_CLASS_C) || defined(PERL_IN_GLOBALS_C) || \
6227     defined(PERL_IN_OP_C)    || defined(PERL_IN_PEEP_C)
6228 PERL_CALLCONV OP *
6229 Perl_ck_anoncode(pTHX_ OP *o)
6230         __attribute__warn_unused_result__
6231         __attribute__visibility__("hidden");
6232 # define PERL_ARGS_ASSERT_CK_ANONCODE           \
6233         assert(o)
6234 
6235 PERL_CALLCONV OP *
6236 Perl_ck_backtick(pTHX_ OP *o)
6237         __attribute__warn_unused_result__
6238         __attribute__visibility__("hidden");
6239 # define PERL_ARGS_ASSERT_CK_BACKTICK           \
6240         assert(o)
6241 
6242 PERL_CALLCONV OP *
6243 Perl_ck_bitop(pTHX_ OP *o)
6244         __attribute__warn_unused_result__
6245         __attribute__visibility__("hidden");
6246 # define PERL_ARGS_ASSERT_CK_BITOP              \
6247         assert(o)
6248 
6249 PERL_CALLCONV OP *
6250 Perl_ck_classname(pTHX_ OP *o)
6251         __attribute__warn_unused_result__
6252         __attribute__visibility__("hidden");
6253 # define PERL_ARGS_ASSERT_CK_CLASSNAME          \
6254         assert(o)
6255 
6256 PERL_CALLCONV OP *
6257 Perl_ck_cmp(pTHX_ OP *o)
6258         __attribute__warn_unused_result__
6259         __attribute__visibility__("hidden");
6260 # define PERL_ARGS_ASSERT_CK_CMP                \
6261         assert(o)
6262 
6263 PERL_CALLCONV OP *
6264 Perl_ck_concat(pTHX_ OP *o)
6265         __attribute__warn_unused_result__
6266         __attribute__visibility__("hidden");
6267 # define PERL_ARGS_ASSERT_CK_CONCAT             \
6268         assert(o)
6269 
6270 PERL_CALLCONV OP *
6271 Perl_ck_defined(pTHX_ OP *o)
6272         __attribute__warn_unused_result__
6273         __attribute__visibility__("hidden");
6274 # define PERL_ARGS_ASSERT_CK_DEFINED            \
6275         assert(o)
6276 
6277 PERL_CALLCONV OP *
6278 Perl_ck_delete(pTHX_ OP *o)
6279         __attribute__warn_unused_result__
6280         __attribute__visibility__("hidden");
6281 # define PERL_ARGS_ASSERT_CK_DELETE             \
6282         assert(o)
6283 
6284 PERL_CALLCONV OP *
6285 Perl_ck_each(pTHX_ OP *o)
6286         __attribute__warn_unused_result__
6287         __attribute__visibility__("hidden");
6288 # define PERL_ARGS_ASSERT_CK_EACH               \
6289         assert(o)
6290 
6291 PERL_CALLCONV OP *
6292 Perl_ck_eof(pTHX_ OP *o)
6293         __attribute__warn_unused_result__
6294         __attribute__visibility__("hidden");
6295 # define PERL_ARGS_ASSERT_CK_EOF                \
6296         assert(o)
6297 
6298 PERL_CALLCONV OP *
6299 Perl_ck_eval(pTHX_ OP *o)
6300         __attribute__warn_unused_result__
6301         __attribute__visibility__("hidden");
6302 # define PERL_ARGS_ASSERT_CK_EVAL               \
6303         assert(o)
6304 
6305 PERL_CALLCONV OP *
6306 Perl_ck_exec(pTHX_ OP *o)
6307         __attribute__warn_unused_result__
6308         __attribute__visibility__("hidden");
6309 # define PERL_ARGS_ASSERT_CK_EXEC               \
6310         assert(o)
6311 
6312 PERL_CALLCONV OP *
6313 Perl_ck_exists(pTHX_ OP *o)
6314         __attribute__warn_unused_result__
6315         __attribute__visibility__("hidden");
6316 # define PERL_ARGS_ASSERT_CK_EXISTS             \
6317         assert(o)
6318 
6319 PERL_CALLCONV OP *
6320 Perl_ck_ftst(pTHX_ OP *o)
6321         __attribute__warn_unused_result__
6322         __attribute__visibility__("hidden");
6323 # define PERL_ARGS_ASSERT_CK_FTST               \
6324         assert(o)
6325 
6326 PERL_CALLCONV OP *
6327 Perl_ck_fun(pTHX_ OP *o)
6328         __attribute__warn_unused_result__
6329         __attribute__visibility__("hidden");
6330 # define PERL_ARGS_ASSERT_CK_FUN                \
6331         assert(o)
6332 
6333 PERL_CALLCONV OP *
6334 Perl_ck_glob(pTHX_ OP *o)
6335         __attribute__warn_unused_result__
6336         __attribute__visibility__("hidden");
6337 # define PERL_ARGS_ASSERT_CK_GLOB               \
6338         assert(o)
6339 
6340 PERL_CALLCONV OP *
6341 Perl_ck_grep(pTHX_ OP *o)
6342         __attribute__warn_unused_result__
6343         __attribute__visibility__("hidden");
6344 # define PERL_ARGS_ASSERT_CK_GREP               \
6345         assert(o)
6346 
6347 PERL_CALLCONV OP *
6348 Perl_ck_helemexistsor(pTHX_ OP *o)
6349         __attribute__warn_unused_result__
6350         __attribute__visibility__("hidden");
6351 # define PERL_ARGS_ASSERT_CK_HELEMEXISTSOR      \
6352         assert(o)
6353 
6354 PERL_CALLCONV OP *
6355 Perl_ck_index(pTHX_ OP *o)
6356         __attribute__warn_unused_result__
6357         __attribute__visibility__("hidden");
6358 # define PERL_ARGS_ASSERT_CK_INDEX              \
6359         assert(o)
6360 
6361 PERL_CALLCONV OP *
6362 Perl_ck_isa(pTHX_ OP *o)
6363         __attribute__warn_unused_result__
6364         __attribute__visibility__("hidden");
6365 # define PERL_ARGS_ASSERT_CK_ISA                \
6366         assert(o)
6367 
6368 PERL_CALLCONV OP *
6369 Perl_ck_join(pTHX_ OP *o)
6370         __attribute__warn_unused_result__
6371         __attribute__visibility__("hidden");
6372 # define PERL_ARGS_ASSERT_CK_JOIN               \
6373         assert(o)
6374 
6375 PERL_CALLCONV OP *
6376 Perl_ck_length(pTHX_ OP *o)
6377         __attribute__warn_unused_result__
6378         __attribute__visibility__("hidden");
6379 # define PERL_ARGS_ASSERT_CK_LENGTH             \
6380         assert(o)
6381 
6382 PERL_CALLCONV OP *
6383 Perl_ck_lfun(pTHX_ OP *o)
6384         __attribute__warn_unused_result__
6385         __attribute__visibility__("hidden");
6386 # define PERL_ARGS_ASSERT_CK_LFUN               \
6387         assert(o)
6388 
6389 PERL_CALLCONV OP *
6390 Perl_ck_listiob(pTHX_ OP *o)
6391         __attribute__warn_unused_result__
6392         __attribute__visibility__("hidden");
6393 # define PERL_ARGS_ASSERT_CK_LISTIOB            \
6394         assert(o)
6395 
6396 PERL_CALLCONV OP *
6397 Perl_ck_match(pTHX_ OP *o)
6398         __attribute__warn_unused_result__
6399         __attribute__visibility__("hidden");
6400 # define PERL_ARGS_ASSERT_CK_MATCH              \
6401         assert(o)
6402 
6403 PERL_CALLCONV OP *
6404 Perl_ck_method(pTHX_ OP *o)
6405         __attribute__warn_unused_result__
6406         __attribute__visibility__("hidden");
6407 # define PERL_ARGS_ASSERT_CK_METHOD             \
6408         assert(o)
6409 
6410 PERL_CALLCONV OP *
6411 Perl_ck_null(pTHX_ OP *o)
6412         __attribute__warn_unused_result__
6413         __attribute__visibility__("hidden");
6414 # define PERL_ARGS_ASSERT_CK_NULL               \
6415         assert(o)
6416 
6417 PERL_CALLCONV OP *
6418 Perl_ck_open(pTHX_ OP *o)
6419         __attribute__warn_unused_result__
6420         __attribute__visibility__("hidden");
6421 # define PERL_ARGS_ASSERT_CK_OPEN               \
6422         assert(o)
6423 
6424 PERL_CALLCONV OP *
6425 Perl_ck_prototype(pTHX_ OP *o)
6426         __attribute__warn_unused_result__
6427         __attribute__visibility__("hidden");
6428 # define PERL_ARGS_ASSERT_CK_PROTOTYPE          \
6429         assert(o)
6430 
6431 PERL_CALLCONV OP *
6432 Perl_ck_readline(pTHX_ OP *o)
6433         __attribute__warn_unused_result__
6434         __attribute__visibility__("hidden");
6435 # define PERL_ARGS_ASSERT_CK_READLINE           \
6436         assert(o)
6437 
6438 PERL_CALLCONV OP *
6439 Perl_ck_refassign(pTHX_ OP *o)
6440         __attribute__warn_unused_result__
6441         __attribute__visibility__("hidden");
6442 # define PERL_ARGS_ASSERT_CK_REFASSIGN          \
6443         assert(o)
6444 
6445 PERL_CALLCONV OP *
6446 Perl_ck_repeat(pTHX_ OP *o)
6447         __attribute__warn_unused_result__
6448         __attribute__visibility__("hidden");
6449 # define PERL_ARGS_ASSERT_CK_REPEAT             \
6450         assert(o)
6451 
6452 PERL_CALLCONV OP *
6453 Perl_ck_require(pTHX_ OP *o)
6454         __attribute__warn_unused_result__
6455         __attribute__visibility__("hidden");
6456 # define PERL_ARGS_ASSERT_CK_REQUIRE            \
6457         assert(o)
6458 
6459 PERL_CALLCONV OP *
6460 Perl_ck_return(pTHX_ OP *o)
6461         __attribute__warn_unused_result__
6462         __attribute__visibility__("hidden");
6463 # define PERL_ARGS_ASSERT_CK_RETURN             \
6464         assert(o)
6465 
6466 PERL_CALLCONV OP *
6467 Perl_ck_rfun(pTHX_ OP *o)
6468         __attribute__warn_unused_result__
6469         __attribute__visibility__("hidden");
6470 # define PERL_ARGS_ASSERT_CK_RFUN               \
6471         assert(o)
6472 
6473 PERL_CALLCONV OP *
6474 Perl_ck_rvconst(pTHX_ OP *o)
6475         __attribute__warn_unused_result__
6476         __attribute__visibility__("hidden");
6477 # define PERL_ARGS_ASSERT_CK_RVCONST            \
6478         assert(o)
6479 
6480 PERL_CALLCONV OP *
6481 Perl_ck_sassign(pTHX_ OP *o)
6482         __attribute__warn_unused_result__
6483         __attribute__visibility__("hidden");
6484 # define PERL_ARGS_ASSERT_CK_SASSIGN            \
6485         assert(o)
6486 
6487 PERL_CALLCONV OP *
6488 Perl_ck_select(pTHX_ OP *o)
6489         __attribute__warn_unused_result__
6490         __attribute__visibility__("hidden");
6491 # define PERL_ARGS_ASSERT_CK_SELECT             \
6492         assert(o)
6493 
6494 PERL_CALLCONV OP *
6495 Perl_ck_shift(pTHX_ OP *o)
6496         __attribute__warn_unused_result__
6497         __attribute__visibility__("hidden");
6498 # define PERL_ARGS_ASSERT_CK_SHIFT              \
6499         assert(o)
6500 
6501 PERL_CALLCONV OP *
6502 Perl_ck_smartmatch(pTHX_ OP *o)
6503         __attribute__warn_unused_result__
6504         __attribute__visibility__("hidden");
6505 # define PERL_ARGS_ASSERT_CK_SMARTMATCH         \
6506         assert(o)
6507 
6508 PERL_CALLCONV OP *
6509 Perl_ck_sort(pTHX_ OP *o)
6510         __attribute__warn_unused_result__
6511         __attribute__visibility__("hidden");
6512 # define PERL_ARGS_ASSERT_CK_SORT               \
6513         assert(o)
6514 
6515 PERL_CALLCONV OP *
6516 Perl_ck_spair(pTHX_ OP *o)
6517         __attribute__warn_unused_result__
6518         __attribute__visibility__("hidden");
6519 # define PERL_ARGS_ASSERT_CK_SPAIR              \
6520         assert(o)
6521 
6522 PERL_CALLCONV OP *
6523 Perl_ck_split(pTHX_ OP *o)
6524         __attribute__warn_unused_result__
6525         __attribute__visibility__("hidden");
6526 # define PERL_ARGS_ASSERT_CK_SPLIT              \
6527         assert(o)
6528 
6529 PERL_CALLCONV OP *
6530 Perl_ck_stringify(pTHX_ OP *o)
6531         __attribute__warn_unused_result__
6532         __attribute__visibility__("hidden");
6533 # define PERL_ARGS_ASSERT_CK_STRINGIFY          \
6534         assert(o)
6535 
6536 PERL_CALLCONV OP *
6537 Perl_ck_subr(pTHX_ OP *o)
6538         __attribute__warn_unused_result__
6539         __attribute__visibility__("hidden");
6540 # define PERL_ARGS_ASSERT_CK_SUBR               \
6541         assert(o)
6542 
6543 PERL_CALLCONV OP *
6544 Perl_ck_substr(pTHX_ OP *o)
6545         __attribute__warn_unused_result__
6546         __attribute__visibility__("hidden");
6547 # define PERL_ARGS_ASSERT_CK_SUBSTR             \
6548         assert(o)
6549 
6550 PERL_CALLCONV OP *
6551 Perl_ck_svconst(pTHX_ OP *o)
6552         __attribute__warn_unused_result__
6553         __attribute__visibility__("hidden");
6554 # define PERL_ARGS_ASSERT_CK_SVCONST            \
6555         assert(o)
6556 
6557 PERL_CALLCONV OP *
6558 Perl_ck_tell(pTHX_ OP *o)
6559         __attribute__warn_unused_result__
6560         __attribute__visibility__("hidden");
6561 # define PERL_ARGS_ASSERT_CK_TELL               \
6562         assert(o)
6563 
6564 PERL_CALLCONV OP *
6565 Perl_ck_trunc(pTHX_ OP *o)
6566         __attribute__warn_unused_result__
6567         __attribute__visibility__("hidden");
6568 # define PERL_ARGS_ASSERT_CK_TRUNC              \
6569         assert(o)
6570 
6571 PERL_CALLCONV OP *
6572 Perl_ck_trycatch(pTHX_ OP *o)
6573         __attribute__warn_unused_result__
6574         __attribute__visibility__("hidden");
6575 # define PERL_ARGS_ASSERT_CK_TRYCATCH           \
6576         assert(o)
6577 
6578 #endif /* defined(PERL_IN_CLASS_C) || defined(PERL_IN_GLOBALS_C) ||
6579           defined(PERL_IN_OP_C)    || defined(PERL_IN_PEEP_C) */
6580 #if defined(PERL_IN_CLASS_C) || defined(PERL_IN_OP_C)    || \
6581     defined(PERL_IN_PAD_C)   || defined(PERL_IN_PERLY_C) || \
6582     defined(PERL_IN_TOKE_C)
6583 PERL_CALLCONV void
6584 Perl_class_add_ADJUST(pTHX_ HV *stash, CV *cv);
6585 # define PERL_ARGS_ASSERT_CLASS_ADD_ADJUST      \
6586         assert(stash); assert(cv)
6587 
6588 PERL_CALLCONV void
6589 Perl_class_add_field(pTHX_ HV *stash, PADNAME *pn);
6590 # define PERL_ARGS_ASSERT_CLASS_ADD_FIELD       \
6591         assert(stash); assert(pn)
6592 
6593 PERL_CALLCONV void
6594 Perl_class_apply_attributes(pTHX_ HV *stash, OP *attrlist);
6595 # define PERL_ARGS_ASSERT_CLASS_APPLY_ATTRIBUTES \
6596         assert(stash)
6597 
6598 PERL_CALLCONV void
6599 Perl_class_apply_field_attributes(pTHX_ PADNAME *pn, OP *attrlist);
6600 # define PERL_ARGS_ASSERT_CLASS_APPLY_FIELD_ATTRIBUTES \
6601         assert(pn)
6602 
6603 PERL_CALLCONV void
6604 Perl_class_prepare_initfield_parse(pTHX);
6605 # define PERL_ARGS_ASSERT_CLASS_PREPARE_INITFIELD_PARSE
6606 
6607 PERL_CALLCONV void
6608 Perl_class_prepare_method_parse(pTHX_ CV *cv);
6609 # define PERL_ARGS_ASSERT_CLASS_PREPARE_METHOD_PARSE \
6610         assert(cv)
6611 
6612 PERL_CALLCONV void
6613 Perl_class_seal_stash(pTHX_ HV *stash);
6614 # define PERL_ARGS_ASSERT_CLASS_SEAL_STASH      \
6615         assert(stash)
6616 
6617 PERL_CALLCONV void
6618 Perl_class_set_field_defop(pTHX_ PADNAME *pn, OPCODE defmode, OP *defop);
6619 # define PERL_ARGS_ASSERT_CLASS_SET_FIELD_DEFOP \
6620         assert(pn); assert(defop)
6621 
6622 PERL_CALLCONV void
6623 Perl_class_setup_stash(pTHX_ HV *stash);
6624 # define PERL_ARGS_ASSERT_CLASS_SETUP_STASH     \
6625         assert(stash)
6626 
6627 PERL_CALLCONV OP *
6628 Perl_class_wrap_method_body(pTHX_ OP *o);
6629 # define PERL_ARGS_ASSERT_CLASS_WRAP_METHOD_BODY
6630 
6631 PERL_CALLCONV void
6632 Perl_croak_kw_unless_class(pTHX_ const char *kw);
6633 # define PERL_ARGS_ASSERT_CROAK_KW_UNLESS_CLASS \
6634         assert(kw)
6635 
6636 #endif /* defined(PERL_IN_CLASS_C) || defined(PERL_IN_OP_C)    ||
6637           defined(PERL_IN_PAD_C)   || defined(PERL_IN_PERLY_C) ||
6638           defined(PERL_IN_TOKE_C) */
6639 #if defined(PERL_IN_DEB_C)
6640 STATIC void
6641 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);
6642 # define PERL_ARGS_ASSERT_DEB_STACK_N           \
6643         assert(stack_base)
6644 
6645 #endif
6646 #if defined(PERL_IN_DOIO_C)
6647 STATIC bool
6648 S_argvout_final(pTHX_ MAGIC *mg, IO *io, bool is_explicit);
6649 # define PERL_ARGS_ASSERT_ARGVOUT_FINAL         \
6650         assert(mg); assert(io)
6651 
6652 STATIC void
6653 S_exec_failed(pTHX_ const char *cmd, int fd, int do_report);
6654 # define PERL_ARGS_ASSERT_EXEC_FAILED           \
6655         assert(cmd)
6656 
6657 STATIC bool
6658 S_is_fork_open(const char *name);
6659 # define PERL_ARGS_ASSERT_IS_FORK_OPEN          \
6660         assert(name)
6661 
6662 STATIC bool
6663 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);
6664 # define PERL_ARGS_ASSERT_OPENN_CLEANUP         \
6665         assert(gv); assert(io); assert(mode); assert(oname)
6666 
6667 STATIC IO *
6668 S_openn_setup(pTHX_ GV *gv, char *mode, PerlIO **saveifp, PerlIO **saveofp, int *savefd, char *savetype);
6669 # define PERL_ARGS_ASSERT_OPENN_SETUP           \
6670         assert(gv); assert(mode); assert(saveifp); assert(saveofp); assert(savefd); \
6671         assert(savetype)
6672 
6673 # if !defined(DOSISH)
6674 STATIC bool
6675 S_ingroup(pTHX_ Gid_t testgid, bool effective)
6676         __attribute__warn_unused_result__;
6677 #   define PERL_ARGS_ASSERT_INGROUP
6678 
6679 # endif
6680 #endif /* defined(PERL_IN_DOIO_C) */
6681 #if defined(PERL_IN_DOOP_C)
6682 STATIC Size_t
6683 S_do_trans_complex(pTHX_ SV * const sv, const OPtrans_map * const tbl)
6684         __attribute__warn_unused_result__;
6685 # define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX      \
6686         assert(sv); assert(tbl)
6687 
6688 STATIC Size_t
6689 S_do_trans_count(pTHX_ SV * const sv, const OPtrans_map * const tbl)
6690         __attribute__warn_unused_result__;
6691 # define PERL_ARGS_ASSERT_DO_TRANS_COUNT        \
6692         assert(sv); assert(tbl)
6693 
6694 STATIC Size_t
6695 S_do_trans_count_invmap(pTHX_ SV * const sv, AV * const map)
6696         __attribute__warn_unused_result__;
6697 # define PERL_ARGS_ASSERT_DO_TRANS_COUNT_INVMAP \
6698         assert(sv); assert(map)
6699 
6700 STATIC Size_t
6701 S_do_trans_invmap(pTHX_ SV * const sv, AV * const map)
6702         __attribute__warn_unused_result__;
6703 # define PERL_ARGS_ASSERT_DO_TRANS_INVMAP       \
6704         assert(sv); assert(map)
6705 
6706 STATIC Size_t
6707 S_do_trans_simple(pTHX_ SV * const sv, const OPtrans_map * const tbl)
6708         __attribute__warn_unused_result__;
6709 # define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE       \
6710         assert(sv); assert(tbl)
6711 
6712 #endif /* defined(PERL_IN_DOOP_C) */
6713 #if defined(PERL_IN_DOOP_C)    || defined(PERL_IN_OP_C)        || \
6714     defined(PERL_IN_PP_C)      || defined(PERL_IN_REGCOMP_ANY) || \
6715     defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C)      || \
6716     defined(PERL_IN_UTF8_C)
6717 
6718 PERL_CALLCONV SSize_t
6719 Perl__invlist_search(SV * const invlist, const UV cp)
6720         __attribute__warn_unused_result__;
6721 # define PERL_ARGS_ASSERT__INVLIST_SEARCH       \
6722         assert(invlist)
6723 
6724 #endif /* defined(PERL_IN_DOOP_C)    || defined(PERL_IN_OP_C)        ||
6725           defined(PERL_IN_PP_C)      || defined(PERL_IN_REGCOMP_ANY) ||
6726           defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C)      ||
6727           defined(PERL_IN_UTF8_C) */
6728 #if defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || \
6729     defined(PERL_IN_REGCOMP_ANY)
6730 
6731 #endif
6732 #if defined(PERL_IN_DOOP_C)      || defined(PERL_IN_OP_C) || \
6733     defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_UTF8_C)
6734 PERL_CALLCONV SV *
6735 Perl__add_range_to_invlist(pTHX_ SV *invlist, UV start, UV end)
6736         __attribute__warn_unused_result__;
6737 # define PERL_ARGS_ASSERT__ADD_RANGE_TO_INVLIST
6738 
6739 /* PERL_CALLCONV void
6740 _invlist_intersection(pTHX_ SV * const a, SV * const b, SV **i); */
6741 
6742 PERL_CALLCONV void
6743 Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV * const a, SV * const b, const bool complement_b, SV **i);
6744 # define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND \
6745         assert(b); assert(i)
6746 
6747 PERL_CALLCONV void
6748 Perl__invlist_invert(pTHX_ SV * const invlist);
6749 # define PERL_ARGS_ASSERT__INVLIST_INVERT       \
6750         assert(invlist)
6751 
6752 /* PERL_CALLCONV void
6753 _invlist_subtract(pTHX_ SV * const a, SV * const b, SV **result); */
6754 
6755 /* PERL_CALLCONV void
6756 _invlist_union(pTHX_ SV * const a, SV * const b, SV **output); */
6757 
6758 PERL_CALLCONV void
6759 Perl__invlist_union_maybe_complement_2nd(pTHX_ SV * const a, SV * const b, const bool complement_b, SV **output);
6760 # define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND \
6761         assert(b); assert(output)
6762 
6763 PERL_CALLCONV SV *
6764 Perl__new_invlist(pTHX_ IV initial_size)
6765         __attribute__warn_unused_result__;
6766 # define PERL_ARGS_ASSERT__NEW_INVLIST
6767 
6768 PERL_CALLCONV SV *
6769 Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV **other_elements_ptr)
6770         __attribute__warn_unused_result__;
6771 # define PERL_ARGS_ASSERT__SETUP_CANNED_INVLIST \
6772         assert(other_elements_ptr)
6773 
6774 #endif /* defined(PERL_IN_DOOP_C)      || defined(PERL_IN_OP_C) ||
6775           defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_UTF8_C) */
6776 #if defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_REGCOMP_C) || \
6777     defined(PERL_IN_TOKE_C)
6778 PERL_CALLCONV const char *
6779 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)
6780         __attribute__warn_unused_result__;
6781 # define PERL_ARGS_ASSERT_FORM_ALIEN_DIGIT_MSG  \
6782         assert(first_bad); assert(send)
6783 
6784 PERL_CALLCONV bool
6785 Perl_grok_bslash_c(pTHX_ const char source, U8 *result, const char **message, U32 *packed_warn)
6786         __attribute__warn_unused_result__;
6787 # define PERL_ARGS_ASSERT_GROK_BSLASH_C         \
6788         assert(result); assert(message)
6789 
6790 PERL_CALLCONV bool
6791 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)
6792         __attribute__warn_unused_result__;
6793 # define PERL_ARGS_ASSERT_GROK_BSLASH_O         \
6794         assert(s); assert(send); assert(uv); assert(message)
6795 
6796 PERL_CALLCONV bool
6797 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)
6798         __attribute__warn_unused_result__;
6799 # define PERL_ARGS_ASSERT_GROK_BSLASH_X         \
6800         assert(s); assert(send); assert(uv); assert(message)
6801 
6802 #endif /* defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_REGCOMP_C) ||
6803           defined(PERL_IN_TOKE_C) */
6804 #if defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_REGCOMP_C) || \
6805     defined(PERL_IN_TOKE_C)   || defined(PERL_IN_UTF8_C)
6806 PERL_CALLCONV const char *
6807 Perl_form_cp_too_large_msg(pTHX_ const U8 which, const char *string, const Size_t len, const UV cp)
6808         __attribute__warn_unused_result__;
6809 # define PERL_ARGS_ASSERT_FORM_CP_TOO_LARGE_MSG
6810 
6811 #endif
6812 #if defined(PERL_IN_DUMP_C)
6813 STATIC CV *
6814 S_deb_curcv(pTHX_ I32 ix);
6815 # define PERL_ARGS_ASSERT_DEB_CURCV
6816 
6817 STATIC void
6818 S_debprof(pTHX_ const OP *o);
6819 # define PERL_ARGS_ASSERT_DEBPROF               \
6820         assert(o)
6821 
6822 STATIC SV *
6823 S_pm_description(pTHX_ const PMOP *pm);
6824 # define PERL_ARGS_ASSERT_PM_DESCRIPTION        \
6825         assert(pm)
6826 
6827 STATIC UV
6828 S_sequence_num(pTHX_ const OP *o);
6829 # define PERL_ARGS_ASSERT_SEQUENCE_NUM
6830 
6831 #endif /* defined(PERL_IN_DUMP_C) */
6832 #if defined(PERL_IN_DUMP_C)  || defined(PERL_IN_HV_C) || \
6833     defined(PERL_IN_SCOPE_C) || defined(PERL_IN_SV_C)
6834 PERL_CALLCONV void
6835 Perl_hv_kill_backrefs(pTHX_ HV *hv)
6836         __attribute__visibility__("hidden");
6837 # define PERL_ARGS_ASSERT_HV_KILL_BACKREFS      \
6838         assert(hv)
6839 
6840 #endif
6841 #if defined(PERL_IN_DUMP_C) || defined(PERL_IN_OP_C) || \
6842     defined(PERL_IN_REGCOMP_ANY)
6843 PERL_CALLCONV void
6844 Perl__invlist_dump(pTHX_ PerlIO *file, I32 level, const char * const indent, SV * const invlist);
6845 # define PERL_ARGS_ASSERT__INVLIST_DUMP         \
6846         assert(file); assert(indent); assert(invlist)
6847 
6848 #endif
6849 #if defined(PERL_IN_GV_C)
6850 STATIC bool
6851 S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len, const U32 is_utf8, const I32 add, const svtype sv_type);
6852 # define PERL_ARGS_ASSERT_FIND_DEFAULT_STASH    \
6853         assert(stash); assert(name)
6854 
6855 STATIC void
6856 S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type);
6857 # define PERL_ARGS_ASSERT_GV_INIT_SVTYPE        \
6858         assert(gv)
6859 
6860 STATIC bool
6861 S_gv_is_in_main(pTHX_ const char *name, STRLEN len, const U32 is_utf8);
6862 # define PERL_ARGS_ASSERT_GV_IS_IN_MAIN         \
6863         assert(name)
6864 
6865 STATIC bool
6866 S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, const svtype sv_type);
6867 # define PERL_ARGS_ASSERT_GV_MAGICALIZE         \
6868         assert(gv); assert(stash); assert(name)
6869 
6870 STATIC void
6871 S_gv_magicalize_isa(pTHX_ GV *gv);
6872 # define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA     \
6873         assert(gv)
6874 
6875 STATIC void
6876 S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type);
6877 # define PERL_ARGS_ASSERT_MAYBE_MULTIMAGIC_GV   \
6878         assert(gv); assert(name)
6879 
6880 STATIC bool
6881 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);
6882 # define PERL_ARGS_ASSERT_PARSE_GV_STASH_NAME   \
6883         assert(stash); assert(gv); assert(name); assert(len); assert(nambeg)
6884 
6885 STATIC void
6886 S_require_tie_mod(pTHX_ GV *gv, const char varname, const char *name, STRLEN len, const U32 flags);
6887 # define PERL_ARGS_ASSERT_REQUIRE_TIE_MOD       \
6888         assert(gv); assert(varname); assert(name)
6889 
6890 # if !defined(PERL_NO_INLINE_FUNCTIONS)
6891 PERL_STATIC_INLINE GV *
6892 S_gv_fetchmeth_internal(pTHX_ HV *stash, SV *meth, const char *name, STRLEN len, I32 level, U32 flags);
6893 #   define PERL_ARGS_ASSERT_GV_FETCHMETH_INTERNAL
6894 
6895 PERL_STATIC_INLINE HV *
6896 S_gv_stashpvn_internal(pTHX_ const char *name, U32 namelen, I32 flags);
6897 #   define PERL_ARGS_ASSERT_GV_STASHPVN_INTERNAL \
6898         assert(name)
6899 
6900 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */
6901 #endif /* defined(PERL_IN_GV_C) */
6902 #if defined(PERL_IN_GV_C)  || defined(PERL_IN_OP_C) || \
6903     defined(PERL_IN_PAD_C) || defined(PERL_IN_SV_C)
6904 PERL_CALLCONV void
6905 Perl_sv_add_backref(pTHX_ SV * const tsv, SV * const sv)
6906         __attribute__visibility__("hidden");
6907 # define PERL_ARGS_ASSERT_SV_ADD_BACKREF        \
6908         assert(tsv); assert(sv)
6909 
6910 #endif
6911 #if defined(PERL_IN_GV_C) || defined(PERL_IN_UNIVERSAL_C)
6912 PERL_CALLCONV HV *
6913 Perl_gv_stashsvpvn_cached(pTHX_ SV *namesv, const char *name, U32 namelen, I32 flags)
6914         __attribute__visibility__("hidden");
6915 
6916 #endif
6917 #if defined(PERL_IN_HV_C)
6918 STATIC void
6919 S_clear_placeholders(pTHX_ HV *hv, U32 items);
6920 # define PERL_ARGS_ASSERT_CLEAR_PLACEHOLDERS    \
6921         assert(hv)
6922 
6923 STATIC void
6924 S_hsplit(pTHX_ HV *hv, STRLEN const oldsize, STRLEN newsize);
6925 # define PERL_ARGS_ASSERT_HSPLIT                \
6926         assert(hv)
6927 
6928 STATIC struct xpvhv_aux *
6929 S_hv_auxinit(pTHX_ HV *hv);
6930 # define PERL_ARGS_ASSERT_HV_AUXINIT            \
6931         assert(hv)
6932 
6933 STATIC SV *
6934 S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash);
6935 # define PERL_ARGS_ASSERT_HV_DELETE_COMMON
6936 
6937 STATIC SV *
6938 S_hv_free_ent_ret(pTHX_ HE *entry);
6939 # define PERL_ARGS_ASSERT_HV_FREE_ENT_RET       \
6940         assert(entry)
6941 
6942 STATIC void
6943 S_hv_free_entries(pTHX_ HV *hv);
6944 # define PERL_ARGS_ASSERT_HV_FREE_ENTRIES       \
6945         assert(hv)
6946 
6947 STATIC void
6948 S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store);
6949 # define PERL_ARGS_ASSERT_HV_MAGIC_CHECK        \
6950         assert(hv); assert(needs_copy); assert(needs_store)
6951 
6952 PERL_STATIC_NO_RET void
6953 S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg)
6954         __attribute__noreturn__;
6955 # define PERL_ARGS_ASSERT_HV_NOTALLOWED         \
6956         assert(key); assert(msg)
6957 
6958 STATIC SV *
6959 S_refcounted_he_value(pTHX_ const struct refcounted_he *he);
6960 # define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE   \
6961         assert(he)
6962 
6963 STATIC HEK *
6964 S_save_hek_flags(const char *str, I32 len, U32 hash, int flags)
6965         __attribute__malloc__
6966         __attribute__warn_unused_result__;
6967 # define PERL_ARGS_ASSERT_SAVE_HEK_FLAGS        \
6968         assert(str)
6969 
6970 STATIC HEK *
6971 S_share_hek_flags(pTHX_ const char *str, STRLEN len, U32 hash, int flags)
6972         __attribute__warn_unused_result__;
6973 # define PERL_ARGS_ASSERT_SHARE_HEK_FLAGS       \
6974         assert(str)
6975 
6976 STATIC void
6977 S_unshare_hek_or_pvn(pTHX_ const HEK *hek, const char *str, I32 len, U32 hash);
6978 # define PERL_ARGS_ASSERT_UNSHARE_HEK_OR_PVN
6979 
6980 # if !defined(PURIFY)
6981 STATIC HE *
6982 S_new_he(pTHX)
6983         __attribute__warn_unused_result__;
6984 #   define PERL_ARGS_ASSERT_NEW_HE
6985 
6986 # endif
6987 #endif /* defined(PERL_IN_HV_C) */
6988 #if defined(PERL_IN_HV_C) || defined(PERL_IN_MG_C) || defined(PERL_IN_SV_C)
6989 PERL_CALLCONV void
6990 Perl_sv_kill_backrefs(pTHX_ SV * const sv, AV * const av)
6991         __attribute__visibility__("hidden");
6992 # define PERL_ARGS_ASSERT_SV_KILL_BACKREFS      \
6993         assert(sv)
6994 
6995 #endif
6996 #if defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C)
6997 PERL_CALLCONV SV *
6998 Perl_hfree_next_entry(pTHX_ HV *hv, STRLEN *indexp)
6999         __attribute__visibility__("hidden");
7000 # define PERL_ARGS_ASSERT_HFREE_NEXT_ENTRY      \
7001         assert(hv); assert(indexp)
7002 
7003 #endif
7004 #if defined(PERL_IN_LOCALE_C)
7005 STATIC utf8ness_t
7006 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);
7007 # define PERL_ARGS_ASSERT_GET_LOCALE_STRING_UTF8NESS_I
7008 
7009 STATIC void
7010 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 wday, int yday, int isdst);
7011 # define PERL_ARGS_ASSERT_INTS_TO_TM            \
7012         assert(my_tm); assert(locale)
7013 
7014 STATIC bool
7015 S_is_locale_utf8(pTHX_ const char *locale);
7016 # define PERL_ARGS_ASSERT_IS_LOCALE_UTF8        \
7017         assert(locale)
7018 
7019 STATIC HV *
7020 S_my_localeconv(pTHX_ const int item);
7021 # define PERL_ARGS_ASSERT_MY_LOCALECONV
7022 
7023 STATIC void
7024 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]);
7025 # define PERL_ARGS_ASSERT_POPULATE_HASH_FROM_C_LOCALECONV \
7026         assert(hv); assert(locale); assert(strings); assert(integers)
7027 
7028 STATIC bool
7029 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);
7030 # define PERL_ARGS_ASSERT_STRFTIME8             \
7031         assert(fmt); assert(sv); assert(locale); assert(mytm); assert(result_utf8ness)
7032 
7033 STATIC bool
7034 S_strftime_tm(pTHX_ const char *fmt, SV *sv, const char *locale, const struct tm *mytm)
7035         __attribute__format__(__strftime__,pTHX_1,0);
7036 # define PERL_ARGS_ASSERT_STRFTIME_TM           \
7037         assert(fmt); assert(sv); assert(locale); assert(mytm)
7038 
7039 STATIC SV *
7040 S_sv_strftime_common(pTHX_ SV *fmt, const char *locale, const struct tm *mytm);
7041 # define PERL_ARGS_ASSERT_SV_STRFTIME_COMMON    \
7042         assert(fmt); assert(locale); assert(mytm)
7043 
7044 # if defined(HAS_MISSING_LANGINFO_ITEM_) || !defined(HAS_NL_LANGINFO)
7045 STATIC const char *
7046 S_emulate_langinfo(pTHX_ const PERL_INTMAX_T item, const char *locale, SV *sv, utf8ness_t *utf8ness);
7047 #   define PERL_ARGS_ASSERT_EMULATE_LANGINFO    \
7048         assert(locale); assert(sv)
7049 
7050 # endif
7051 # if defined(USE_LOCALE)
7052 STATIC const char *
7053 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);
7054 #   define PERL_ARGS_ASSERT_CALCULATE_LC_ALL_STRING
7055 
7056 STATIC const char *
7057 S_external_call_langinfo(pTHX_ const nl_item item, SV *sv, utf8ness_t *utf8ness);
7058 #   define PERL_ARGS_ASSERT_EXTERNAL_CALL_LANGINFO \
7059         assert(sv)
7060 
7061 STATIC locale_category_index
7062 S_get_category_index_helper(pTHX_ const int category, bool *success, const line_t caller_line)
7063         __attribute__warn_unused_result__;
7064 #   define PERL_ARGS_ASSERT_GET_CATEGORY_INDEX_HELPER
7065 
7066 STATIC const char *
7067 S_native_querylocale_i(pTHX_ const locale_category_index cat_index);
7068 #   define PERL_ARGS_ASSERT_NATIVE_QUERYLOCALE_I
7069 
7070 STATIC void
7071 S_new_LC_ALL(pTHX_ const char *lc_all, bool force);
7072 #   define PERL_ARGS_ASSERT_NEW_LC_ALL          \
7073         assert(lc_all)
7074 
7075 STATIC void
7076 S_output_check_environment_warning(pTHX_ const char * const language, const char * const lc_all, const char * const lang);
7077 #   define PERL_ARGS_ASSERT_OUTPUT_CHECK_ENVIRONMENT_WARNING
7078 
7079 STATIC parse_LC_ALL_string_return
7080 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);
7081 #   define PERL_ARGS_ASSERT_PARSE_LC_ALL_STRING \
7082         assert(string); assert(output)
7083 
7084 STATIC void
7085 S_restore_toggled_locale_i(pTHX_ const locale_category_index cat_index, const char *original_locale, const line_t caller_line);
7086 #   define PERL_ARGS_ASSERT_RESTORE_TOGGLED_LOCALE_I
7087 
7088 STATIC const char *
7089 S_save_to_buffer(pTHX_ const char *string, char **buf, Size_t *buf_size);
7090 #   define PERL_ARGS_ASSERT_SAVE_TO_BUFFER
7091 
7092 STATIC void
7093 S_set_save_buffer_min_size(pTHX_ const Size_t min_len, char **buf, Size_t *buf_size);
7094 #   define PERL_ARGS_ASSERT_SET_SAVE_BUFFER_MIN_SIZE
7095 
7096 PERL_STATIC_NO_RET void
7097 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)
7098         __attribute__noreturn__;
7099 #   define PERL_ARGS_ASSERT_SETLOCALE_FAILURE_PANIC_VIA_I \
7100         assert(failed); assert(higher_caller_file)
7101 
7102 STATIC const char *
7103 S_toggle_locale_i(pTHX_ const locale_category_index cat_index, const char *new_locale, const line_t caller_line);
7104 #   define PERL_ARGS_ASSERT_TOGGLE_LOCALE_I     \
7105         assert(new_locale)
7106 
7107 #   if defined(DEBUGGING)
7108 STATIC char *
7109 S_my_setlocale_debug_string_i(pTHX_ const locale_category_index cat_index, const char *locale, const char *retval, const line_t line)
7110         __attribute__warn_unused_result__;
7111 #     define PERL_ARGS_ASSERT_MY_SETLOCALE_DEBUG_STRING_I
7112 
7113 #   endif
7114 #   if   defined(HAS_LOCALECONV) && \
7115        ( defined(USE_LOCALE_MONETARY) || defined(USE_LOCALE_NUMERIC) )
7116 STATIC void
7117 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]);
7118 #     define PERL_ARGS_ASSERT_POPULATE_HASH_FROM_LOCALECONV \
7119         assert(hv); assert(locale); assert(strings); assert(integers)
7120 
7121 #   endif
7122 #   if defined(HAS_NL_LANGINFO)
7123 STATIC const char *
7124 S_langinfo_sv_i(pTHX_ const nl_item item, locale_category_index cat_index, const char *locale, SV *sv, utf8ness_t *utf8ness);
7125 #     define PERL_ARGS_ASSERT_LANGINFO_SV_I     \
7126         assert(locale); assert(sv)
7127 
7128 #   endif
7129 #   if defined(LC_ALL)
7130 STATIC void
7131 S_give_perl_locale_control(pTHX_ const char *lc_all_string, const line_t caller_line);
7132 #     define PERL_ARGS_ASSERT_GIVE_PERL_LOCALE_CONTROL \
7133         assert(lc_all_string)
7134 
7135 #   else
7136 STATIC void
7137 S_give_perl_locale_control(pTHX_ const char **curlocales, const line_t caller_line);
7138 #     define PERL_ARGS_ASSERT_GIVE_PERL_LOCALE_CONTROL \
7139         assert(curlocales)
7140 
7141 #   endif
7142 #   if !defined(PERL_NO_INLINE_FUNCTIONS)
7143 PERL_STATIC_INLINE const char *
7144 S_mortalized_pv_copy(pTHX_ const char * const pv)
7145         __attribute__warn_unused_result__;
7146 #     define PERL_ARGS_ASSERT_MORTALIZED_PV_COPY
7147 
7148 #   endif
7149 #   if defined(USE_LOCALE_COLLATE)
7150 STATIC void
7151 S_new_collate(pTHX_ const char *newcoll, bool force);
7152 #     define PERL_ARGS_ASSERT_NEW_COLLATE       \
7153         assert(newcoll)
7154 
7155 #     if defined(DEBUGGING)
7156 STATIC void
7157 S_print_collxfrm_input_and_return(pTHX_ const char *s, const char *e, const char *xbuf, const STRLEN xlen, const bool is_utf8);
7158 #       define PERL_ARGS_ASSERT_PRINT_COLLXFRM_INPUT_AND_RETURN \
7159         assert(s); assert(e)
7160 
7161 #     endif
7162 #   endif /* defined(USE_LOCALE_COLLATE) */
7163 #   if defined(USE_LOCALE_CTYPE)
7164 STATIC bool
7165 S_is_codeset_name_UTF8(const char *name);
7166 #     define PERL_ARGS_ASSERT_IS_CODESET_NAME_UTF8 \
7167         assert(name)
7168 
7169 STATIC void
7170 S_new_ctype(pTHX_ const char *newctype, bool force);
7171 #     define PERL_ARGS_ASSERT_NEW_CTYPE         \
7172         assert(newctype)
7173 
7174 #   endif /* defined(USE_LOCALE_CTYPE) */
7175 #   if defined(USE_LOCALE_NUMERIC)
7176 STATIC void
7177 S_new_numeric(pTHX_ const char *newnum, bool force);
7178 #     define PERL_ARGS_ASSERT_NEW_NUMERIC       \
7179         assert(newnum)
7180 
7181 #   endif
7182 #   if defined(USE_PERL_SWITCH_LOCALE_CONTEXT) || defined(DEBUGGING)
7183 STATIC const char *
7184 S_get_LC_ALL_display(pTHX);
7185 #     define PERL_ARGS_ASSERT_GET_LC_ALL_DISPLAY
7186 
7187 #   endif
7188 #   if defined(USE_POSIX_2008_LOCALE)
7189 STATIC bool
7190 S_bool_setlocale_2008_i(pTHX_ const locale_category_index index, const char *new_locale, const line_t caller_line);
7191 #     define PERL_ARGS_ASSERT_BOOL_SETLOCALE_2008_I \
7192         assert(new_locale)
7193 
7194 STATIC const char *
7195 S_querylocale_2008_i(pTHX_ const locale_category_index index, const line_t line);
7196 #     define PERL_ARGS_ASSERT_QUERYLOCALE_2008_I
7197 
7198 STATIC locale_t
7199 S_use_curlocale_scratch(pTHX);
7200 #     define PERL_ARGS_ASSERT_USE_CURLOCALE_SCRATCH
7201 
7202 #     if !defined(USE_QUERYLOCALE)
7203 STATIC void
7204 S_update_PL_curlocales_i(pTHX_ const locale_category_index index, const char *new_locale, const line_t caller_line);
7205 #       define PERL_ARGS_ASSERT_UPDATE_PL_CURLOCALES_I \
7206         assert(new_locale)
7207 
7208 #     endif
7209 #   elif  defined(USE_LOCALE_THREADS) &&                  \
7210          !defined(USE_THREAD_SAFE_LOCALE) &&              \
7211          !defined(USE_THREAD_SAFE_LOCALE_EMULATION) /* &&
7212          !defined(USE_POSIX_2008_LOCALE) */
7213 STATIC bool
7214 S_less_dicey_bool_setlocale_r(pTHX_ const int cat, const char *locale);
7215 #     define PERL_ARGS_ASSERT_LESS_DICEY_BOOL_SETLOCALE_R \
7216         assert(locale)
7217 
7218 STATIC const char *
7219 S_less_dicey_setlocale_r(pTHX_ const int category, const char *locale);
7220 #     define PERL_ARGS_ASSERT_LESS_DICEY_SETLOCALE_R
7221 
7222 #   endif /*  defined(USE_LOCALE_THREADS) &&
7223              !defined(USE_POSIX_2008_LOCALE) &&
7224              !defined(USE_THREAD_SAFE_LOCALE) &&
7225              !defined(USE_THREAD_SAFE_LOCALE_EMULATION) */
7226 #   if defined(WIN32) || defined(WIN32_USE_FAKE_OLD_MINGW_LOCALES)
7227 STATIC wchar_t *
7228 S_Win_byte_string_to_wstring(const UINT code_page, const char *byte_string);
7229 #     define PERL_ARGS_ASSERT_WIN_BYTE_STRING_TO_WSTRING
7230 
7231 STATIC char *
7232 S_Win_wstring_to_byte_string(const UINT code_page, const wchar_t *wstring);
7233 #     define PERL_ARGS_ASSERT_WIN_WSTRING_TO_BYTE_STRING
7234 
7235 STATIC const char *
7236 S_win32_setlocale(pTHX_ int category, const char *locale);
7237 #     define PERL_ARGS_ASSERT_WIN32_SETLOCALE
7238 
7239 STATIC const char *
7240 S_wrap_wsetlocale(pTHX_ const int category, const char *locale);
7241 #     define PERL_ARGS_ASSERT_WRAP_WSETLOCALE
7242 
7243 #   endif /* defined(WIN32) || defined(WIN32_USE_FAKE_OLD_MINGW_LOCALES) */
7244 #   if   defined(WIN32) || defined(WIN32_USE_FAKE_OLD_MINGW_LOCALES) || \
7245        ( defined(USE_POSIX_2008_LOCALE) && !defined(USE_QUERYLOCALE) )
7246 STATIC const char *
7247 S_find_locale_from_environment(pTHX_ const locale_category_index index);
7248 #     define PERL_ARGS_ASSERT_FIND_LOCALE_FROM_ENVIRONMENT
7249 
7250 #   endif
7251 # endif /* defined(USE_LOCALE) */
7252 # if defined(USE_LOCALE) || defined(DEBUGGING)
7253 STATIC const char *
7254 S_get_displayable_string(pTHX_ const char * const s, const char * const e, const bool is_utf8);
7255 #   define PERL_ARGS_ASSERT_GET_DISPLAYABLE_STRING \
7256         assert(s); assert(e)
7257 
7258 # endif
7259 #endif /* defined(PERL_IN_LOCALE_C) */
7260 #if defined(PERL_IN_MALLOC_C)
7261 STATIC int
7262 S_adjust_size_and_find_bucket(size_t *nbytes_p);
7263 # define PERL_ARGS_ASSERT_ADJUST_SIZE_AND_FIND_BUCKET \
7264         assert(nbytes_p)
7265 
7266 #endif
7267 #if defined(PERL_IN_MG_C)
7268 STATIC void
7269 S_fixup_errno_string(pTHX_ SV *sv);
7270 # define PERL_ARGS_ASSERT_FIXUP_ERRNO_STRING    \
7271         assert(sv)
7272 
7273 STATIC SV *
7274 S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, int n, SV *val);
7275 # define PERL_ARGS_ASSERT_MAGIC_METHCALL1       \
7276         assert(sv); assert(mg); assert(meth)
7277 
7278 STATIC int
7279 S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth);
7280 # define PERL_ARGS_ASSERT_MAGIC_METHPACK        \
7281         assert(sv); assert(mg); assert(meth)
7282 
7283 STATIC void
7284 S_restore_magic(pTHX_ const void *p);
7285 # define PERL_ARGS_ASSERT_RESTORE_MAGIC
7286 
7287 STATIC void
7288 S_save_magic_flags(pTHX_ SSize_t mgs_ix, SV *sv, U32 flags);
7289 # define PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS      \
7290         assert(sv)
7291 
7292 STATIC void
7293 S_unwind_handler_stack(pTHX_ const void *p);
7294 # define PERL_ARGS_ASSERT_UNWIND_HANDLER_STACK
7295 
7296 #endif /* defined(PERL_IN_MG_C) */
7297 #if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C)
7298 PERL_CALLCONV bool
7299 Perl_translate_substr_offsets(STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp)
7300         __attribute__visibility__("hidden");
7301 # define PERL_ARGS_ASSERT_TRANSLATE_SUBSTR_OFFSETS \
7302         assert(posp); assert(lenp)
7303 
7304 #endif
7305 #if defined(PERL_IN_MRO_C)
7306 STATIC void
7307 S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN len, HV * const exceptions, U32 hash, U32 flags);
7308 # define PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV      \
7309         assert(isa); assert(name)
7310 
7311 STATIC void
7312 S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes, HV *stash, HV *oldstash, SV *namesv);
7313 # define PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME \
7314         assert(stashes); assert(seen_stashes); assert(namesv)
7315 
7316 STATIC AV *
7317 S_mro_get_linear_isa_dfs(pTHX_ HV *stash, U32 level);
7318 # define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS \
7319         assert(stash)
7320 
7321 #endif /* defined(PERL_IN_MRO_C) */
7322 #if defined(PERL_IN_NUMERIC_C)
7323 STATIC void
7324 S_output_non_portable(pTHX_ const U8 shift);
7325 # define PERL_ARGS_ASSERT_OUTPUT_NON_PORTABLE
7326 
7327 #endif
7328 #if defined(PERL_IN_OP_C)
7329 STATIC void
7330 S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs);
7331 # define PERL_ARGS_ASSERT_APPLY_ATTRS           \
7332         assert(stash); assert(target)
7333 
7334 STATIC void
7335 S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp);
7336 # define PERL_ARGS_ASSERT_APPLY_ATTRS_MY        \
7337         assert(stash); assert(target); assert(imopsp)
7338 
7339 STATIC I32
7340 S_assignment_type(pTHX_ const OP *o)
7341         __attribute__warn_unused_result__;
7342 # define PERL_ARGS_ASSERT_ASSIGNMENT_TYPE
7343 
7344 STATIC void
7345 S_bad_type_gv(pTHX_ I32 n, GV *gv, const OP *kid, const char *t);
7346 # define PERL_ARGS_ASSERT_BAD_TYPE_GV           \
7347         assert(gv); assert(kid); assert(t)
7348 
7349 STATIC void
7350 S_bad_type_pv(pTHX_ I32 n, const char *t, const OP *o, const OP *kid);
7351 # define PERL_ARGS_ASSERT_BAD_TYPE_PV           \
7352         assert(t); assert(o); assert(kid)
7353 
7354 STATIC void
7355 S_clear_special_blocks(pTHX_ const char * const fullname, GV * const gv, CV * const cv);
7356 # define PERL_ARGS_ASSERT_CLEAR_SPECIAL_BLOCKS  \
7357         assert(fullname); assert(gv); assert(cv)
7358 
7359 STATIC void
7360 S_cop_free(pTHX_ COP *cop);
7361 # define PERL_ARGS_ASSERT_COP_FREE              \
7362         assert(cop)
7363 
7364 STATIC OP *
7365 S_dup_attrlist(pTHX_ OP *o);
7366 # define PERL_ARGS_ASSERT_DUP_ATTRLIST          \
7367         assert(o)
7368 
7369 STATIC void
7370 S_find_and_forget_pmops(pTHX_ OP *o);
7371 # define PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS \
7372         assert(o)
7373 
7374 STATIC OP *
7375 S_fold_constants(pTHX_ OP * const o);
7376 # define PERL_ARGS_ASSERT_FOLD_CONSTANTS        \
7377         assert(o)
7378 
7379 STATIC OP *
7380 S_force_list(pTHX_ OP *arg, bool nullit);
7381 # define PERL_ARGS_ASSERT_FORCE_LIST
7382 
7383 STATIC void
7384 S_forget_pmop(pTHX_ PMOP * const o);
7385 # define PERL_ARGS_ASSERT_FORGET_PMOP           \
7386         assert(o)
7387 
7388 STATIC void
7389 S_gen_constant_list(pTHX_ OP *o);
7390 # define PERL_ARGS_ASSERT_GEN_CONSTANT_LIST
7391 
7392 STATIC void
7393 S_inplace_aassign(pTHX_ OP *o);
7394 # define PERL_ARGS_ASSERT_INPLACE_AASSIGN       \
7395         assert(o)
7396 
7397 STATIC bool
7398 S_is_handle_constructor(const OP *o, I32 numargs)
7399         __attribute__warn_unused_result__;
7400 # define PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR \
7401         assert(o)
7402 
7403 STATIC OP *
7404 S_listkids(pTHX_ OP *o);
7405 # define PERL_ARGS_ASSERT_LISTKIDS
7406 
7407 STATIC bool
7408 S_looks_like_bool(pTHX_ const OP *o);
7409 # define PERL_ARGS_ASSERT_LOOKS_LIKE_BOOL       \
7410         assert(o)
7411 
7412 STATIC OP *
7413 S_modkids(pTHX_ OP *o, I32 type);
7414 # define PERL_ARGS_ASSERT_MODKIDS
7415 
7416 STATIC void
7417 S_move_proto_attr(pTHX_ OP **proto, OP **attrs, const GV *name, bool curstash);
7418 # define PERL_ARGS_ASSERT_MOVE_PROTO_ATTR       \
7419         assert(proto); assert(attrs); assert(name)
7420 
7421 STATIC OP *
7422 S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp);
7423 # define PERL_ARGS_ASSERT_MY_KID                \
7424         assert(imopsp)
7425 
7426 STATIC OP *
7427 S_newGIVWHENOP(pTHX_ OP *cond, OP *block, I32 enter_opcode, I32 leave_opcode, PADOFFSET entertarg);
7428 # define PERL_ARGS_ASSERT_NEWGIVWHENOP          \
7429         assert(block)
7430 
7431 STATIC OP *
7432 S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp)
7433         __attribute__warn_unused_result__;
7434 # define PERL_ARGS_ASSERT_NEW_LOGOP             \
7435         assert(firstp); assert(otherp)
7436 
7437 STATIC OP *
7438 S_no_fh_allowed(pTHX_ OP *o)
7439         __attribute__warn_unused_result__;
7440 # define PERL_ARGS_ASSERT_NO_FH_ALLOWED         \
7441         assert(o)
7442 
7443 STATIC OP *
7444 S_pmtrans(pTHX_ OP *o, OP *expr, OP *repl);
7445 # define PERL_ARGS_ASSERT_PMTRANS               \
7446         assert(o); assert(expr); assert(repl)
7447 
7448 STATIC bool
7449 S_process_special_blocks(pTHX_ I32 floor, const char * const fullname, GV * const gv, CV * const cv);
7450 # define PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS \
7451         assert(fullname); assert(gv); assert(cv)
7452 
7453 STATIC OP *
7454 S_ref_array_or_hash(pTHX_ OP *cond);
7455 # define PERL_ARGS_ASSERT_REF_ARRAY_OR_HASH
7456 
7457 STATIC OP *
7458 S_refkids(pTHX_ OP *o, I32 type);
7459 # define PERL_ARGS_ASSERT_REFKIDS
7460 
7461 STATIC bool
7462 S_scalar_mod_type(const OP *o, I32 type)
7463         __attribute__warn_unused_result__;
7464 # define PERL_ARGS_ASSERT_SCALAR_MOD_TYPE
7465 
7466 STATIC OP *
7467 S_scalarboolean(pTHX_ OP *o);
7468 # define PERL_ARGS_ASSERT_SCALARBOOLEAN         \
7469         assert(o)
7470 
7471 STATIC OP *
7472 S_scalarkids(pTHX_ OP *o);
7473 # define PERL_ARGS_ASSERT_SCALARKIDS
7474 
7475 STATIC OP *
7476 S_search_const(pTHX_ OP *o)
7477         __attribute__warn_unused_result__;
7478 # define PERL_ARGS_ASSERT_SEARCH_CONST          \
7479         assert(o)
7480 
7481 STATIC void
7482 S_simplify_sort(pTHX_ OP *o);
7483 # define PERL_ARGS_ASSERT_SIMPLIFY_SORT         \
7484         assert(o)
7485 
7486 STATIC OP *
7487 S_too_few_arguments_pv(pTHX_ OP *o, const char *name, U32 flags)
7488         __attribute__warn_unused_result__;
7489 # define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_PV  \
7490         assert(o); assert(name)
7491 
7492 STATIC OP *
7493 S_too_many_arguments_pv(pTHX_ OP *o, const char *name, U32 flags);
7494 # define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_PV \
7495         assert(o); assert(name)
7496 
7497 STATIC OP *
7498 S_voidnonfinal(pTHX_ OP *o);
7499 # define PERL_ARGS_ASSERT_VOIDNONFINAL
7500 
7501 # if !defined(PERL_NO_INLINE_FUNCTIONS)
7502 PERL_STATIC_INLINE bool
7503 S_is_standard_filehandle_name(const char *fhname);
7504 #   define PERL_ARGS_ASSERT_IS_STANDARD_FILEHANDLE_NAME \
7505         assert(fhname)
7506 
7507 PERL_STATIC_INLINE OP *
7508 S_newMETHOP_internal(pTHX_ I32 type, I32 flags, OP *dynamic_meth, SV * const_meth);
7509 #   define PERL_ARGS_ASSERT_NEWMETHOP_INTERNAL
7510 
7511 PERL_STATIC_INLINE OP *
7512 S_op_integerize(pTHX_ OP *o);
7513 #   define PERL_ARGS_ASSERT_OP_INTEGERIZE       \
7514         assert(o)
7515 
7516 PERL_STATIC_INLINE OP *
7517 S_op_std_init(pTHX_ OP *o);
7518 #   define PERL_ARGS_ASSERT_OP_STD_INIT         \
7519         assert(o)
7520 
7521 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */
7522 #endif /* defined(PERL_IN_OP_C) */
7523 #if defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C)
7524 PERL_CALLCONV void
7525 Perl_check_hash_fields_and_hekify(pTHX_ UNOP *rop, SVOP *key_op, int real)
7526         __attribute__visibility__("hidden");
7527 # define PERL_ARGS_ASSERT_CHECK_HASH_FIELDS_AND_HEKIFY
7528 
7529 PERL_CALLCONV void
7530 Perl_no_bareword_allowed(pTHX_ OP *o)
7531         __attribute__visibility__("hidden");
7532 # define PERL_ARGS_ASSERT_NO_BAREWORD_ALLOWED   \
7533         assert(o)
7534 
7535 PERL_CALLCONV void
7536 Perl_op_prune_chain_head(OP **op_p)
7537         __attribute__visibility__("hidden");
7538 # define PERL_ARGS_ASSERT_OP_PRUNE_CHAIN_HEAD   \
7539         assert(op_p)
7540 
7541 PERL_CALLCONV SV *
7542 Perl_op_varname(pTHX_ const OP *o)
7543         __attribute__visibility__("hidden");
7544 # define PERL_ARGS_ASSERT_OP_VARNAME            \
7545         assert(o)
7546 
7547 PERL_CALLCONV void
7548 Perl_warn_elem_scalar_context(pTHX_ const OP *o, SV *name, bool is_hash, bool is_slice)
7549         __attribute__visibility__("hidden");
7550 # define PERL_ARGS_ASSERT_WARN_ELEM_SCALAR_CONTEXT \
7551         assert(o); assert(name)
7552 
7553 #endif /* defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) */
7554 #if defined(PERL_IN_OP_C) || defined(PERL_IN_REGCOMP_ANY)
7555 
7556 #endif
7557 #if defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C)
7558 PERL_CALLCONV void
7559 Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_cv, SV * const *new_const_svp)
7560         __attribute__visibility__("hidden");
7561 # define PERL_ARGS_ASSERT_REPORT_REDEFINED_CV   \
7562         assert(name); assert(old_cv)
7563 
7564 PERL_CALLCONV SV *
7565 Perl_varname(pTHX_ const GV * const gv, const char gvtype, PADOFFSET targ, const SV * const keyname, SSize_t aindex, int subscript_type)
7566         __attribute__warn_unused_result__
7567         __attribute__visibility__("hidden");
7568 # define PERL_ARGS_ASSERT_VARNAME
7569 
7570 #endif /* defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C) */
7571 #if defined(PERL_IN_PAD_C)
7572 STATIC PADOFFSET
7573 S_pad_alloc_name(pTHX_ PADNAME *name, U32 flags, HV *typestash, HV *ourstash);
7574 # define PERL_ARGS_ASSERT_PAD_ALLOC_NAME        \
7575         assert(name)
7576 
7577 STATIC void
7578 S_pad_check_dup(pTHX_ PADNAME *name, U32 flags, const HV *ourstash);
7579 # define PERL_ARGS_ASSERT_PAD_CHECK_DUP         \
7580         assert(name)
7581 
7582 STATIC PADOFFSET
7583 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);
7584 # define PERL_ARGS_ASSERT_PAD_FINDLEX           \
7585         assert(namepv); assert(cv); assert(out_name); assert(out_flags)
7586 
7587 STATIC void
7588 S_pad_reset(pTHX);
7589 # define PERL_ARGS_ASSERT_PAD_RESET
7590 
7591 # if defined(DEBUGGING)
7592 STATIC void
7593 S_cv_dump(pTHX_ const CV *cv, const char *title);
7594 #   define PERL_ARGS_ASSERT_CV_DUMP             \
7595         assert(cv); assert(title)
7596 
7597 # endif
7598 #endif /* defined(PERL_IN_PAD_C) */
7599 #if defined(PERL_IN_PEEP_C)
7600 STATIC void
7601 S_finalize_op(pTHX_ OP *o);
7602 # define PERL_ARGS_ASSERT_FINALIZE_OP           \
7603         assert(o)
7604 
7605 STATIC void
7606 S_optimize_op(pTHX_ OP *o);
7607 # define PERL_ARGS_ASSERT_OPTIMIZE_OP           \
7608         assert(o)
7609 
7610 STATIC OP *
7611 S_traverse_op_tree(pTHX_ OP *top, OP *o);
7612 # define PERL_ARGS_ASSERT_TRAVERSE_OP_TREE      \
7613         assert(top); assert(o)
7614 
7615 #endif /* defined(PERL_IN_PEEP_C) */
7616 #if defined(PERL_IN_PERL_C)
7617 STATIC void
7618 S_find_beginning(pTHX_ SV *linestr_sv, PerlIO *rsfp);
7619 # define PERL_ARGS_ASSERT_FIND_BEGINNING        \
7620         assert(linestr_sv); assert(rsfp)
7621 
7622 STATIC void
7623 S_forbid_setid(pTHX_ const char flag, const bool suidscript);
7624 # define PERL_ARGS_ASSERT_FORBID_SETID
7625 
7626 STATIC void
7627 S_incpush(pTHX_ const char * const dir, STRLEN len, U32 flags);
7628 # define PERL_ARGS_ASSERT_INCPUSH               \
7629         assert(dir)
7630 
7631 STATIC void
7632 S_incpush_use_sep(pTHX_ const char *p, STRLEN len, U32 flags);
7633 # define PERL_ARGS_ASSERT_INCPUSH_USE_SEP       \
7634         assert(p)
7635 
7636 STATIC void
7637 S_init_ids(pTHX);
7638 # define PERL_ARGS_ASSERT_INIT_IDS
7639 
7640 STATIC void
7641 S_init_interp(pTHX);
7642 # define PERL_ARGS_ASSERT_INIT_INTERP
7643 
7644 STATIC void
7645 S_init_main_stash(pTHX);
7646 # define PERL_ARGS_ASSERT_INIT_MAIN_STASH
7647 
7648 STATIC void
7649 S_init_perllib(pTHX);
7650 # define PERL_ARGS_ASSERT_INIT_PERLLIB
7651 
7652 STATIC void
7653 S_init_postdump_symbols(pTHX_ int argc, char **argv, char **env);
7654 # define PERL_ARGS_ASSERT_INIT_POSTDUMP_SYMBOLS \
7655         assert(argv)
7656 
7657 STATIC void
7658 S_init_predump_symbols(pTHX);
7659 # define PERL_ARGS_ASSERT_INIT_PREDUMP_SYMBOLS
7660 
7661 STATIC SV *
7662 S_mayberelocate(pTHX_ const char * const dir, STRLEN len, U32 flags);
7663 # define PERL_ARGS_ASSERT_MAYBERELOCATE         \
7664         assert(dir)
7665 
7666 PERL_STATIC_NO_RET void
7667 S_minus_v(pTHX)
7668         __attribute__noreturn__;
7669 # define PERL_ARGS_ASSERT_MINUS_V
7670 
7671 PERL_STATIC_NO_RET void
7672 S_my_exit_jump(pTHX)
7673         __attribute__noreturn__;
7674 # define PERL_ARGS_ASSERT_MY_EXIT_JUMP
7675 
7676 STATIC void
7677 S_nuke_stacks(pTHX);
7678 # define PERL_ARGS_ASSERT_NUKE_STACKS
7679 
7680 STATIC PerlIO *
7681 S_open_script(pTHX_ const char *scriptname, bool dosearch, bool *suidscript);
7682 # define PERL_ARGS_ASSERT_OPEN_SCRIPT           \
7683         assert(scriptname); assert(suidscript)
7684 
7685 STATIC void *
7686 S_parse_body(pTHX_ char **env, XSINIT_t xsinit);
7687 # define PERL_ARGS_ASSERT_PARSE_BODY
7688 
7689 PERL_STATIC_NO_RET void
7690 S_run_body(pTHX_ I32 oldscope)
7691         __attribute__noreturn__;
7692 # define PERL_ARGS_ASSERT_RUN_BODY
7693 
7694 PERL_STATIC_NO_RET void
7695 S_usage(pTHX)
7696         __attribute__noreturn__;
7697 # define PERL_ARGS_ASSERT_USAGE
7698 
7699 # if !defined(PERL_IS_MINIPERL)
7700 STATIC SV *
7701 S_incpush_if_exists(pTHX_ AV * const av, SV *dir, SV * const stem);
7702 #   define PERL_ARGS_ASSERT_INCPUSH_IF_EXISTS   \
7703         assert(av); assert(dir); assert(stem)
7704 
7705 # endif
7706 # if !defined(SETUID_SCRIPTS_ARE_SECURE_NOW)
7707 STATIC void
7708 S_validate_suid(pTHX_ PerlIO *rsfp);
7709 #   define PERL_ARGS_ASSERT_VALIDATE_SUID       \
7710         assert(rsfp)
7711 
7712 # endif
7713 #endif /* defined(PERL_IN_PERL_C) */
7714 #if defined(PERL_IN_PERL_C) || defined(PERL_IN_REGCOMP_ANY) || \
7715     defined(PERL_IN_UTF8_C)
7716 PERL_CALLCONV bool
7717 Perl__invlistEQ(pTHX_ SV * const a, SV * const b, const bool complement_b);
7718 # define PERL_ARGS_ASSERT__INVLISTEQ            \
7719         assert(a); assert(b)
7720 
7721 PERL_CALLCONV SV *
7722 Perl__new_invlist_C_array(pTHX_ const UV * const list)
7723         __attribute__warn_unused_result__;
7724 # define PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY  \
7725         assert(list)
7726 
7727 #endif /* defined(PERL_IN_PERL_C) || defined(PERL_IN_REGCOMP_ANY) ||
7728           defined(PERL_IN_UTF8_C) */
7729 #if defined(PERL_IN_PP_C)
7730 STATIC size_t
7731 S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping);
7732 # define PERL_ARGS_ASSERT_DO_CHOMP              \
7733         assert(retval); assert(sv)
7734 
7735 STATIC OP *
7736 S_do_delete_local(pTHX);
7737 # define PERL_ARGS_ASSERT_DO_DELETE_LOCAL
7738 
7739 STATIC SV *
7740 S_refto(pTHX_ SV *sv)
7741         __attribute__warn_unused_result__;
7742 # define PERL_ARGS_ASSERT_REFTO                 \
7743         assert(sv)
7744 
7745 #endif /* defined(PERL_IN_PP_C) */
7746 #if defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C)
7747 
7748 PERL_CALLCONV GV *
7749 Perl_softref2xv(pTHX_ SV * const sv, const char * const what, const svtype type)
7750         __attribute__warn_unused_result__;
7751 # define PERL_ARGS_ASSERT_SOFTREF2XV            \
7752         assert(sv); assert(what)
7753 
7754 #endif
7755 #if defined(PERL_IN_PP_C) || defined(PERL_IN_UTF8_C)
7756 PERL_CALLCONV UV
7757 Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_or_s)
7758         __attribute__visibility__("hidden");
7759 # define PERL_ARGS_ASSERT__TO_UPPER_TITLE_LATIN1 \
7760         assert(p); assert(lenp)
7761 
7762 #endif
7763 #if defined(PERL_IN_PP_CTL_C)
7764 STATIC PerlIO *
7765 S_check_type_and_open(pTHX_ SV *name)
7766         __attribute__warn_unused_result__;
7767 # define PERL_ARGS_ASSERT_CHECK_TYPE_AND_OPEN   \
7768         assert(name)
7769 
7770 STATIC void
7771 S_destroy_matcher(pTHX_ PMOP *matcher);
7772 # define PERL_ARGS_ASSERT_DESTROY_MATCHER       \
7773         assert(matcher)
7774 
7775 STATIC OP *
7776 S_do_smartmatch(pTHX_ HV *seen_this, HV *seen_other, const bool copied);
7777 # define PERL_ARGS_ASSERT_DO_SMARTMATCH
7778 
7779 STATIC OP *
7780 S_docatch(pTHX_ Perl_ppaddr_t firstpp)
7781         __attribute__warn_unused_result__;
7782 # define PERL_ARGS_ASSERT_DOCATCH
7783 
7784 STATIC bool
7785 S_doeval_compile(pTHX_ U8 gimme, CV *outside, U32 seq, HV *hh);
7786 # define PERL_ARGS_ASSERT_DOEVAL_COMPILE
7787 
7788 STATIC OP *
7789 S_dofindlabel(pTHX_ OP *o, const char *label, STRLEN len, U32 flags, OP **opstack, OP **oplimit)
7790         __attribute__warn_unused_result__;
7791 # define PERL_ARGS_ASSERT_DOFINDLABEL           \
7792         assert(o); assert(label); assert(opstack); assert(oplimit)
7793 
7794 STATIC MAGIC *
7795 S_doparseform(pTHX_ SV *sv);
7796 # define PERL_ARGS_ASSERT_DOPARSEFORM           \
7797         assert(sv)
7798 
7799 STATIC I32
7800 S_dopoptoeval(pTHX_ I32 startingblock)
7801         __attribute__warn_unused_result__;
7802 # define PERL_ARGS_ASSERT_DOPOPTOEVAL
7803 
7804 STATIC I32
7805 S_dopoptogivenfor(pTHX_ I32 startingblock)
7806         __attribute__warn_unused_result__;
7807 # define PERL_ARGS_ASSERT_DOPOPTOGIVENFOR
7808 
7809 STATIC I32
7810 S_dopoptolabel(pTHX_ const char *label, STRLEN len, U32 flags)
7811         __attribute__warn_unused_result__;
7812 # define PERL_ARGS_ASSERT_DOPOPTOLABEL          \
7813         assert(label)
7814 
7815 STATIC I32
7816 S_dopoptoloop(pTHX_ I32 startingblock)
7817         __attribute__warn_unused_result__;
7818 # define PERL_ARGS_ASSERT_DOPOPTOLOOP
7819 
7820 STATIC I32
7821 S_dopoptosub_at(pTHX_ const PERL_CONTEXT *cxstk, I32 startingblock)
7822         __attribute__warn_unused_result__;
7823 # define PERL_ARGS_ASSERT_DOPOPTOSUB_AT         \
7824         assert(cxstk)
7825 
7826 STATIC I32
7827 S_dopoptowhen(pTHX_ I32 startingblock)
7828         __attribute__warn_unused_result__;
7829 # define PERL_ARGS_ASSERT_DOPOPTOWHEN
7830 
7831 STATIC PMOP *
7832 S_make_matcher(pTHX_ REGEXP *re)
7833         __attribute__warn_unused_result__;
7834 # define PERL_ARGS_ASSERT_MAKE_MATCHER          \
7835         assert(re)
7836 
7837 STATIC bool
7838 S_matcher_matches_sv(pTHX_ PMOP *matcher, SV *sv)
7839         __attribute__warn_unused_result__;
7840 # define PERL_ARGS_ASSERT_MATCHER_MATCHES_SV    \
7841         assert(matcher); assert(sv)
7842 
7843 STATIC bool
7844 S_num_overflow(NV value, I32 fldsize, I32 frcsize)
7845         __attribute__warn_unused_result__;
7846 # define PERL_ARGS_ASSERT_NUM_OVERFLOW
7847 
7848 STATIC I32
7849 S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen)
7850         __attribute__warn_unused_result__;
7851 # define PERL_ARGS_ASSERT_RUN_USER_FILTER       \
7852         assert(buf_sv)
7853 
7854 STATIC void
7855 S_rxres_free(pTHX_ void **rsp);
7856 # define PERL_ARGS_ASSERT_RXRES_FREE            \
7857         assert(rsp)
7858 
7859 STATIC void
7860 S_rxres_restore(pTHX_ void **rsp, REGEXP *rx);
7861 # define PERL_ARGS_ASSERT_RXRES_RESTORE         \
7862         assert(rsp); assert(rx)
7863 
7864 STATIC void
7865 S_save_lines(pTHX_ AV *array, SV *sv);
7866 # define PERL_ARGS_ASSERT_SAVE_LINES            \
7867         assert(sv)
7868 
7869 # if !defined(PERL_DISABLE_PMC)
7870 STATIC PerlIO *
7871 S_doopen_pm(pTHX_ SV *name)
7872         __attribute__warn_unused_result__;
7873 #   define PERL_ARGS_ASSERT_DOOPEN_PM           \
7874         assert(name)
7875 
7876 # endif
7877 # if !defined(PERL_NO_INLINE_FUNCTIONS)
7878 PERL_STATIC_INLINE bool
7879 S_path_is_searchable(const char *name)
7880         __attribute__warn_unused_result__;
7881 #   define PERL_ARGS_ASSERT_PATH_IS_SEARCHABLE  \
7882         assert(name)
7883 
7884 # endif
7885 #endif /* defined(PERL_IN_PP_CTL_C) */
7886 #if defined(PERL_IN_PP_CTL_C) || defined(PERL_IN_UTIL_C)
7887 PERL_CALLCONV bool
7888 Perl_invoke_exception_hook(pTHX_ SV *ex, bool warn)
7889         __attribute__visibility__("hidden");
7890 # define PERL_ARGS_ASSERT_INVOKE_EXCEPTION_HOOK
7891 
7892 #endif
7893 #if defined(PERL_IN_PP_HOT_C)
7894 STATIC void
7895 S_do_oddball(pTHX_ SV **oddkey, SV **firstkey);
7896 # define PERL_ARGS_ASSERT_DO_ODDBALL            \
7897         assert(oddkey); assert(firstkey)
7898 
7899 # if !defined(PERL_NO_INLINE_FUNCTIONS)
7900 PERL_STATIC_INLINE HV *
7901 S_opmethod_stash(pTHX_ SV *meth);
7902 #   define PERL_ARGS_ASSERT_OPMETHOD_STASH      \
7903         assert(meth)
7904 
7905 PERL_STATIC_FORCE_INLINE bool
7906 S_should_we_output_Debug_r(pTHX_ regexp *prog)
7907         __attribute__warn_unused_result__
7908         __attribute__always_inline__;
7909 #   define PERL_ARGS_ASSERT_SHOULD_WE_OUTPUT_DEBUG_R \
7910         assert(prog)
7911 
7912 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */
7913 #endif /* defined(PERL_IN_PP_HOT_C) */
7914 #if defined(PERL_IN_PP_PACK_C)
7915 STATIC int
7916 S_div128(pTHX_ SV *pnum, bool *done);
7917 # define PERL_ARGS_ASSERT_DIV128                \
7918         assert(pnum); assert(done)
7919 
7920 STATIC char
7921 S_first_symbol(const char *pat, const char *patend);
7922 # define PERL_ARGS_ASSERT_FIRST_SYMBOL          \
7923         assert(pat); assert(patend)
7924 
7925 STATIC const char *
7926 S_get_num(pTHX_ const char *patptr, SSize_t *lenptr)
7927         __attribute__warn_unused_result__;
7928 # define PERL_ARGS_ASSERT_GET_NUM               \
7929         assert(patptr); assert(lenptr)
7930 
7931 STATIC const char *
7932 S_group_end(pTHX_ const char *patptr, const char *patend, char ender);
7933 # define PERL_ARGS_ASSERT_GROUP_END             \
7934         assert(patptr); assert(patend)
7935 
7936 STATIC SV *
7937 S_is_an_int(pTHX_ const char *s, STRLEN l)
7938         __attribute__warn_unused_result__;
7939 # define PERL_ARGS_ASSERT_IS_AN_INT             \
7940         assert(s)
7941 
7942 STATIC SSize_t
7943 S_measure_struct(pTHX_ struct tempsym *symptr);
7944 # define PERL_ARGS_ASSERT_MEASURE_STRUCT        \
7945         assert(symptr)
7946 
7947 STATIC SV *
7948 S_mul128(pTHX_ SV *sv, U8 m);
7949 # define PERL_ARGS_ASSERT_MUL128                \
7950         assert(sv)
7951 
7952 STATIC char *
7953 S_my_bytes_to_utf8(const U8 *start, STRLEN len, char *dest, const bool needs_swap)
7954         __attribute__warn_unused_result__;
7955 # define PERL_ARGS_ASSERT_MY_BYTES_TO_UTF8      \
7956         assert(start); assert(dest)
7957 
7958 STATIC bool
7959 S_need_utf8(const char *pat, const char *patend);
7960 # define PERL_ARGS_ASSERT_NEED_UTF8             \
7961         assert(pat); assert(patend)
7962 
7963 STATIC bool
7964 S_next_symbol(pTHX_ struct tempsym *symptr);
7965 # define PERL_ARGS_ASSERT_NEXT_SYMBOL           \
7966         assert(symptr)
7967 
7968 STATIC SV **
7969 S_pack_rec(pTHX_ SV *cat, struct tempsym *symptr, SV **beglist, SV **endlist);
7970 # define PERL_ARGS_ASSERT_PACK_REC              \
7971         assert(cat); assert(symptr); assert(beglist); assert(endlist)
7972 
7973 STATIC char *
7974 S_sv_exp_grow(pTHX_ SV *sv, STRLEN needed)
7975         __attribute__warn_unused_result__;
7976 # define PERL_ARGS_ASSERT_SV_EXP_GROW           \
7977         assert(sv)
7978 
7979 STATIC SSize_t
7980 S_unpack_rec(pTHX_ struct tempsym *symptr, const char *s, const char *strbeg, const char *strend, const char **new_s);
7981 # define PERL_ARGS_ASSERT_UNPACK_REC            \
7982         assert(symptr); assert(s); assert(strbeg); assert(strend)
7983 
7984 #endif /* defined(PERL_IN_PP_PACK_C) */
7985 #if defined(PERL_IN_PP_SORT_C)
7986 STATIC I32
7987 S_sortcv(pTHX_ SV * const a, SV * const b);
7988 # define PERL_ARGS_ASSERT_SORTCV                \
7989         assert(a); assert(b)
7990 
7991 STATIC I32
7992 S_sortcv_stacked(pTHX_ SV * const a, SV * const b);
7993 # define PERL_ARGS_ASSERT_SORTCV_STACKED        \
7994         assert(a); assert(b)
7995 
7996 STATIC I32
7997 S_sortcv_xsub(pTHX_ SV * const a, SV * const b);
7998 # define PERL_ARGS_ASSERT_SORTCV_XSUB           \
7999         assert(a); assert(b)
8000 
8001 # if !defined(PERL_NO_INLINE_FUNCTIONS)
8002 PERL_STATIC_INLINE I32
8003 S_amagic_cmp(pTHX_ SV * const str1, SV * const str2);
8004 #   define PERL_ARGS_ASSERT_AMAGIC_CMP          \
8005         assert(str1); assert(str2)
8006 
8007 PERL_STATIC_INLINE I32
8008 S_amagic_cmp_desc(pTHX_ SV * const str1, SV * const str2);
8009 #   define PERL_ARGS_ASSERT_AMAGIC_CMP_DESC     \
8010         assert(str1); assert(str2)
8011 
8012 PERL_STATIC_INLINE I32
8013 S_amagic_i_ncmp(pTHX_ SV * const a, SV * const b);
8014 #   define PERL_ARGS_ASSERT_AMAGIC_I_NCMP       \
8015         assert(a); assert(b)
8016 
8017 PERL_STATIC_INLINE I32
8018 S_amagic_i_ncmp_desc(pTHX_ SV * const a, SV * const b);
8019 #   define PERL_ARGS_ASSERT_AMAGIC_I_NCMP_DESC  \
8020         assert(a); assert(b)
8021 
8022 PERL_STATIC_INLINE I32
8023 S_amagic_ncmp(pTHX_ SV * const a, SV * const b);
8024 #   define PERL_ARGS_ASSERT_AMAGIC_NCMP         \
8025         assert(a); assert(b)
8026 
8027 PERL_STATIC_INLINE I32
8028 S_amagic_ncmp_desc(pTHX_ SV * const a, SV * const b);
8029 #   define PERL_ARGS_ASSERT_AMAGIC_NCMP_DESC    \
8030         assert(a); assert(b)
8031 
8032 PERL_STATIC_INLINE I32
8033 S_cmp_desc(pTHX_ SV * const str1, SV * const str2);
8034 #   define PERL_ARGS_ASSERT_CMP_DESC            \
8035         assert(str1); assert(str2)
8036 
8037 PERL_STATIC_FORCE_INLINE void
8038 S_sortsv_flags_impl(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp, U32 flags)
8039         __attribute__always_inline__;
8040 #   define PERL_ARGS_ASSERT_SORTSV_FLAGS_IMPL   \
8041         assert(cmp)
8042 
8043 PERL_STATIC_INLINE I32
8044 S_sv_i_ncmp(pTHX_ SV * const a, SV * const b);
8045 #   define PERL_ARGS_ASSERT_SV_I_NCMP           \
8046         assert(a); assert(b)
8047 
8048 PERL_STATIC_INLINE I32
8049 S_sv_i_ncmp_desc(pTHX_ SV * const a, SV * const b);
8050 #   define PERL_ARGS_ASSERT_SV_I_NCMP_DESC      \
8051         assert(a); assert(b)
8052 
8053 PERL_STATIC_INLINE I32
8054 S_sv_ncmp(pTHX_ SV * const a, SV * const b);
8055 #   define PERL_ARGS_ASSERT_SV_NCMP             \
8056         assert(a); assert(b)
8057 
8058 PERL_STATIC_INLINE I32
8059 S_sv_ncmp_desc(pTHX_ SV * const a, SV * const b);
8060 #   define PERL_ARGS_ASSERT_SV_NCMP_DESC        \
8061         assert(a); assert(b)
8062 
8063 #   if defined(USE_LOCALE_COLLATE)
8064 PERL_STATIC_INLINE I32
8065 S_amagic_cmp_locale(pTHX_ SV * const str1, SV * const str2);
8066 #     define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \
8067         assert(str1); assert(str2)
8068 
8069 PERL_STATIC_INLINE I32
8070 S_amagic_cmp_locale_desc(pTHX_ SV * const str1, SV * const str2);
8071 #     define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE_DESC \
8072         assert(str1); assert(str2)
8073 
8074 PERL_STATIC_INLINE I32
8075 S_cmp_locale_desc(pTHX_ SV * const str1, SV * const str2);
8076 #     define PERL_ARGS_ASSERT_CMP_LOCALE_DESC   \
8077         assert(str1); assert(str2)
8078 
8079 #   endif /* defined(USE_LOCALE_COLLATE) */
8080 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */
8081 #endif /* defined(PERL_IN_PP_SORT_C) */
8082 #if defined(PERL_IN_PP_SYS_C)
8083 STATIC OP *
8084 S_doform(pTHX_ CV *cv, GV *gv, OP *retop);
8085 # define PERL_ARGS_ASSERT_DOFORM                \
8086         assert(cv); assert(gv)
8087 
8088 STATIC SV *
8089 S_space_join_names_mortal(pTHX_ char * const *array);
8090 # define PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL
8091 
8092 # if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
8093 STATIC int
8094 S_dooneliner(pTHX_ const char *cmd, const char *filename)
8095         __attribute__warn_unused_result__;
8096 #   define PERL_ARGS_ASSERT_DOONELINER          \
8097         assert(cmd); assert(filename)
8098 
8099 # endif
8100 #endif /* defined(PERL_IN_PP_SYS_C) */
8101 #if defined(PERL_IN_REGCOMP_ANY)
8102 PERL_CALLCONV void
8103 Perl_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV **invlist)
8104         __attribute__visibility__("hidden");
8105 # define PERL_ARGS_ASSERT_ADD_ABOVE_LATIN1_FOLDS \
8106         assert(pRExC_state); assert(invlist)
8107 
8108 PERL_CALLCONV regnode *
8109 Perl_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *source, U32 depth)
8110         __attribute__visibility__("hidden");
8111 # define PERL_ARGS_ASSERT_CONSTRUCT_AHOCORASICK_FROM_TRIE \
8112         assert(pRExC_state); assert(source)
8113 
8114 PERL_CALLCONV SV *
8115 Perl_get_ANYOFHbbm_contents(pTHX_ const regnode *n)
8116         __attribute__warn_unused_result__
8117         __attribute__visibility__("hidden");
8118 # define PERL_ARGS_ASSERT_GET_ANYOFHBBM_CONTENTS \
8119         assert(n)
8120 
8121 PERL_CALLCONV SV *
8122 Perl_get_ANYOFM_contents(pTHX_ const regnode *n)
8123         __attribute__warn_unused_result__
8124         __attribute__visibility__("hidden");
8125 # define PERL_ARGS_ASSERT_GET_ANYOFM_CONTENTS   \
8126         assert(n)
8127 
8128 PERL_CALLCONV U32
8129 Perl_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, UV *min_subtract, bool *unfolded_multi_char, U32 flags, regnode *val, U32 depth)
8130         __attribute__visibility__("hidden");
8131 # define PERL_ARGS_ASSERT_JOIN_EXACT            \
8132         assert(pRExC_state); assert(scan); assert(min_subtract); assert(unfolded_multi_char)
8133 
8134 PERL_CALLCONV I32
8135 Perl_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *first, regnode *last, regnode *tail, U32 word_count, U32 flags, U32 depth)
8136         __attribute__visibility__("hidden");
8137 # define PERL_ARGS_ASSERT_MAKE_TRIE             \
8138         assert(pRExC_state); assert(startbranch); assert(first); assert(last); \
8139         assert(tail)
8140 
8141 PERL_CALLCONV void
8142 Perl_populate_anyof_bitmap_from_invlist(pTHX_ regnode *node, SV **invlist_ptr)
8143         __attribute__visibility__("hidden");
8144 # define PERL_ARGS_ASSERT_POPULATE_ANYOF_BITMAP_FROM_INVLIST \
8145         assert(node); assert(invlist_ptr)
8146 
8147 PERL_CALLCONV U32
8148 Perl_reg_add_data(RExC_state_t * const pRExC_state, const char * const s, const U32 n)
8149         __attribute__warn_unused_result__
8150         __attribute__visibility__("hidden");
8151 # define PERL_ARGS_ASSERT_REG_ADD_DATA          \
8152         assert(pRExC_state); assert(s)
8153 
8154 PERL_CALLCONV void
8155 Perl_scan_commit(pTHX_ const RExC_state_t *pRExC_state, struct scan_data_t *data, SSize_t *minlenp, int is_inf)
8156         __attribute__visibility__("hidden");
8157 # define PERL_ARGS_ASSERT_SCAN_COMMIT           \
8158         assert(pRExC_state); assert(data); assert(minlenp)
8159 
8160 PERL_CALLCONV void
8161 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)
8162         __attribute__visibility__("hidden");
8163 # define PERL_ARGS_ASSERT_SET_ANYOF_ARG         \
8164         assert(pRExC_state); assert(node)
8165 
8166 PERL_CALLCONV void
8167 Perl_ssc_init(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc)
8168         __attribute__visibility__("hidden");
8169 # define PERL_ARGS_ASSERT_SSC_INIT              \
8170         assert(pRExC_state); assert(ssc)
8171 
8172 PERL_CALLCONV SSize_t
8173 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)
8174         __attribute__visibility__("hidden");
8175 # define PERL_ARGS_ASSERT_STUDY_CHUNK           \
8176         assert(pRExC_state); assert(scanp); assert(minlenp); assert(deltap); \
8177         assert(last)
8178 
8179 # if defined(PERL_IN_REGCOMP_TRIE_C) && defined(DEBUGGING)
8180 STATIC void
8181 S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV *widecharmap, AV *revcharmap, U32 depth);
8182 #   define PERL_ARGS_ASSERT_DUMP_TRIE           \
8183         assert(trie); assert(revcharmap)
8184 
8185 STATIC void
8186 S_dump_trie_interim_list(pTHX_ const struct _reg_trie_data *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth);
8187 #   define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_LIST \
8188         assert(trie); assert(revcharmap)
8189 
8190 STATIC void
8191 S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth);
8192 #   define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_TABLE \
8193         assert(trie); assert(revcharmap)
8194 
8195 # endif /* defined(PERL_IN_REGCOMP_TRIE_C) && defined(DEBUGGING) */
8196 # if !defined(PERL_NO_INLINE_FUNCTIONS)
8197 PERL_STATIC_INLINE SV *
8198 S_invlist_contents(pTHX_ SV * const invlist, const bool traditional_style)
8199         __attribute__warn_unused_result__;
8200 #   define PERL_ARGS_ASSERT_INVLIST_CONTENTS    \
8201         assert(invlist)
8202 
8203 PERL_STATIC_INLINE UV
8204 S_invlist_highest_range_start(SV * const invlist)
8205         __attribute__warn_unused_result__;
8206 #   define PERL_ARGS_ASSERT_INVLIST_HIGHEST_RANGE_START \
8207         assert(invlist)
8208 
8209 PERL_STATIC_INLINE bool
8210 S_invlist_is_iterating(const SV * const invlist)
8211         __attribute__warn_unused_result__;
8212 #   define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING \
8213         assert(invlist)
8214 
8215 PERL_STATIC_INLINE UV
8216 S_invlist_lowest(SV * const invlist)
8217         __attribute__warn_unused_result__;
8218 #   define PERL_ARGS_ASSERT_INVLIST_LOWEST      \
8219         assert(invlist)
8220 
8221 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */
8222 #endif /* defined(PERL_IN_REGCOMP_ANY) */
8223 #if defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_SV_C)
8224 PERL_CALLCONV SV *
8225 Perl_invlist_clone(pTHX_ SV * const invlist, SV *newlist);
8226 # define PERL_ARGS_ASSERT_INVLIST_CLONE         \
8227         assert(invlist)
8228 
8229 #endif
8230 #if defined(PERL_IN_REGCOMP_C)
8231 STATIC AV *
8232 S_add_multi_match(pTHX_ AV *multi_char_matches, SV *multi_string, const STRLEN cp_count);
8233 # define PERL_ARGS_ASSERT_ADD_MULTI_MATCH       \
8234         assert(multi_string)
8235 
8236 STATIC void
8237 S_change_engine_size(pTHX_ RExC_state_t *pRExC_state, const Ptrdiff_t size);
8238 # define PERL_ARGS_ASSERT_CHANGE_ENGINE_SIZE    \
8239         assert(pRExC_state)
8240 
8241 STATIC REGEXP *
8242 S_compile_wildcard(pTHX_ const char *subpattern, const STRLEN len, const bool ignore_case)
8243         __attribute__warn_unused_result__;
8244 # define PERL_ARGS_ASSERT_COMPILE_WILDCARD      \
8245         assert(subpattern)
8246 
8247 STATIC U8
8248 S_compute_EXACTish(RExC_state_t *pRExC_state);
8249 # define PERL_ARGS_ASSERT_COMPUTE_EXACTISH      \
8250         assert(pRExC_state)
8251 
8252 STATIC int
8253 S_edit_distance(const UV *src, const UV *tgt, const STRLEN x, const STRLEN y, const SSize_t maxDistance)
8254         __attribute__warn_unused_result__;
8255 # define PERL_ARGS_ASSERT_EDIT_DISTANCE         \
8256         assert(src); assert(tgt)
8257 
8258 STATIC I32
8259 S_execute_wildcard(pTHX_ REGEXP * const prog, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *screamer, U32 nosave);
8260 # define PERL_ARGS_ASSERT_EXECUTE_WILDCARD      \
8261         assert(prog); assert(stringarg); assert(strend); assert(strbeg); \
8262         assert(screamer)
8263 
8264 STATIC U32
8265 S_get_quantifier_value(pTHX_ RExC_state_t *pRExC_state, const char *start, const char *end);
8266 # define PERL_ARGS_ASSERT_GET_QUANTIFIER_VALUE  \
8267         assert(pRExC_state); assert(start); assert(end)
8268 
8269 STATIC bool
8270 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);
8271 # define PERL_ARGS_ASSERT_GROK_BSLASH_N         \
8272         assert(pRExC_state); assert(flagp)
8273 
8274 STATIC regnode_offset
8275 S_handle_named_backref(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, char *backref_parse_start, char ch);
8276 # define PERL_ARGS_ASSERT_HANDLE_NAMED_BACKREF  \
8277         assert(pRExC_state); assert(flagp); assert(backref_parse_start)
8278 
8279 STATIC bool
8280 S_handle_names_wildcard(pTHX_ const char *wname, const STRLEN wname_len, SV **prop_definition, AV **strings);
8281 # define PERL_ARGS_ASSERT_HANDLE_NAMES_WILDCARD \
8282         assert(wname); assert(prop_definition); assert(strings)
8283 
8284 STATIC int
8285 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);
8286 # define PERL_ARGS_ASSERT_HANDLE_POSSIBLE_POSIX \
8287         assert(pRExC_state); assert(s)
8288 
8289 STATIC regnode_offset
8290 S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV **return_invlist, I32 *flagp, U32 depth);
8291 # define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS     \
8292         assert(pRExC_state); assert(flagp)
8293 
8294 STATIC SV *
8295 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);
8296 # define PERL_ARGS_ASSERT_HANDLE_USER_DEFINED_PROPERTY \
8297         assert(name); assert(contents); assert(user_defined_ptr); assert(msg)
8298 
8299 STATIC bool
8300 S_is_ssc_worth_it(const RExC_state_t *pRExC_state, const regnode_ssc *ssc);
8301 # define PERL_ARGS_ASSERT_IS_SSC_WORTH_IT       \
8302         assert(pRExC_state); assert(ssc)
8303 
8304 STATIC void
8305 S_nextchar(pTHX_ RExC_state_t *pRExC_state);
8306 # define PERL_ARGS_ASSERT_NEXTCHAR              \
8307         assert(pRExC_state)
8308 
8309 STATIC U8
8310 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);
8311 # define PERL_ARGS_ASSERT_OPTIMIZE_REGCLASS     \
8312         assert(pRExC_state); assert(anyof_flags); assert(invert); assert(ret); \
8313         assert(flagp)
8314 
8315 STATIC void
8316 S_output_posix_warnings(pTHX_ RExC_state_t *pRExC_state, AV *posix_warnings);
8317 # define PERL_ARGS_ASSERT_OUTPUT_POSIX_WARNINGS \
8318         assert(pRExC_state); assert(posix_warnings)
8319 
8320 STATIC void
8321 S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state);
8322 # define PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS \
8323         assert(pRExC_state)
8324 
8325 STATIC SV *
8326 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);
8327 # define PERL_ARGS_ASSERT_PARSE_UNIPROP_STRING  \
8328         assert(name); assert(user_defined_ptr); assert(msg)
8329 
8330 PERL_STATIC_NO_RET void
8331 S_re_croak(pTHX_ bool utf8, const char *pat, ...)
8332         __attribute__noreturn__
8333         __attribute__format__(__printf__,pTHX_2,pTHX_3);
8334 # define PERL_ARGS_ASSERT_RE_CROAK              \
8335         assert(pat)
8336 
8337 STATIC regnode_offset
8338 S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth);
8339 # define PERL_ARGS_ASSERT_REG                   \
8340         assert(pRExC_state); assert(flagp)
8341 
8342 STATIC regnode_offset
8343 S_reg1node(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg);
8344 # define PERL_ARGS_ASSERT_REG1NODE              \
8345         assert(pRExC_state)
8346 
8347 STATIC regnode_offset
8348 S_reg2node(pTHX_ RExC_state_t *pRExC_state, const U8 op, const U32 arg1, const I32 arg2);
8349 # define PERL_ARGS_ASSERT_REG2NODE              \
8350         assert(pRExC_state)
8351 
8352 STATIC regnode_offset
8353 S_reg_la_NOTHING(pTHX_ RExC_state_t *pRExC_state, U32 flags, const char *type);
8354 # define PERL_ARGS_ASSERT_REG_LA_NOTHING        \
8355         assert(pRExC_state); assert(type)
8356 
8357 STATIC regnode_offset
8358 S_reg_la_OPFAIL(pTHX_ RExC_state_t *pRExC_state, U32 flags, const char *type);
8359 # define PERL_ARGS_ASSERT_REG_LA_OPFAIL         \
8360         assert(pRExC_state); assert(type)
8361 
8362 STATIC regnode_offset
8363 S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op);
8364 # define PERL_ARGS_ASSERT_REG_NODE              \
8365         assert(pRExC_state)
8366 
8367 STATIC SV *
8368 S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags);
8369 # define PERL_ARGS_ASSERT_REG_SCAN_NAME         \
8370         assert(pRExC_state)
8371 
8372 STATIC regnode_offset
8373 S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth);
8374 # define PERL_ARGS_ASSERT_REGATOM               \
8375         assert(pRExC_state); assert(flagp)
8376 
8377 STATIC regnode_offset
8378 S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth);
8379 # define PERL_ARGS_ASSERT_REGBRANCH             \
8380         assert(pRExC_state); assert(flagp)
8381 
8382 STATIC regnode_offset
8383 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);
8384 # define PERL_ARGS_ASSERT_REGCLASS              \
8385         assert(pRExC_state); assert(flagp)
8386 
8387 STATIC unsigned int
8388 S_regex_set_precedence(const U8 my_operator)
8389         __attribute__warn_unused_result__;
8390 # define PERL_ARGS_ASSERT_REGEX_SET_PRECEDENCE
8391 
8392 STATIC void
8393 S_reginsert(pTHX_ RExC_state_t *pRExC_state, const U8 op, const regnode_offset operand, const U32 depth);
8394 # define PERL_ARGS_ASSERT_REGINSERT             \
8395         assert(pRExC_state)
8396 
8397 STATIC regnode_offset
8398 S_regnode_guts(pTHX_ RExC_state_t *pRExC_state, const STRLEN extra_len);
8399 # define PERL_ARGS_ASSERT_REGNODE_GUTS          \
8400         assert(pRExC_state)
8401 
8402 STATIC regnode_offset
8403 S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth);
8404 # define PERL_ARGS_ASSERT_REGPIECE              \
8405         assert(pRExC_state); assert(flagp)
8406 
8407 STATIC regnode_offset
8408 S_regpnode(pTHX_ RExC_state_t *pRExC_state, U8 op, SV *arg);
8409 # define PERL_ARGS_ASSERT_REGPNODE              \
8410         assert(pRExC_state); assert(arg)
8411 
8412 STATIC bool
8413 S_regtail(pTHX_ RExC_state_t *pRExC_state, const regnode_offset p, const regnode_offset val, const U32 depth)
8414         __attribute__warn_unused_result__;
8415 # define PERL_ARGS_ASSERT_REGTAIL               \
8416         assert(pRExC_state); assert(p); assert(val)
8417 
8418 STATIC void
8419 S_set_regex_pv(pTHX_ RExC_state_t *pRExC_state, REGEXP *Rx);
8420 # define PERL_ARGS_ASSERT_SET_REGEX_PV          \
8421         assert(pRExC_state); assert(Rx)
8422 
8423 STATIC void
8424 S_skip_to_be_ignored_text(pTHX_ RExC_state_t *pRExC_state, char **p, const bool force_to_xmod);
8425 # define PERL_ARGS_ASSERT_SKIP_TO_BE_IGNORED_TEXT \
8426         assert(pRExC_state); assert(p)
8427 
8428 STATIC void
8429 S_ssc_finalize(pTHX_ RExC_state_t *pRExC_state, regnode_ssc *ssc);
8430 # define PERL_ARGS_ASSERT_SSC_FINALIZE          \
8431         assert(pRExC_state); assert(ssc)
8432 
8433 # if defined(DEBUGGING)
8434 STATIC regnode_offset
8435 S_regnode_guts_debug(pTHX_ RExC_state_t *pRExC_state, const U8 op, const STRLEN extra_len);
8436 #   define PERL_ARGS_ASSERT_REGNODE_GUTS_DEBUG  \
8437         assert(pRExC_state)
8438 
8439 STATIC bool
8440 S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode_offset p, const regnode_offset val, U32 depth)
8441         __attribute__warn_unused_result__;
8442 #   define PERL_ARGS_ASSERT_REGTAIL_STUDY       \
8443         assert(pRExC_state); assert(p); assert(val)
8444 
8445 #   if defined(ENABLE_REGEX_SETS_DEBUGGING)
8446 STATIC void
8447 S_dump_regex_sets_structures(pTHX_ RExC_state_t *pRExC_state, AV *stack, const IV fence, AV *fence_stack);
8448 #     define PERL_ARGS_ASSERT_DUMP_REGEX_SETS_STRUCTURES \
8449         assert(pRExC_state); assert(stack); assert(fence_stack)
8450 
8451 #   endif
8452 # endif /* defined(DEBUGGING) */
8453 # if !defined(PERL_NO_INLINE_FUNCTIONS)
8454 PERL_STATIC_INLINE Size_t
8455 S_find_first_differing_byte_pos(const U8 *s1, const U8 *s2, const Size_t max);
8456 #   define PERL_ARGS_ASSERT_FIND_FIRST_DIFFERING_BYTE_POS \
8457         assert(s1); assert(s2)
8458 
8459 PERL_STATIC_INLINE char *
8460 S_reg_skipcomment(RExC_state_t *pRExC_state, char *p);
8461 #   define PERL_ARGS_ASSERT_REG_SKIPCOMMENT     \
8462         assert(pRExC_state); assert(p)
8463 
8464 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */
8465 #endif /* defined(PERL_IN_REGCOMP_C) */
8466 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGCOMP_INVLIST_C)
8467 PERL_CALLCONV void
8468 Perl_populate_bitmap_from_invlist(pTHX_ SV *invlist, const UV offset, const U8 *bitmap, const Size_t len)
8469         __attribute__visibility__("hidden");
8470 # define PERL_ARGS_ASSERT_POPULATE_BITMAP_FROM_INVLIST \
8471         assert(invlist); assert(bitmap)
8472 
8473 PERL_CALLCONV void
8474 Perl_populate_invlist_from_bitmap(pTHX_ const U8 *bitmap, const Size_t bitmap_len, SV **invlist, const UV offset)
8475         __attribute__visibility__("hidden");
8476 # define PERL_ARGS_ASSERT_POPULATE_INVLIST_FROM_BITMAP \
8477         assert(bitmap); assert(invlist)
8478 
8479 #endif /* defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGCOMP_INVLIST_C) */
8480 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || \
8481     defined(PERL_IN_TOKE_C)
8482 PERL_CALLCONV bool
8483 Perl_is_grapheme(pTHX_ const U8 *strbeg, const U8 *s, const U8 *strend, const UV cp)
8484         __attribute__warn_unused_result__
8485         __attribute__visibility__("hidden");
8486 # define PERL_ARGS_ASSERT_IS_GRAPHEME           \
8487         assert(strbeg); assert(s); assert(strend)
8488 
8489 #endif
8490 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || \
8491     defined(PERL_IN_UTF8_C)
8492 PERL_CALLCONV UV
8493 Perl__to_fold_latin1(const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags);
8494 # define PERL_ARGS_ASSERT__TO_FOLD_LATIN1       \
8495         assert(p); assert(lenp)
8496 
8497 #endif
8498 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C)
8499 PERL_CALLCONV bool
8500 Perl_regcurly(const char *s, const char *e, const char *result[5])
8501         __attribute__warn_unused_result__;
8502 # define PERL_ARGS_ASSERT_REGCURLY              \
8503         assert(s); assert(e)
8504 
8505 #endif
8506 #if defined(PERL_IN_REGCOMP_DEBUG_C) && defined(DEBUGGING)
8507 STATIC U8
8508 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);
8509 # define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS \
8510         assert(sv)
8511 
8512 STATIC SV *
8513 S_put_charclass_bitmap_innards_common(pTHX_ SV *invlist, SV *posixes, SV *only_utf8, SV *not_utf8, SV *only_utf8_locale, const bool invert);
8514 # define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS_COMMON \
8515         assert(invlist)
8516 
8517 STATIC void
8518 S_put_charclass_bitmap_innards_invlist(pTHX_ SV *sv, SV *invlist);
8519 # define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS_INVLIST \
8520         assert(sv); assert(invlist)
8521 
8522 STATIC void
8523 S_put_code_point(pTHX_ SV *sv, UV c);
8524 # define PERL_ARGS_ASSERT_PUT_CODE_POINT        \
8525         assert(sv)
8526 
8527 STATIC void
8528 S_put_range(pTHX_ SV *sv, UV start, const UV end, const bool allow_literals);
8529 # define PERL_ARGS_ASSERT_PUT_RANGE             \
8530         assert(sv)
8531 
8532 STATIC void
8533 S_regdump_extflags(pTHX_ const char *lead, const U32 flags);
8534 # define PERL_ARGS_ASSERT_REGDUMP_EXTFLAGS
8535 
8536 STATIC void
8537 S_regdump_intflags(pTHX_ const char *lead, const U32 flags);
8538 # define PERL_ARGS_ASSERT_REGDUMP_INTFLAGS
8539 
8540 #endif /* defined(PERL_IN_REGCOMP_DEBUG_C) && defined(DEBUGGING) */
8541 #if defined(PERL_IN_REGCOMP_INVLIST_C) && !defined(PERL_EXT_RE_BUILD)
8542 STATIC void
8543 S__append_range_to_invlist(pTHX_ SV * const invlist, const UV start, const UV end);
8544 # define PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST \
8545         assert(invlist)
8546 
8547 STATIC void
8548 S_initialize_invlist_guts(pTHX_ SV *invlist, const Size_t initial_size);
8549 # define PERL_ARGS_ASSERT_INITIALIZE_INVLIST_GUTS \
8550         assert(invlist)
8551 
8552 STATIC void
8553 S_invlist_replace_list_destroys_src(pTHX_ SV *dest, SV *src);
8554 # define PERL_ARGS_ASSERT_INVLIST_REPLACE_LIST_DESTROYS_SRC \
8555         assert(dest); assert(src)
8556 
8557 # if !defined(PERL_NO_INLINE_FUNCTIONS)
8558 PERL_STATIC_INLINE UV *
8559 S__invlist_array_init(SV * const invlist, const bool will_have_0)
8560         __attribute__warn_unused_result__;
8561 #   define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT \
8562         assert(invlist)
8563 
8564 PERL_STATIC_INLINE IV *
8565 S_get_invlist_previous_index_addr(SV *invlist)
8566         __attribute__warn_unused_result__;
8567 #   define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR \
8568         assert(invlist)
8569 
8570 PERL_STATIC_INLINE void
8571 S_invlist_clear(pTHX_ SV *invlist);
8572 #   define PERL_ARGS_ASSERT_INVLIST_CLEAR       \
8573         assert(invlist)
8574 
8575 PERL_STATIC_INLINE UV
8576 S_invlist_max(const SV * const invlist)
8577         __attribute__warn_unused_result__;
8578 #   define PERL_ARGS_ASSERT_INVLIST_MAX         \
8579         assert(invlist)
8580 
8581 PERL_STATIC_INLINE IV
8582 S_invlist_previous_index(SV * const invlist)
8583         __attribute__warn_unused_result__;
8584 #   define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX \
8585         assert(invlist)
8586 
8587 PERL_STATIC_INLINE void
8588 S_invlist_set_previous_index(SV * const invlist, const IV index);
8589 #   define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX \
8590         assert(invlist)
8591 
8592 PERL_STATIC_INLINE void
8593 S_invlist_trim(SV *invlist);
8594 #   define PERL_ARGS_ASSERT_INVLIST_TRIM        \
8595         assert(invlist)
8596 
8597 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */
8598 #endif /* defined(PERL_IN_REGCOMP_INVLIST_C) && !defined(PERL_EXT_RE_BUILD) */
8599 #if defined(PERL_IN_REGCOMP_STUDY_C)
8600 STATIC SV *
8601 S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, const regnode_charclass * const node);
8602 # define PERL_ARGS_ASSERT_GET_ANYOF_CP_LIST_FOR_SSC \
8603         assert(pRExC_state); assert(node)
8604 
8605 STATIC SV *
8606 S_make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node)
8607         __attribute__warn_unused_result__;
8608 # define PERL_ARGS_ASSERT_MAKE_EXACTF_INVLIST   \
8609         assert(pRExC_state); assert(node)
8610 
8611 STATIC void
8612 S_rck_elide_nothing(pTHX_ regnode *node);
8613 # define PERL_ARGS_ASSERT_RCK_ELIDE_NOTHING     \
8614         assert(node)
8615 
8616 STATIC void
8617 S_ssc_add_range(pTHX_ regnode_ssc *ssc, UV const start, UV const end);
8618 # define PERL_ARGS_ASSERT_SSC_ADD_RANGE         \
8619         assert(ssc)
8620 
8621 STATIC void
8622 S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *and_with);
8623 # define PERL_ARGS_ASSERT_SSC_AND               \
8624         assert(pRExC_state); assert(ssc); assert(and_with)
8625 
8626 STATIC void
8627 S_ssc_anything(pTHX_ regnode_ssc *ssc);
8628 # define PERL_ARGS_ASSERT_SSC_ANYTHING          \
8629         assert(ssc)
8630 
8631 STATIC void
8632 S_ssc_clear_locale(regnode_ssc *ssc);
8633 # define PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE      \
8634         assert(ssc)
8635 
8636 STATIC void
8637 S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp);
8638 # define PERL_ARGS_ASSERT_SSC_CP_AND            \
8639         assert(ssc)
8640 
8641 STATIC void
8642 S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV * const invlist, const bool invert_2nd);
8643 # define PERL_ARGS_ASSERT_SSC_INTERSECTION      \
8644         assert(ssc); assert(invlist)
8645 
8646 STATIC int
8647 S_ssc_is_anything(const regnode_ssc *ssc)
8648         __attribute__warn_unused_result__;
8649 # define PERL_ARGS_ASSERT_SSC_IS_ANYTHING       \
8650         assert(ssc)
8651 
8652 STATIC int
8653 S_ssc_is_cp_posixl_init(const RExC_state_t *pRExC_state, const regnode_ssc *ssc)
8654         __attribute__warn_unused_result__;
8655 # define PERL_ARGS_ASSERT_SSC_IS_CP_POSIXL_INIT \
8656         assert(pRExC_state); assert(ssc)
8657 
8658 STATIC void
8659 S_ssc_or(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *or_with);
8660 # define PERL_ARGS_ASSERT_SSC_OR                \
8661         assert(pRExC_state); assert(ssc); assert(or_with)
8662 
8663 STATIC void
8664 S_ssc_union(pTHX_ regnode_ssc *ssc, SV * const invlist, const bool invert_2nd);
8665 # define PERL_ARGS_ASSERT_SSC_UNION             \
8666         assert(ssc); assert(invlist)
8667 
8668 STATIC void
8669 S_unwind_scan_frames(pTHX_ const void *p);
8670 # define PERL_ARGS_ASSERT_UNWIND_SCAN_FRAMES    \
8671         assert(p)
8672 
8673 #endif /* defined(PERL_IN_REGCOMP_STUDY_C) */
8674 #if defined(PERL_IN_REGEXEC_C)
8675 STATIC LB_enum
8676 S_advance_one_LB(pTHX_ U8 **curpos, const U8 * const strend, const bool utf8_target)
8677         __attribute__warn_unused_result__;
8678 # define PERL_ARGS_ASSERT_ADVANCE_ONE_LB        \
8679         assert(curpos); assert(strend)
8680 
8681 STATIC SB_enum
8682 S_advance_one_SB(pTHX_ U8 **curpos, const U8 * const strend, const bool utf8_target)
8683         __attribute__warn_unused_result__;
8684 # define PERL_ARGS_ASSERT_ADVANCE_ONE_SB        \
8685         assert(curpos); assert(strend)
8686 
8687 STATIC WB_enum
8688 S_advance_one_WB(pTHX_ U8 **curpos, const U8 * const strend, const bool utf8_target, const bool skip_Extend_Format)
8689         __attribute__warn_unused_result__;
8690 # define PERL_ARGS_ASSERT_ADVANCE_ONE_WB        \
8691         assert(curpos); assert(strend)
8692 
8693 STATIC GCB_enum
8694 S_backup_one_GCB(pTHX_ const U8 * const strbeg, U8 **curpos, const bool utf8_target)
8695         __attribute__warn_unused_result__;
8696 # define PERL_ARGS_ASSERT_BACKUP_ONE_GCB        \
8697         assert(strbeg); assert(curpos)
8698 
8699 STATIC LB_enum
8700 S_backup_one_LB(pTHX_ const U8 * const strbeg, U8 **curpos, const bool utf8_target)
8701         __attribute__warn_unused_result__;
8702 # define PERL_ARGS_ASSERT_BACKUP_ONE_LB         \
8703         assert(strbeg); assert(curpos)
8704 
8705 STATIC SB_enum
8706 S_backup_one_SB(pTHX_ const U8 * const strbeg, U8 **curpos, const bool utf8_target)
8707         __attribute__warn_unused_result__;
8708 # define PERL_ARGS_ASSERT_BACKUP_ONE_SB         \
8709         assert(strbeg); assert(curpos)
8710 
8711 STATIC WB_enum
8712 S_backup_one_WB(pTHX_ WB_enum *previous, const U8 * const strbeg, U8 **curpos, const bool utf8_target)
8713         __attribute__warn_unused_result__;
8714 # define PERL_ARGS_ASSERT_BACKUP_ONE_WB         \
8715         assert(previous); assert(strbeg); assert(curpos)
8716 
8717 STATIC char *
8718 S_find_byclass(pTHX_ regexp *prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo)
8719         __attribute__warn_unused_result__;
8720 # define PERL_ARGS_ASSERT_FIND_BYCLASS          \
8721         assert(prog); assert(c); assert(s); assert(strend)
8722 
8723 STATIC U8 *
8724 S_find_next_masked(U8 *s, const U8 *send, const U8 byte, const U8 mask)
8725         __attribute__warn_unused_result__;
8726 # define PERL_ARGS_ASSERT_FIND_NEXT_MASKED      \
8727         assert(s); assert(send)
8728 
8729 STATIC U8 *
8730 S_find_span_end(U8 *s, const U8 *send, const U8 span_byte)
8731         __attribute__warn_unused_result__;
8732 # define PERL_ARGS_ASSERT_FIND_SPAN_END         \
8733         assert(s); assert(send)
8734 
8735 STATIC U8 *
8736 S_find_span_end_mask(U8 *s, const U8 *send, const U8 span_byte, const U8 mask)
8737         __attribute__warn_unused_result__;
8738 # define PERL_ARGS_ASSERT_FIND_SPAN_END_MASK    \
8739         assert(s); assert(send)
8740 
8741 STATIC bool
8742 S_isFOO_lc(pTHX_ const U8 classnum, const U8 character)
8743         __attribute__warn_unused_result__;
8744 # define PERL_ARGS_ASSERT_ISFOO_LC
8745 
8746 STATIC bool
8747 S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8 *character, const U8 *e)
8748         __attribute__warn_unused_result__;
8749 # define PERL_ARGS_ASSERT_ISFOO_UTF8_LC         \
8750         assert(character); assert(e)
8751 
8752 STATIC bool
8753 S_isGCB(pTHX_ const GCB_enum before, const GCB_enum after, const U8 * const strbeg, const U8 * const curpos, const bool utf8_target)
8754         __attribute__warn_unused_result__;
8755 # define PERL_ARGS_ASSERT_ISGCB                 \
8756         assert(strbeg); assert(curpos)
8757 
8758 STATIC bool
8759 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)
8760         __attribute__warn_unused_result__;
8761 # define PERL_ARGS_ASSERT_ISLB                  \
8762         assert(strbeg); assert(curpos); assert(strend)
8763 
8764 STATIC bool
8765 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)
8766         __attribute__warn_unused_result__;
8767 # define PERL_ARGS_ASSERT_ISSB                  \
8768         assert(strbeg); assert(curpos); assert(strend)
8769 
8770 STATIC bool
8771 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)
8772         __attribute__warn_unused_result__;
8773 # define PERL_ARGS_ASSERT_ISWB                  \
8774         assert(strbeg); assert(curpos); assert(strend)
8775 
8776 STATIC I32
8777 S_reg_check_named_buff_matched(const regexp *rex, const regnode *scan)
8778         __attribute__warn_unused_result__;
8779 # define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED \
8780         assert(rex); assert(scan)
8781 
8782 STATIC void
8783 S_regcp_restore(pTHX_ regexp *rex, I32 ix, U32 *maxopenparen_p comma_pDEPTH);
8784 # define PERL_ARGS_ASSERT_REGCP_RESTORE         \
8785         assert(rex); assert(maxopenparen_p)
8786 
8787 STATIC void
8788 S_regcppop(pTHX_ regexp *rex, U32 *maxopenparen_p comma_pDEPTH);
8789 # define PERL_ARGS_ASSERT_REGCPPOP              \
8790         assert(rex); assert(maxopenparen_p)
8791 
8792 STATIC CHECKPOINT
8793 S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen comma_pDEPTH);
8794 # define PERL_ARGS_ASSERT_REGCPPUSH             \
8795         assert(rex)
8796 
8797 STATIC U8 *
8798 S_reghop3(U8 *s, SSize_t off, const U8 *lim)
8799         __attribute__warn_unused_result__;
8800 # define PERL_ARGS_ASSERT_REGHOP3               \
8801         assert(s); assert(lim)
8802 
8803 STATIC U8 *
8804 S_reghop4(U8 *s, SSize_t off, const U8 *llim, const U8 *rlim)
8805         __attribute__warn_unused_result__;
8806 # define PERL_ARGS_ASSERT_REGHOP4               \
8807         assert(s); assert(llim); assert(rlim)
8808 
8809 STATIC U8 *
8810 S_reghopmaybe3(U8 *s, SSize_t off, const U8 * const lim)
8811         __attribute__warn_unused_result__;
8812 # define PERL_ARGS_ASSERT_REGHOPMAYBE3          \
8813         assert(s); assert(lim)
8814 
8815 STATIC bool
8816 S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8 * const p, const U8 * const p_end, bool const utf8_target)
8817         __attribute__warn_unused_result__;
8818 # define PERL_ARGS_ASSERT_REGINCLASS            \
8819         assert(n); assert(p); assert(p_end)
8820 
8821 STATIC SSize_t
8822 S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog)
8823         __attribute__warn_unused_result__;
8824 # define PERL_ARGS_ASSERT_REGMATCH              \
8825         assert(reginfo); assert(startpos); assert(prog)
8826 
8827 STATIC I32
8828 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, char *loceol, regmatch_info * const reginfo, I32 max comma_pDEPTH)
8829         __attribute__warn_unused_result__;
8830 # define PERL_ARGS_ASSERT_REGREPEAT             \
8831         assert(prog); assert(startposp); assert(p); assert(loceol); assert(reginfo); \
8832         assert(max)
8833 
8834 STATIC bool
8835 S_regtry(pTHX_ regmatch_info *reginfo, char **startposp)
8836         __attribute__warn_unused_result__;
8837 # define PERL_ARGS_ASSERT_REGTRY                \
8838         assert(reginfo); assert(startposp)
8839 
8840 STATIC bool
8841 S_to_byte_substr(pTHX_ regexp *prog);
8842 # define PERL_ARGS_ASSERT_TO_BYTE_SUBSTR        \
8843         assert(prog)
8844 
8845 STATIC void
8846 S_to_utf8_substr(pTHX_ regexp *prog);
8847 # define PERL_ARGS_ASSERT_TO_UTF8_SUBSTR        \
8848         assert(prog)
8849 
8850 # if defined(DEBUGGING)
8851 STATIC void
8852 S_debug_start_match(pTHX_ const REGEXP *prog, const bool do_utf8, const char *start, const char *end, const char *blurb);
8853 #   define PERL_ARGS_ASSERT_DEBUG_START_MATCH   \
8854         assert(prog); assert(start); assert(end); assert(blurb)
8855 
8856 STATIC void
8857 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);
8858 #   define PERL_ARGS_ASSERT_DUMP_EXEC_POS       \
8859         assert(locinput); assert(scan); assert(loc_regeol); assert(loc_bostr); \
8860         assert(loc_reg_starttry)
8861 
8862 PERL_CALLCONV int
8863 Perl_re_exec_indentf(pTHX_ const char *fmt, U32 depth, ...)
8864         __attribute__visibility__("hidden");
8865 #   define PERL_ARGS_ASSERT_RE_EXEC_INDENTF     \
8866         assert(fmt)
8867 
8868 # endif /* defined(DEBUGGING) */
8869 # if !defined(PERL_NO_INLINE_FUNCTIONS)
8870 PERL_STATIC_INLINE void
8871 S_capture_clear(pTHX_ regexp *rex, U16 from_ix, U16 to_ix, const char *str comma_pDEPTH);
8872 #   define PERL_ARGS_ASSERT_CAPTURE_CLEAR       \
8873         assert(rex); assert(str)
8874 
8875 PERL_STATIC_INLINE I32
8876 S_foldEQ_latin1_s2_folded(pTHX_ const char *a, const char *b, I32 len);
8877 #   define PERL_ARGS_ASSERT_FOLDEQ_LATIN1_S2_FOLDED \
8878         assert(a); assert(b)
8879 
8880 PERL_STATIC_INLINE void
8881 S_unwind_paren(pTHX_ regexp *rex, U32 lp, U32 lcp comma_pDEPTH);
8882 #   define PERL_ARGS_ASSERT_UNWIND_PAREN        \
8883         assert(rex)
8884 
8885 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */
8886 #endif /* defined(PERL_IN_REGEXEC_C) */
8887 #if defined(PERL_IN_REGEX_ENGINE)
8888 
8889 # if defined(DEBUGGING)
8890 PERL_CALLCONV void
8891 Perl_debug_peep(pTHX_ const char *str, const RExC_state_t *pRExC_state, regnode *scan, U32 depth, U32 flags)
8892         __attribute__visibility__("hidden");
8893 #   define PERL_ARGS_ASSERT_DEBUG_PEEP          \
8894         assert(str); assert(pRExC_state)
8895 
8896 PERL_CALLCONV void
8897 Perl_debug_show_study_flags(pTHX_ U32 flags, const char *open_str, const char *close_str)
8898         __attribute__visibility__("hidden");
8899 #   define PERL_ARGS_ASSERT_DEBUG_SHOW_STUDY_FLAGS \
8900         assert(open_str); assert(close_str)
8901 
8902 PERL_CALLCONV void
8903 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)
8904         __attribute__visibility__("hidden");
8905 #   define PERL_ARGS_ASSERT_DEBUG_STUDYDATA     \
8906         assert(where)
8907 
8908 PERL_CALLCONV const regnode *
8909 Perl_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node, const regnode *last, const regnode *plast, SV *sv, I32 indent, U32 depth)
8910         __attribute__visibility__("hidden");
8911 #   define PERL_ARGS_ASSERT_DUMPUNTIL           \
8912         assert(r); assert(start); assert(node); assert(sv)
8913 
8914 PERL_CALLCONV int
8915 Perl_re_indentf(pTHX_ const char *fmt, U32 depth, ...)
8916         __attribute__visibility__("hidden");
8917 #   define PERL_ARGS_ASSERT_RE_INDENTF          \
8918         assert(fmt)
8919 
8920 PERL_CALLCONV int
8921 Perl_re_printf(pTHX_ const char *fmt, ...)
8922         __attribute__visibility__("hidden")
8923         __attribute__format__(__printf__,pTHX_1,pTHX_2);
8924 #   define PERL_ARGS_ASSERT_RE_PRINTF           \
8925         assert(fmt)
8926 
8927 PERL_CALLCONV void
8928 Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_info *reginfo, const RExC_state_t *pRExC_state)
8929         __attribute__visibility__("hidden");
8930 #   define PERL_ARGS_ASSERT_REGPROP             \
8931         assert(sv); assert(o)
8932 
8933 # endif /* defined(DEBUGGING) */
8934 # if defined(PERL_EXT_RE_BUILD)
8935 PERL_CALLCONV SV *
8936 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)
8937         __attribute__visibility__("hidden");
8938 #   define PERL_ARGS_ASSERT_GET_RE_GCLASS_AUX_DATA \
8939         assert(node)
8940 
8941 # else
8942 PERL_CALLCONV SV *
8943 Perl_get_regclass_aux_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV **output_invlist)
8944         __attribute__visibility__("hidden");
8945 #   define PERL_ARGS_ASSERT_GET_REGCLASS_AUX_DATA \
8946         assert(node)
8947 
8948 # endif
8949 # if !defined(PERL_NO_INLINE_FUNCTIONS)
8950 PERL_STATIC_INLINE bool
8951 Perl_check_regnode_after(pTHX_ const regnode *p, const STRLEN extra)
8952         __attribute__warn_unused_result__;
8953 #   define PERL_ARGS_ASSERT_CHECK_REGNODE_AFTER
8954 
8955 PERL_STATIC_INLINE regnode *
8956 Perl_regnext(pTHX_ const regnode *p)
8957         __attribute__warn_unused_result__;
8958 #   define PERL_ARGS_ASSERT_REGNEXT
8959 
8960 PERL_STATIC_INLINE regnode *
8961 Perl_regnode_after(pTHX_ const regnode *p, bool varies)
8962         __attribute__warn_unused_result__;
8963 #   define PERL_ARGS_ASSERT_REGNODE_AFTER
8964 
8965 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */
8966 #endif /* defined(PERL_IN_REGEX_ENGINE) */
8967 #if defined(PERL_IN_SCOPE_C)
8968 STATIC void
8969 S_save_pushptri32ptr(pTHX_ void * const ptr1, const I32 i, void * const ptr2, const int type);
8970 # define PERL_ARGS_ASSERT_SAVE_PUSHPTRI32PTR
8971 
8972 STATIC SV *
8973 S_save_scalar_at(pTHX_ SV **sptr, const U32 flags);
8974 # define PERL_ARGS_ASSERT_SAVE_SCALAR_AT        \
8975         assert(sptr)
8976 
8977 #endif /* defined(PERL_IN_SCOPE_C) */
8978 #if defined(PERL_IN_SV_C)
8979 STATIC char *
8980 S_F0convert(NV nv, char * const endbuf, STRLEN * const len);
8981 # define PERL_ARGS_ASSERT_F0CONVERT             \
8982         assert(endbuf); assert(len)
8983 
8984 STATIC void
8985 S_anonymise_cv_maybe(pTHX_ GV *gv, CV *cv);
8986 # define PERL_ARGS_ASSERT_ANONYMISE_CV_MAYBE    \
8987         assert(gv); assert(cv)
8988 
8989 STATIC void
8990 S_assert_uft8_cache_coherent(pTHX_ const char * const func, STRLEN from_cache, STRLEN real, SV * const sv);
8991 # define PERL_ARGS_ASSERT_ASSERT_UFT8_CACHE_COHERENT \
8992         assert(func); assert(sv)
8993 
8994 STATIC bool
8995 S_curse(pTHX_ SV * const sv, const bool check_refcnt);
8996 # define PERL_ARGS_ASSERT_CURSE                 \
8997         assert(sv)
8998 
8999 STATIC STRLEN
9000 S_expect_number(pTHX_ const char ** const pattern)
9001         __attribute__warn_unused_result__;
9002 # define PERL_ARGS_ASSERT_EXPECT_NUMBER         \
9003         assert(pattern)
9004 
9005 STATIC SSize_t
9006 S_find_array_subscript(pTHX_ const AV * const av, const SV * const val);
9007 # define PERL_ARGS_ASSERT_FIND_ARRAY_SUBSCRIPT  \
9008         assert(val)
9009 
9010 STATIC SV *
9011 S_find_hash_subscript(pTHX_ const HV * const hv, const SV * const val);
9012 # define PERL_ARGS_ASSERT_FIND_HASH_SUBSCRIPT   \
9013         assert(val)
9014 
9015 STATIC SV *
9016 S_find_uninit_var(pTHX_ const OP * const obase, const SV * const uninit_sv, bool match, const char **desc_p);
9017 # define PERL_ARGS_ASSERT_FIND_UNINIT_VAR       \
9018         assert(desc_p)
9019 
9020 STATIC bool
9021 S_glob_2number(pTHX_ GV * const gv);
9022 # define PERL_ARGS_ASSERT_GLOB_2NUMBER          \
9023         assert(gv)
9024 
9025 STATIC void
9026 S_glob_assign_glob(pTHX_ SV * const dsv, SV * const ssv, const int dtype);
9027 # define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB      \
9028         assert(dsv); assert(ssv)
9029 
9030 PERL_CALLCONV SV *
9031 Perl_more_sv(pTHX);
9032 # define PERL_ARGS_ASSERT_MORE_SV
9033 
9034 STATIC void
9035 S_not_a_number(pTHX_ SV * const sv);
9036 # define PERL_ARGS_ASSERT_NOT_A_NUMBER          \
9037         assert(sv)
9038 
9039 STATIC void
9040 S_not_incrementable(pTHX_ SV * const sv);
9041 # define PERL_ARGS_ASSERT_NOT_INCREMENTABLE     \
9042         assert(sv)
9043 
9044 STATIC PTR_TBL_ENT_t *
9045 S_ptr_table_find(PTR_TBL_t * const tbl, const void * const sv)
9046         __attribute__warn_unused_result__;
9047 # define PERL_ARGS_ASSERT_PTR_TABLE_FIND        \
9048         assert(tbl)
9049 
9050 STATIC bool
9051 S_sv_2iuv_common(pTHX_ SV * const sv);
9052 # define PERL_ARGS_ASSERT_SV_2IUV_COMMON        \
9053         assert(sv)
9054 
9055 STATIC void
9056 S_sv_add_arena(pTHX_ char * const ptr, const U32 size, const U32 flags);
9057 # define PERL_ARGS_ASSERT_SV_ADD_ARENA          \
9058         assert(ptr)
9059 
9060 STATIC const char *
9061 S_sv_display(pTHX_ SV * const sv, char *tmpbuf, STRLEN tmpbuf_size);
9062 # define PERL_ARGS_ASSERT_SV_DISPLAY            \
9063         assert(sv); assert(tmpbuf)
9064 
9065 STATIC STRLEN
9066 S_sv_pos_b2u_midway(pTHX_ const U8 * const s, const U8 * const target, const U8 *end, STRLEN endu);
9067 # define PERL_ARGS_ASSERT_SV_POS_B2U_MIDWAY     \
9068         assert(s); assert(target); assert(end)
9069 
9070 STATIC STRLEN
9071 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);
9072 # define PERL_ARGS_ASSERT_SV_POS_U2B_CACHED     \
9073         assert(sv); assert(mgp); assert(start); assert(send)
9074 
9075 STATIC STRLEN
9076 S_sv_pos_u2b_forwards(const U8 * const start, const U8 * const send, STRLEN * const uoffset, bool * const at_end, bool *canonical_position);
9077 # define PERL_ARGS_ASSERT_SV_POS_U2B_FORWARDS   \
9078         assert(start); assert(send); assert(uoffset); assert(at_end); assert(canonical_position)
9079 
9080 STATIC STRLEN
9081 S_sv_pos_u2b_midway(const U8 * const start, const U8 *send, STRLEN uoffset, const STRLEN uend);
9082 # define PERL_ARGS_ASSERT_SV_POS_U2B_MIDWAY     \
9083         assert(start); assert(send)
9084 
9085 STATIC void
9086 S_utf8_mg_len_cache_update(pTHX_ SV * const sv, MAGIC ** const mgp, const STRLEN ulen);
9087 # define PERL_ARGS_ASSERT_UTF8_MG_LEN_CACHE_UPDATE \
9088         assert(sv); assert(mgp)
9089 
9090 STATIC void
9091 S_utf8_mg_pos_cache_update(pTHX_ SV * const sv, MAGIC ** const mgp, const STRLEN byte, const STRLEN utf8, const STRLEN blen);
9092 # define PERL_ARGS_ASSERT_UTF8_MG_POS_CACHE_UPDATE \
9093         assert(sv); assert(mgp)
9094 
9095 STATIC SSize_t
9096 S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask);
9097 # define PERL_ARGS_ASSERT_VISIT                 \
9098         assert(f)
9099 
9100 # if defined(DEBUGGING)
9101 STATIC void
9102 S_del_sv(pTHX_ SV *p);
9103 #   define PERL_ARGS_ASSERT_DEL_SV              \
9104         assert(p)
9105 
9106 PERL_CALLCONV void
9107 Perl_sv_mark_arenas(pTHX)
9108         __attribute__visibility__("hidden");
9109 #   define PERL_ARGS_ASSERT_SV_MARK_ARENAS
9110 
9111 PERL_CALLCONV void
9112 Perl_sv_sweep_arenas(pTHX)
9113         __attribute__visibility__("hidden");
9114 #   define PERL_ARGS_ASSERT_SV_SWEEP_ARENAS
9115 
9116 # endif /* defined(DEBUGGING) */
9117 # if !defined(NV_PRESERVES_UV)
9118 #   if defined(DEBUGGING)
9119 STATIC int
9120 S_sv_2iuv_non_preserve(pTHX_ SV * const sv, I32 numtype);
9121 #     define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \
9122         assert(sv)
9123 
9124 #   else
9125 STATIC int
9126 S_sv_2iuv_non_preserve(pTHX_ SV * const sv);
9127 #     define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \
9128         assert(sv)
9129 
9130 #   endif
9131 # endif /* !defined(NV_PRESERVES_UV) */
9132 # if defined(PERL_DEBUG_READONLY_COW)
9133 STATIC void
9134 S_sv_buf_to_rw(pTHX_ SV *sv);
9135 #   define PERL_ARGS_ASSERT_SV_BUF_TO_RW        \
9136         assert(sv)
9137 
9138 # endif
9139 # if !defined(PERL_NO_INLINE_FUNCTIONS)
9140 PERL_STATIC_INLINE void
9141 S_sv_unglob(pTHX_ SV * const sv, U32 flags);
9142 #   define PERL_ARGS_ASSERT_SV_UNGLOB           \
9143         assert(sv)
9144 
9145 PERL_STATIC_INLINE char *
9146 S_uiv_2buf(char * const buf, const IV iv, UV uv, const int is_uv, char ** const peob)
9147         __attribute__warn_unused_result__;
9148 #   define PERL_ARGS_ASSERT_UIV_2BUF            \
9149         assert(buf); assert(peob)
9150 
9151 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */
9152 # if defined(USE_ITHREADS)
9153 STATIC SV *
9154 S_sv_dup_common(pTHX_ const SV * const ssv, CLONE_PARAMS * const param)
9155         __attribute__warn_unused_result__;
9156 #   define PERL_ARGS_ASSERT_SV_DUP_COMMON       \
9157         assert(ssv); assert(param)
9158 
9159 STATIC void
9160 S_sv_dup_hvaux(pTHX_ const SV * const ssv, SV *dsv, CLONE_PARAMS * const param);
9161 #   define PERL_ARGS_ASSERT_SV_DUP_HVAUX        \
9162         assert(ssv); assert(dsv); assert(param)
9163 
9164 STATIC SV **
9165 S_sv_dup_inc_multiple(pTHX_ SV * const *source, SV **dest, SSize_t items, CLONE_PARAMS * const param);
9166 #   define PERL_ARGS_ASSERT_SV_DUP_INC_MULTIPLE \
9167         assert(source); assert(dest); assert(param)
9168 
9169 STATIC void
9170 S_unreferenced_to_tmp_stack(pTHX_ AV * const unreferenced);
9171 #   define PERL_ARGS_ASSERT_UNREFERENCED_TO_TMP_STACK \
9172         assert(unreferenced)
9173 
9174 # endif /* defined(USE_ITHREADS) */
9175 #endif /* defined(PERL_IN_SV_C) */
9176 #if defined(PERL_IN_TOKE_C)
9177 STATIC int
9178 S_ao(pTHX_ int toketype);
9179 # define PERL_ARGS_ASSERT_AO
9180 
9181 STATIC void
9182 S_check_uni(pTHX);
9183 # define PERL_ARGS_ASSERT_CHECK_UNI
9184 
9185 STATIC void
9186 S_checkcomma(pTHX_ const char *s, const char *name, const char *what);
9187 # define PERL_ARGS_ASSERT_CHECKCOMMA            \
9188         assert(s); assert(name); assert(what)
9189 
9190 STATIC char *
9191 S_filter_gets(pTHX_ SV *sv, STRLEN append)
9192         __attribute__warn_unused_result__;
9193 # define PERL_ARGS_ASSERT_FILTER_GETS           \
9194         assert(sv)
9195 
9196 STATIC HV *
9197 S_find_in_my_stash(pTHX_ const char *pkgname, STRLEN len)
9198         __attribute__warn_unused_result__;
9199 # define PERL_ARGS_ASSERT_FIND_IN_MY_STASH      \
9200         assert(pkgname)
9201 
9202 STATIC void
9203 S_force_ident(pTHX_ const char *s, int kind);
9204 # define PERL_ARGS_ASSERT_FORCE_IDENT           \
9205         assert(s)
9206 
9207 STATIC void
9208 S_force_ident_maybe_lex(pTHX_ char pit);
9209 # define PERL_ARGS_ASSERT_FORCE_IDENT_MAYBE_LEX
9210 
9211 STATIC void
9212 S_force_next(pTHX_ I32 type);
9213 # define PERL_ARGS_ASSERT_FORCE_NEXT
9214 
9215 STATIC char *
9216 S_force_strict_version(pTHX_ char *s);
9217 # define PERL_ARGS_ASSERT_FORCE_STRICT_VERSION  \
9218         assert(s)
9219 
9220 STATIC char *
9221 S_force_version(pTHX_ char *s, int guessing);
9222 # define PERL_ARGS_ASSERT_FORCE_VERSION         \
9223         assert(s)
9224 
9225 STATIC char *
9226 S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack);
9227 # define PERL_ARGS_ASSERT_FORCE_WORD            \
9228         assert(start)
9229 
9230 STATIC SV *
9231 S_get_and_check_backslash_N_name_wrapper(pTHX_ const char *s, const char * const e)
9232         __attribute__warn_unused_result__;
9233 # define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME_WRAPPER \
9234         assert(s); assert(e)
9235 
9236 STATIC void
9237 S_incline(pTHX_ const char *s, const char *end);
9238 # define PERL_ARGS_ASSERT_INCLINE               \
9239         assert(s); assert(end)
9240 
9241 STATIC int
9242 S_intuit_method(pTHX_ char *s, SV *ioname, CV *cv);
9243 # define PERL_ARGS_ASSERT_INTUIT_METHOD         \
9244         assert(s)
9245 
9246 STATIC int
9247 S_intuit_more(pTHX_ char *s, char *e);
9248 # define PERL_ARGS_ASSERT_INTUIT_MORE           \
9249         assert(s); assert(e)
9250 
9251 STATIC I32
9252 S_lop(pTHX_ I32 f, U8 x, char *s);
9253 # define PERL_ARGS_ASSERT_LOP                   \
9254         assert(s)
9255 
9256 PERL_STATIC_NO_RET void
9257 S_missingterm(pTHX_ char *s, STRLEN len)
9258         __attribute__noreturn__;
9259 # define PERL_ARGS_ASSERT_MISSINGTERM
9260 
9261 STATIC SV *
9262 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);
9263 # define PERL_ARGS_ASSERT_NEW_CONSTANT          \
9264         assert(key); assert(sv)
9265 
9266 STATIC void
9267 S_no_op(pTHX_ const char * const what, char *s);
9268 # define PERL_ARGS_ASSERT_NO_OP                 \
9269         assert(what)
9270 
9271 STATIC void
9272 S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_package, bool is_utf8, bool check_dollar, bool tick_warn);
9273 # define PERL_ARGS_ASSERT_PARSE_IDENT           \
9274         assert(s); assert(d); assert(e)
9275 
9276 STATIC int
9277 S_pending_ident(pTHX);
9278 # define PERL_ARGS_ASSERT_PENDING_IDENT
9279 
9280 STATIC char *
9281 S_scan_const(pTHX_ char *start)
9282         __attribute__warn_unused_result__;
9283 # define PERL_ARGS_ASSERT_SCAN_CONST            \
9284         assert(start)
9285 
9286 STATIC char *
9287 S_scan_formline(pTHX_ char *s)
9288         __attribute__warn_unused_result__;
9289 # define PERL_ARGS_ASSERT_SCAN_FORMLINE         \
9290         assert(s)
9291 
9292 STATIC char *
9293 S_scan_heredoc(pTHX_ char *s)
9294         __attribute__warn_unused_result__;
9295 # define PERL_ARGS_ASSERT_SCAN_HEREDOC          \
9296         assert(s)
9297 
9298 STATIC char *
9299 S_scan_ident(pTHX_ char *s, char *dest, STRLEN destlen, I32 ck_uni);
9300 # define PERL_ARGS_ASSERT_SCAN_IDENT            \
9301         assert(s); assert(dest)
9302 
9303 STATIC char *
9304 S_scan_inputsymbol(pTHX_ char *start)
9305         __attribute__warn_unused_result__;
9306 # define PERL_ARGS_ASSERT_SCAN_INPUTSYMBOL      \
9307         assert(start)
9308 
9309 STATIC char *
9310 S_scan_pat(pTHX_ char *start, I32 type)
9311         __attribute__warn_unused_result__;
9312 # define PERL_ARGS_ASSERT_SCAN_PAT              \
9313         assert(start)
9314 
9315 STATIC char *
9316 S_scan_subst(pTHX_ char *start)
9317         __attribute__warn_unused_result__;
9318 # define PERL_ARGS_ASSERT_SCAN_SUBST            \
9319         assert(start)
9320 
9321 STATIC char *
9322 S_scan_trans(pTHX_ char *start)
9323         __attribute__warn_unused_result__;
9324 # define PERL_ARGS_ASSERT_SCAN_TRANS            \
9325         assert(start)
9326 
9327 STATIC I32
9328 S_sublex_done(pTHX)
9329         __attribute__warn_unused_result__;
9330 # define PERL_ARGS_ASSERT_SUBLEX_DONE
9331 
9332 STATIC I32
9333 S_sublex_push(pTHX)
9334         __attribute__warn_unused_result__;
9335 # define PERL_ARGS_ASSERT_SUBLEX_PUSH
9336 
9337 STATIC I32
9338 S_sublex_start(pTHX)
9339         __attribute__warn_unused_result__;
9340 # define PERL_ARGS_ASSERT_SUBLEX_START
9341 
9342 STATIC char *
9343 S_swallow_bom(pTHX_ U8 *s)
9344         __attribute__warn_unused_result__;
9345 # define PERL_ARGS_ASSERT_SWALLOW_BOM           \
9346         assert(s)
9347 
9348 STATIC char *
9349 S_tokenize_use(pTHX_ int is_use, char *s)
9350         __attribute__warn_unused_result__;
9351 # define PERL_ARGS_ASSERT_TOKENIZE_USE          \
9352         assert(s)
9353 
9354 STATIC SV *
9355 S_tokeq(pTHX_ SV *sv);
9356 # define PERL_ARGS_ASSERT_TOKEQ                 \
9357         assert(sv)
9358 
9359 STATIC void
9360 S_update_debugger_info(pTHX_ SV *orig_sv, const char * const buf, STRLEN len);
9361 # define PERL_ARGS_ASSERT_UPDATE_DEBUGGER_INFO
9362 
9363 STATIC int
9364 S_yywarn(pTHX_ const char * const s, U32 flags);
9365 # define PERL_ARGS_ASSERT_YYWARN                \
9366         assert(s)
9367 
9368 # if defined(DEBUGGING)
9369 STATIC void
9370 S_printbuf(pTHX_ const char * const fmt, const char * const s)
9371         __attribute__format__(__printf__,pTHX_1,0);
9372 #   define PERL_ARGS_ASSERT_PRINTBUF            \
9373         assert(fmt); assert(s)
9374 
9375 STATIC int
9376 S_tokereport(pTHX_ I32 rv, const YYSTYPE *lvalp);
9377 #   define PERL_ARGS_ASSERT_TOKEREPORT          \
9378         assert(lvalp)
9379 
9380 # endif /* defined(DEBUGGING) */
9381 # if defined(PERL_CR_FILTER)
9382 STATIC I32
9383 S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen);
9384 #   define PERL_ARGS_ASSERT_CR_TEXTFILTER
9385 
9386 STATIC void
9387 S_strip_return(pTHX_ SV *sv);
9388 #   define PERL_ARGS_ASSERT_STRIP_RETURN        \
9389         assert(sv)
9390 
9391 # endif /* defined(PERL_CR_FILTER) */
9392 # if !defined(PERL_NO_UTF16_FILTER)
9393 STATIC U8 *
9394 S_add_utf16_textfilter(pTHX_ U8 * const s, bool reversed);
9395 #   define PERL_ARGS_ASSERT_ADD_UTF16_TEXTFILTER \
9396         assert(s)
9397 
9398 STATIC I32
9399 S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen);
9400 #   define PERL_ARGS_ASSERT_UTF16_TEXTFILTER    \
9401         assert(sv)
9402 
9403 # endif /* !defined(PERL_NO_UTF16_FILTER) */
9404 #endif /* defined(PERL_IN_TOKE_C) */
9405 #if defined(PERL_IN_UNIVERSAL_C)
9406 STATIC bool
9407 S_isa_lookup(pTHX_ HV *stash, SV *namesv, const char *name, STRLEN len, U32 flags);
9408 
9409 STATIC bool
9410 S_sv_derived_from_svpvn(pTHX_ SV *sv, SV *namesv, const char *name, const STRLEN len, U32 flags);
9411 
9412 #endif
9413 #if defined(PERL_IN_UTF8_C)
9414 STATIC UV
9415 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);
9416 # define PERL_ARGS_ASSERT__TO_UTF8_CASE         \
9417         assert(ustrp); assert(lenp); assert(invlist); assert(invmap); assert(normal)
9418 
9419 STATIC UV
9420 S_check_locale_boundary_crossing(pTHX_ const U8 * const p, const UV result, U8 * const ustrp, STRLEN *lenp)
9421         __attribute__warn_unused_result__;
9422 # define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \
9423         assert(p); assert(ustrp); assert(lenp)
9424 
9425 STATIC HV *
9426 S_new_msg_hv(pTHX_ const char * const message, U32 categories, U32 flag)
9427         __attribute__warn_unused_result__;
9428 # define PERL_ARGS_ASSERT_NEW_MSG_HV            \
9429         assert(message)
9430 
9431 STATIC UV
9432 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);
9433 # define PERL_ARGS_ASSERT_TO_CASE_CP_LIST       \
9434         assert(invlist); assert(invmap); assert(normal)
9435 
9436 STATIC U8
9437 S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp, const char dummy)
9438         __attribute__warn_unused_result__;
9439 # define PERL_ARGS_ASSERT_TO_LOWER_LATIN1
9440 
9441 STATIC UV
9442 S_turkic_fc(pTHX_ const U8 * const p, const U8 * const e, U8 *ustrp, STRLEN *lenp);
9443 # define PERL_ARGS_ASSERT_TURKIC_FC             \
9444         assert(p); assert(e); assert(ustrp); assert(lenp)
9445 
9446 STATIC UV
9447 S_turkic_lc(pTHX_ const U8 * const p0, const U8 * const e, U8 *ustrp, STRLEN *lenp);
9448 # define PERL_ARGS_ASSERT_TURKIC_LC             \
9449         assert(p0); assert(e); assert(ustrp); assert(lenp)
9450 
9451 STATIC UV
9452 S_turkic_uc(pTHX_ const U8 * const p, const U8 * const e, U8 *ustrp, STRLEN *lenp);
9453 # define PERL_ARGS_ASSERT_TURKIC_UC             \
9454         assert(p); assert(e); assert(ustrp); assert(lenp)
9455 
9456 STATIC char *
9457 S_unexpected_non_continuation_text(pTHX_ const U8 * const s, STRLEN print_len, const STRLEN non_cont_byte_pos, const STRLEN expect_len)
9458         __attribute__warn_unused_result__;
9459 # define PERL_ARGS_ASSERT_UNEXPECTED_NON_CONTINUATION_TEXT \
9460         assert(s)
9461 
9462 # if 0
9463 STATIC void
9464 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);
9465 #   define PERL_ARGS_ASSERT_WARN_ON_FIRST_DEPRECATED_USE \
9466         assert(name); assert(alternative); assert(file)
9467 
9468 # endif
9469 # if !defined(PERL_NO_INLINE_FUNCTIONS)
9470 PERL_STATIC_INLINE int
9471 S_does_utf8_overflow(const U8 * const s, const U8 *e, const bool consider_overlongs)
9472         __attribute__warn_unused_result__;
9473 #   define PERL_ARGS_ASSERT_DOES_UTF8_OVERFLOW  \
9474         assert(s); assert(e)
9475 
9476 PERL_STATIC_INLINE int
9477 S_isFF_overlong(const U8 * const s, const STRLEN len)
9478         __attribute__warn_unused_result__;
9479 #   define PERL_ARGS_ASSERT_ISFF_OVERLONG       \
9480         assert(s)
9481 
9482 PERL_STATIC_INLINE bool
9483 S_is_utf8_common(pTHX_ const U8 * const p, const U8 * const e, SV * const invlist)
9484         __attribute__warn_unused_result__;
9485 #   define PERL_ARGS_ASSERT_IS_UTF8_COMMON      \
9486         assert(p); assert(e)
9487 
9488 PERL_STATIC_INLINE int
9489 S_is_utf8_overlong(const U8 * const s, const STRLEN len)
9490         __attribute__warn_unused_result__;
9491 #   define PERL_ARGS_ASSERT_IS_UTF8_OVERLONG    \
9492         assert(s)
9493 
9494 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */
9495 #endif /* defined(PERL_IN_UTF8_C) */
9496 #if defined(PERL_IN_UTIL_C)
9497 STATIC bool
9498 S_ckwarn_common(pTHX_ U32 w);
9499 # define PERL_ARGS_ASSERT_CKWARN_COMMON
9500 
9501 STATIC SV *
9502 S_mess_alloc(pTHX);
9503 # define PERL_ARGS_ASSERT_MESS_ALLOC
9504 
9505 STATIC SV *
9506 S_with_queued_errors(pTHX_ SV *ex);
9507 # define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS    \
9508         assert(ex)
9509 
9510 STATIC void
9511 S_xs_version_bootcheck(pTHX_ SSize_t items, SSize_t ax, const char *xs_p, STRLEN xs_len);
9512 # define PERL_ARGS_ASSERT_XS_VERSION_BOOTCHECK  \
9513         assert(xs_p)
9514 
9515 # if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL)
9516 STATIC void
9517 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);
9518 #   define PERL_ARGS_ASSERT_MEM_LOG_COMMON      \
9519         assert(type_name); assert(filename); assert(funcname)
9520 
9521 # endif
9522 # if !defined(PERL_NO_INLINE_FUNCTIONS)
9523 PERL_STATIC_INLINE U32
9524 S_ptr_hash(PTRV u);
9525 #   define PERL_ARGS_ASSERT_PTR_HASH
9526 
9527 # endif
9528 # if defined(PERL_USES_PL_PIDSTATUS)
9529 STATIC void
9530 S_pidgone(pTHX_ Pid_t pid, int status);
9531 #   define PERL_ARGS_ASSERT_PIDGONE
9532 
9533 # endif
9534 #endif /* defined(PERL_IN_UTIL_C) */
9535 #if defined(PERL_MEM_LOG)
9536 PERL_CALLCONV Malloc_t
9537 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);
9538 # define PERL_ARGS_ASSERT_MEM_LOG_ALLOC         \
9539         assert(type_name); assert(filename); assert(funcname)
9540 
9541 PERL_CALLCONV void
9542 Perl_mem_log_del_sv(const SV *sv, const char *filename, int linenumber, const char *funcname);
9543 # define PERL_ARGS_ASSERT_MEM_LOG_DEL_SV        \
9544         assert(sv); assert(filename); assert(funcname)
9545 
9546 PERL_CALLCONV Malloc_t
9547 Perl_mem_log_free(Malloc_t oldalloc, const char *filename, const int linenumber, const char *funcname);
9548 # define PERL_ARGS_ASSERT_MEM_LOG_FREE          \
9549         assert(filename); assert(funcname)
9550 
9551 PERL_CALLCONV void
9552 Perl_mem_log_new_sv(const SV *sv, const char *filename, int linenumber, const char *funcname);
9553 # define PERL_ARGS_ASSERT_MEM_LOG_NEW_SV        \
9554         assert(sv); assert(filename); assert(funcname)
9555 
9556 PERL_CALLCONV Malloc_t
9557 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);
9558 # define PERL_ARGS_ASSERT_MEM_LOG_REALLOC       \
9559         assert(type_name); assert(filename); assert(funcname)
9560 
9561 #endif /* defined(PERL_MEM_LOG) */
9562 #if !defined(PERL_NO_INLINE_FUNCTIONS)
9563 PERL_STATIC_INLINE I32 *
9564 Perl_CvDEPTH(const CV * const sv);
9565 # define PERL_ARGS_ASSERT_CVDEPTH               \
9566         assert(sv)
9567 
9568 PERL_STATIC_INLINE GV *
9569 Perl_CvGV(pTHX_ CV *sv);
9570 # define PERL_ARGS_ASSERT_CVGV                  \
9571         assert(sv)
9572 
9573 PERL_STATIC_INLINE Stack_off_t
9574 Perl_POPMARK(pTHX);
9575 # define PERL_ARGS_ASSERT_POPMARK
9576 
9577 PERL_STATIC_INLINE struct regexp *
9578 Perl_ReANY(const REGEXP * const re);
9579 # define PERL_ARGS_ASSERT_REANY                 \
9580         assert(re)
9581 
9582 PERL_STATIC_INLINE void
9583 Perl_SvAMAGIC_off(SV *sv);
9584 # define PERL_ARGS_ASSERT_SVAMAGIC_OFF          \
9585         assert(sv)
9586 
9587 PERL_STATIC_INLINE void
9588 Perl_SvAMAGIC_on(SV *sv);
9589 # define PERL_ARGS_ASSERT_SVAMAGIC_ON           \
9590         assert(sv)
9591 
9592 PERL_STATIC_INLINE void
9593 Perl_SvGETMAGIC(pTHX_ SV *sv);
9594 # define PERL_ARGS_ASSERT_SVGETMAGIC            \
9595         assert(sv)
9596 
9597 PERL_STATIC_INLINE IV
9598 Perl_SvIV(pTHX_ SV *sv);
9599 # define PERL_ARGS_ASSERT_SVIV                  \
9600         assert(sv)
9601 
9602 PERL_STATIC_INLINE IV
9603 Perl_SvIV_nomg(pTHX_ SV *sv);
9604 # define PERL_ARGS_ASSERT_SVIV_NOMG             \
9605         assert(sv)
9606 
9607 PERL_STATIC_INLINE NV
9608 Perl_SvNV(pTHX_ SV *sv);
9609 # define PERL_ARGS_ASSERT_SVNV                  \
9610         assert(sv)
9611 
9612 PERL_STATIC_INLINE NV
9613 Perl_SvNV_nomg(pTHX_ SV *sv);
9614 # define PERL_ARGS_ASSERT_SVNV_NOMG             \
9615         assert(sv)
9616 
9617 PERL_STATIC_FORCE_INLINE bool
9618 Perl_SvPVXtrue(pTHX_ SV *sv)
9619         __attribute__always_inline__;
9620 # define PERL_ARGS_ASSERT_SVPVXTRUE             \
9621         assert(sv)
9622 
9623 PERL_STATIC_INLINE void
9624 Perl_SvREFCNT_dec(pTHX_ SV *sv);
9625 # define PERL_ARGS_ASSERT_SVREFCNT_DEC
9626 
9627 PERL_STATIC_INLINE void
9628 Perl_SvREFCNT_dec_NN(pTHX_ SV *sv);
9629 # define PERL_ARGS_ASSERT_SVREFCNT_DEC_NN       \
9630         assert(sv)
9631 
9632 PERL_STATIC_INLINE SV *
9633 Perl_SvREFCNT_dec_ret_NULL(pTHX_ SV *sv);
9634 # define PERL_ARGS_ASSERT_SVREFCNT_DEC_RET_NULL
9635 
9636 PERL_STATIC_INLINE SV *
9637 Perl_SvREFCNT_inc(SV *sv);
9638 # define PERL_ARGS_ASSERT_SVREFCNT_INC
9639 
9640 PERL_STATIC_INLINE SV *
9641 Perl_SvREFCNT_inc_NN(SV *sv);
9642 # define PERL_ARGS_ASSERT_SVREFCNT_INC_NN       \
9643         assert(sv)
9644 
9645 PERL_STATIC_INLINE void
9646 Perl_SvREFCNT_inc_void(SV *sv);
9647 # define PERL_ARGS_ASSERT_SVREFCNT_INC_VOID
9648 
9649 PERL_STATIC_INLINE bool
9650 Perl_SvTRUE(pTHX_ SV *sv);
9651 # define PERL_ARGS_ASSERT_SVTRUE
9652 
9653 PERL_STATIC_INLINE bool
9654 Perl_SvTRUE_NN(pTHX_ SV *sv);
9655 # define PERL_ARGS_ASSERT_SVTRUE_NN             \
9656         assert(sv)
9657 
9658 PERL_STATIC_INLINE bool
9659 Perl_SvTRUE_common(pTHX_ SV *sv, const bool sv_2bool_is_fallback);
9660 # define PERL_ARGS_ASSERT_SVTRUE_COMMON         \
9661         assert(sv)
9662 
9663 PERL_STATIC_INLINE bool
9664 Perl_SvTRUE_nomg(pTHX_ SV *sv);
9665 # define PERL_ARGS_ASSERT_SVTRUE_NOMG
9666 
9667 PERL_STATIC_INLINE UV
9668 Perl_SvUV(pTHX_ SV *sv);
9669 # define PERL_ARGS_ASSERT_SVUV                  \
9670         assert(sv)
9671 
9672 PERL_STATIC_INLINE UV
9673 Perl_SvUV_nomg(pTHX_ SV *sv);
9674 # define PERL_ARGS_ASSERT_SVUV_NOMG             \
9675         assert(sv)
9676 
9677 PERL_STATIC_INLINE Stack_off_t
9678 Perl_TOPMARK(pTHX);
9679 # define PERL_ARGS_ASSERT_TOPMARK
9680 
9681 PERL_STATIC_INLINE void
9682 Perl_append_utf8_from_native_byte(const U8 byte, U8 **dest);
9683 # define PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE \
9684         assert(dest)
9685 
9686 PERL_STATIC_INLINE Size_t
9687 Perl_av_count(pTHX_ AV *av)
9688         __attribute__warn_unused_result__;
9689 # define PERL_ARGS_ASSERT_AV_COUNT              \
9690         assert(av)
9691 
9692 PERL_STATIC_INLINE SV **
9693 Perl_av_fetch_simple(pTHX_ AV *av, SSize_t key, I32 lval)
9694         __attribute__warn_unused_result__;
9695 # define PERL_ARGS_ASSERT_AV_FETCH_SIMPLE       \
9696         assert(av)
9697 
9698 PERL_STATIC_INLINE AV *
9699 Perl_av_new_alloc(pTHX_ SSize_t size, bool zeroflag)
9700         __attribute__warn_unused_result__;
9701 # define PERL_ARGS_ASSERT_AV_NEW_ALLOC
9702 
9703 PERL_STATIC_INLINE void
9704 Perl_av_push_simple(pTHX_ AV *av, SV *val);
9705 # define PERL_ARGS_ASSERT_AV_PUSH_SIMPLE        \
9706         assert(av); assert(val)
9707 
9708 PERL_STATIC_INLINE void
9709 Perl_av_remove_offset(pTHX_ AV *av);
9710 # define PERL_ARGS_ASSERT_AV_REMOVE_OFFSET      \
9711         assert(av)
9712 
9713 PERL_STATIC_INLINE SV **
9714 Perl_av_store_simple(pTHX_ AV *av, SSize_t key, SV *val);
9715 # define PERL_ARGS_ASSERT_AV_STORE_SIMPLE       \
9716         assert(av)
9717 
9718 PERL_STATIC_INLINE void
9719 Perl_clear_defarray_simple(pTHX_ AV *av);
9720 # define PERL_ARGS_ASSERT_CLEAR_DEFARRAY_SIMPLE \
9721         assert(av)
9722 
9723 PERL_STATIC_INLINE I32
9724 Perl_foldEQ(pTHX_ const char *a, const char *b, I32 len);
9725 # define PERL_ARGS_ASSERT_FOLDEQ                \
9726         assert(a); assert(b)
9727 
9728 PERL_STATIC_INLINE I32
9729 Perl_foldEQ_latin1(pTHX_ const char *a, const char *b, I32 len);
9730 # define PERL_ARGS_ASSERT_FOLDEQ_LATIN1         \
9731         assert(a); assert(b)
9732 
9733 PERL_STATIC_INLINE I32
9734 Perl_foldEQ_locale(pTHX_ const char *a, const char *b, I32 len);
9735 # define PERL_ARGS_ASSERT_FOLDEQ_LOCALE         \
9736         assert(a); assert(b)
9737 
9738 PERL_STATIC_INLINE MGVTBL *
9739 Perl_get_vtbl(pTHX_ int vtbl_id)
9740         __attribute__warn_unused_result__;
9741 # define PERL_ARGS_ASSERT_GET_VTBL
9742 
9743 PERL_STATIC_INLINE Size_t
9744 Perl_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e)
9745         __attribute__warn_unused_result__;
9746 # define PERL_ARGS_ASSERT_ISC9_STRICT_UTF8_CHAR \
9747         assert(s0); assert(e)
9748 
9749 PERL_STATIC_INLINE Size_t
9750 Perl_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e)
9751         __attribute__warn_unused_result__;
9752 # define PERL_ARGS_ASSERT_ISSTRICT_UTF8_CHAR    \
9753         assert(s0); assert(e)
9754 
9755 PERL_STATIC_INLINE Size_t
9756 Perl_isUTF8_CHAR(const U8 * const s0, const U8 * const e)
9757         __attribute__warn_unused_result__;
9758 # define PERL_ARGS_ASSERT_ISUTF8_CHAR           \
9759         assert(s0); assert(e)
9760 
9761 PERL_STATIC_INLINE Size_t
9762 Perl_isUTF8_CHAR_flags(const U8 * const s0, const U8 * const e, const U32 flags)
9763         __attribute__warn_unused_result__;
9764 # define PERL_ARGS_ASSERT_ISUTF8_CHAR_FLAGS     \
9765         assert(s0); assert(e)
9766 
9767 PERL_STATIC_INLINE bool
9768 Perl_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el);
9769 # define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING_LOCLEN \
9770         assert(s)
9771 
9772 PERL_STATIC_INLINE bool
9773 Perl_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name)
9774         __attribute__warn_unused_result__;
9775 # define PERL_ARGS_ASSERT_IS_SAFE_SYSCALL       \
9776         assert(pv); assert(what); assert(op_name)
9777 
9778 PERL_STATIC_INLINE bool
9779 Perl_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el);
9780 # define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING_LOCLEN \
9781         assert(s)
9782 
9783 PERL_STATIC_INLINE bool
9784 Perl_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags);
9785 # define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_LOCLEN_FLAGS \
9786         assert(s)
9787 
9788 PERL_STATIC_INLINE bool
9789 Perl_is_utf8_invariant_string_loc(const U8 * const s, STRLEN len, const U8 **ep)
9790         __attribute__warn_unused_result__;
9791 # define PERL_ARGS_ASSERT_IS_UTF8_INVARIANT_STRING_LOC \
9792         assert(s)
9793 
9794 PERL_STATIC_INLINE bool
9795 Perl_is_utf8_string_flags(const U8 *s, STRLEN len, const U32 flags)
9796         __attribute__warn_unused_result__;
9797 # define PERL_ARGS_ASSERT_IS_UTF8_STRING_FLAGS  \
9798         assert(s)
9799 
9800 PERL_STATIC_INLINE bool
9801 Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el);
9802 # define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN \
9803         assert(s)
9804 
9805 PERL_STATIC_INLINE bool
9806 Perl_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags);
9807 # define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN_FLAGS \
9808         assert(s)
9809 
9810 PERL_STATIC_INLINE bool
9811 Perl_is_utf8_valid_partial_char_flags(const U8 * const s0, const U8 * const e, const U32 flags)
9812         __attribute__warn_unused_result__;
9813 # define PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR_FLAGS \
9814         assert(s0); assert(e)
9815 
9816 PERL_STATIC_INLINE unsigned
9817 Perl_lsbit_pos32(U32 word)
9818         __attribute__warn_unused_result__;
9819 # define PERL_ARGS_ASSERT_LSBIT_POS32
9820 
9821 PERL_STATIC_INLINE char *
9822 Perl_mortal_getenv(const char *str)
9823         __attribute__warn_unused_result__;
9824 # define PERL_ARGS_ASSERT_MORTAL_GETENV         \
9825         assert(str)
9826 
9827 PERL_STATIC_INLINE unsigned
9828 Perl_msbit_pos32(U32 word)
9829         __attribute__warn_unused_result__;
9830 # define PERL_ARGS_ASSERT_MSBIT_POS32
9831 
9832 PERL_STATIC_INLINE OP *
9833 Perl_newPADxVOP(pTHX_ I32 type, I32 flags, PADOFFSET padix)
9834         __attribute__warn_unused_result__;
9835 # define PERL_ARGS_ASSERT_NEWPADXVOP
9836 
9837 PERL_STATIC_INLINE SV *
9838 Perl_newRV_noinc(pTHX_ SV * const tmpRef)
9839         __attribute__warn_unused_result__;
9840 # define PERL_ARGS_ASSERT_NEWRV_NOINC           \
9841         assert(tmpRef)
9842 
9843 PERL_STATIC_INLINE SV *
9844 Perl_newSV_type(pTHX_ const svtype type)
9845         __attribute__warn_unused_result__;
9846 # define PERL_ARGS_ASSERT_NEWSV_TYPE
9847 
9848 PERL_STATIC_FORCE_INLINE SV *
9849 Perl_newSV_type_mortal(pTHX_ const svtype type)
9850         __attribute__warn_unused_result__
9851         __attribute__always_inline__;
9852 # define PERL_ARGS_ASSERT_NEWSV_TYPE_MORTAL
9853 
9854 PERL_STATIC_INLINE void
9855 Perl_pop_stackinfo(pTHX);
9856 # define PERL_ARGS_ASSERT_POP_STACKINFO
9857 
9858 PERL_STATIC_INLINE void
9859 Perl_push_stackinfo(pTHX_ I32 type, UV flags);
9860 # define PERL_ARGS_ASSERT_PUSH_STACKINFO
9861 
9862 PERL_STATIC_INLINE void
9863 Perl_rpp_context(pTHX_ SV **mark, U8 gimme, SSize_t extra);
9864 # define PERL_ARGS_ASSERT_RPP_CONTEXT           \
9865         assert(mark)
9866 
9867 PERL_STATIC_INLINE void
9868 Perl_rpp_extend(pTHX_ SSize_t n);
9869 # define PERL_ARGS_ASSERT_RPP_EXTEND
9870 
9871 PERL_STATIC_INLINE void
9872 Perl_rpp_invoke_xs(pTHX_ CV *cv);
9873 # define PERL_ARGS_ASSERT_RPP_INVOKE_XS         \
9874         assert(cv)
9875 
9876 PERL_STATIC_INLINE bool
9877 Perl_rpp_is_lone(pTHX_ SV *sv);
9878 # define PERL_ARGS_ASSERT_RPP_IS_LONE           \
9879         assert(sv)
9880 
9881 PERL_STATIC_INLINE SV *
9882 Perl_rpp_pop_1_norc(pTHX);
9883 # define PERL_ARGS_ASSERT_RPP_POP_1_NORC
9884 
9885 PERL_STATIC_INLINE void
9886 Perl_rpp_popfree_1(pTHX);
9887 # define PERL_ARGS_ASSERT_RPP_POPFREE_1
9888 
9889 PERL_STATIC_INLINE void
9890 Perl_rpp_popfree_1_NN(pTHX);
9891 # define PERL_ARGS_ASSERT_RPP_POPFREE_1_NN
9892 
9893 PERL_STATIC_INLINE void
9894 Perl_rpp_popfree_2(pTHX);
9895 # define PERL_ARGS_ASSERT_RPP_POPFREE_2
9896 
9897 PERL_STATIC_INLINE void
9898 Perl_rpp_popfree_2_NN(pTHX);
9899 # define PERL_ARGS_ASSERT_RPP_POPFREE_2_NN
9900 
9901 PERL_STATIC_INLINE void
9902 Perl_rpp_popfree_to(pTHX_ SV **sp);
9903 # define PERL_ARGS_ASSERT_RPP_POPFREE_TO        \
9904         assert(sp)
9905 
9906 PERL_STATIC_INLINE void
9907 Perl_rpp_popfree_to_NN(pTHX_ SV **sp);
9908 # define PERL_ARGS_ASSERT_RPP_POPFREE_TO_NN     \
9909         assert(sp)
9910 
9911 PERL_STATIC_INLINE void
9912 Perl_rpp_push_1(pTHX_ SV *sv);
9913 # define PERL_ARGS_ASSERT_RPP_PUSH_1            \
9914         assert(sv)
9915 
9916 PERL_STATIC_INLINE void
9917 Perl_rpp_push_1_norc(pTHX_ SV *sv);
9918 # define PERL_ARGS_ASSERT_RPP_PUSH_1_NORC       \
9919         assert(sv)
9920 
9921 PERL_STATIC_INLINE void
9922 Perl_rpp_push_2(pTHX_ SV *sv1, SV *sv2);
9923 # define PERL_ARGS_ASSERT_RPP_PUSH_2            \
9924         assert(sv1); assert(sv2)
9925 
9926 PERL_STATIC_INLINE void
9927 Perl_rpp_push_IMM(pTHX_ SV *sv);
9928 # define PERL_ARGS_ASSERT_RPP_PUSH_IMM          \
9929         assert(sv)
9930 
9931 PERL_STATIC_INLINE void
9932 Perl_rpp_replace_1_1(pTHX_ SV *sv);
9933 # define PERL_ARGS_ASSERT_RPP_REPLACE_1_1       \
9934         assert(sv)
9935 
9936 PERL_STATIC_INLINE void
9937 Perl_rpp_replace_1_1_NN(pTHX_ SV *sv);
9938 # define PERL_ARGS_ASSERT_RPP_REPLACE_1_1_NN    \
9939         assert(sv)
9940 
9941 PERL_STATIC_INLINE void
9942 Perl_rpp_replace_1_IMM_NN(pTHX_ SV *sv);
9943 # define PERL_ARGS_ASSERT_RPP_REPLACE_1_IMM_NN  \
9944         assert(sv)
9945 
9946 PERL_STATIC_INLINE void
9947 Perl_rpp_replace_2_1(pTHX_ SV *sv);
9948 # define PERL_ARGS_ASSERT_RPP_REPLACE_2_1       \
9949         assert(sv)
9950 
9951 PERL_STATIC_INLINE void
9952 Perl_rpp_replace_2_1_COMMON(pTHX_ SV *sv);
9953 # define PERL_ARGS_ASSERT_RPP_REPLACE_2_1_COMMON \
9954         assert(sv)
9955 
9956 PERL_STATIC_INLINE void
9957 Perl_rpp_replace_2_1_NN(pTHX_ SV *sv);
9958 # define PERL_ARGS_ASSERT_RPP_REPLACE_2_1_NN    \
9959         assert(sv)
9960 
9961 PERL_STATIC_INLINE void
9962 Perl_rpp_replace_2_IMM_NN(pTHX_ SV *sv);
9963 # define PERL_ARGS_ASSERT_RPP_REPLACE_2_IMM_NN  \
9964         assert(sv)
9965 
9966 PERL_STATIC_INLINE void
9967 Perl_rpp_replace_at(pTHX_ SV **sp, SV *sv);
9968 # define PERL_ARGS_ASSERT_RPP_REPLACE_AT        \
9969         assert(sp); assert(sv)
9970 
9971 PERL_STATIC_INLINE void
9972 Perl_rpp_replace_at_NN(pTHX_ SV **sp, SV *sv);
9973 # define PERL_ARGS_ASSERT_RPP_REPLACE_AT_NN     \
9974         assert(sp); assert(sv)
9975 
9976 PERL_STATIC_INLINE void
9977 Perl_rpp_replace_at_norc(pTHX_ SV **sp, SV *sv);
9978 # define PERL_ARGS_ASSERT_RPP_REPLACE_AT_NORC   \
9979         assert(sp); assert(sv)
9980 
9981 PERL_STATIC_INLINE void
9982 Perl_rpp_replace_at_norc_NN(pTHX_ SV **sp, SV *sv);
9983 # define PERL_ARGS_ASSERT_RPP_REPLACE_AT_NORC_NN \
9984         assert(sp); assert(sv)
9985 
9986 PERL_STATIC_INLINE bool
9987 Perl_rpp_stack_is_rc(pTHX);
9988 # define PERL_ARGS_ASSERT_RPP_STACK_IS_RC
9989 
9990 PERL_STATIC_INLINE bool
9991 Perl_rpp_try_AMAGIC_1(pTHX_ int method, int flags);
9992 # define PERL_ARGS_ASSERT_RPP_TRY_AMAGIC_1
9993 
9994 PERL_STATIC_INLINE bool
9995 Perl_rpp_try_AMAGIC_2(pTHX_ int method, int flags);
9996 # define PERL_ARGS_ASSERT_RPP_TRY_AMAGIC_2
9997 
9998 PERL_STATIC_INLINE void
9999 Perl_rpp_xpush_1(pTHX_ SV *sv);
10000 # define PERL_ARGS_ASSERT_RPP_XPUSH_1           \
10001         assert(sv)
10002 
10003 PERL_STATIC_INLINE void
10004 Perl_rpp_xpush_2(pTHX_ SV *sv1, SV *sv2);
10005 # define PERL_ARGS_ASSERT_RPP_XPUSH_2           \
10006         assert(sv1); assert(sv2)
10007 
10008 PERL_STATIC_INLINE void
10009 Perl_rpp_xpush_IMM(pTHX_ SV *sv);
10010 # define PERL_ARGS_ASSERT_RPP_XPUSH_IMM         \
10011         assert(sv)
10012 
10013 PERL_STATIC_INLINE char *
10014 Perl_savepv(pTHX_ const char *pv)
10015         __attribute__malloc__
10016         __attribute__warn_unused_result__;
10017 # define PERL_ARGS_ASSERT_SAVEPV
10018 
10019 PERL_STATIC_INLINE char *
10020 Perl_savepvn(pTHX_ const char *pv, Size_t len)
10021         __attribute__malloc__
10022         __attribute__warn_unused_result__;
10023 # define PERL_ARGS_ASSERT_SAVEPVN
10024 
10025 PERL_STATIC_INLINE char *
10026 Perl_savesharedsvpv(pTHX_ SV *sv)
10027         __attribute__malloc__
10028         __attribute__warn_unused_result__;
10029 # define PERL_ARGS_ASSERT_SAVESHAREDSVPV        \
10030         assert(sv)
10031 
10032 PERL_STATIC_INLINE char *
10033 Perl_savesvpv(pTHX_ SV *sv)
10034         __attribute__malloc__
10035         __attribute__warn_unused_result__;
10036 # define PERL_ARGS_ASSERT_SAVESVPV              \
10037         assert(sv)
10038 
10039 PERL_STATIC_INLINE unsigned
10040 Perl_single_1bit_pos32(U32 word)
10041         __attribute__warn_unused_result__;
10042 # define PERL_ARGS_ASSERT_SINGLE_1BIT_POS32
10043 
10044 PERL_STATIC_INLINE bool
10045 Perl_sv_only_taint_gmagic(SV *sv);
10046 # define PERL_ARGS_ASSERT_SV_ONLY_TAINT_GMAGIC  \
10047         assert(sv)
10048 
10049 PERL_STATIC_INLINE char *
10050 Perl_sv_pvbyten_force_wrapper(pTHX_ SV * const sv, STRLEN * const lp, const U32 dummy);
10051 # define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE_WRAPPER \
10052         assert(sv)
10053 
10054 PERL_STATIC_INLINE char *
10055 Perl_sv_pvutf8n_force_wrapper(pTHX_ SV * const sv, STRLEN * const lp, const U32 dummy);
10056 # define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE_WRAPPER \
10057         assert(sv)
10058 
10059 PERL_STATIC_INLINE char  *
10060 Perl_sv_setpv_freshbuf(pTHX_ SV * const sv);
10061 # define PERL_ARGS_ASSERT_SV_SETPV_FRESHBUF     \
10062         assert(sv)
10063 
10064 PERL_STATIC_INLINE void
10065 Perl_switch_argstack(pTHX_ AV *to);
10066 # define PERL_ARGS_ASSERT_SWITCH_ARGSTACK       \
10067         assert(to)
10068 
10069 PERL_STATIC_INLINE IV
10070 Perl_utf8_distance(pTHX_ const U8 *a, const U8 *b)
10071         __attribute__warn_unused_result__;
10072 # define PERL_ARGS_ASSERT_UTF8_DISTANCE         \
10073         assert(a); assert(b)
10074 
10075 PERL_STATIC_INLINE U8 *
10076 Perl_utf8_hop(const U8 *s, SSize_t off)
10077         __attribute__warn_unused_result__;
10078 # define PERL_ARGS_ASSERT_UTF8_HOP              \
10079         assert(s)
10080 
10081 PERL_STATIC_INLINE U8 *
10082 Perl_utf8_hop_back(const U8 *s, SSize_t off, const U8 *start)
10083         __attribute__warn_unused_result__;
10084 # define PERL_ARGS_ASSERT_UTF8_HOP_BACK         \
10085         assert(s); assert(start)
10086 
10087 PERL_STATIC_INLINE U8 *
10088 Perl_utf8_hop_forward(const U8 *s, SSize_t off, const U8 *end)
10089         __attribute__warn_unused_result__;
10090 # define PERL_ARGS_ASSERT_UTF8_HOP_FORWARD      \
10091         assert(s); assert(end)
10092 
10093 PERL_STATIC_INLINE U8 *
10094 Perl_utf8_hop_safe(const U8 *s, SSize_t off, const U8 *start, const U8 *end)
10095         __attribute__warn_unused_result__;
10096 # define PERL_ARGS_ASSERT_UTF8_HOP_SAFE         \
10097         assert(s); assert(start); assert(end)
10098 
10099 PERL_STATIC_INLINE UV
10100 Perl_utf8_to_uvchr_buf_helper(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen);
10101 # define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF_HELPER \
10102         assert(s); assert(send)
10103 
10104 PERL_STATIC_INLINE UV
10105 Perl_utf8n_to_uvchr_msgs(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 *errors, AV **msgs);
10106 # define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_MSGS   \
10107         assert(s)
10108 
10109 PERL_STATIC_INLINE UV
10110 Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen)
10111         __attribute__warn_unused_result__;
10112 # define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR   \
10113         assert(s)
10114 
10115 PERL_STATIC_INLINE void
10116 Perl_cx_popblock(pTHX_ PERL_CONTEXT *cx);
10117 # define PERL_ARGS_ASSERT_CX_POPBLOCK           \
10118         assert(cx)
10119 
10120 PERL_STATIC_INLINE void
10121 Perl_cx_popeval(pTHX_ PERL_CONTEXT *cx);
10122 # define PERL_ARGS_ASSERT_CX_POPEVAL            \
10123         assert(cx)
10124 
10125 PERL_STATIC_INLINE void
10126 Perl_cx_popformat(pTHX_ PERL_CONTEXT *cx);
10127 # define PERL_ARGS_ASSERT_CX_POPFORMAT          \
10128         assert(cx)
10129 
10130 PERL_STATIC_INLINE void
10131 Perl_cx_popgiven(pTHX_ PERL_CONTEXT *cx);
10132 # define PERL_ARGS_ASSERT_CX_POPGIVEN           \
10133         assert(cx)
10134 
10135 PERL_STATIC_INLINE void
10136 Perl_cx_poploop(pTHX_ PERL_CONTEXT *cx);
10137 # define PERL_ARGS_ASSERT_CX_POPLOOP            \
10138         assert(cx)
10139 
10140 PERL_STATIC_INLINE void
10141 Perl_cx_popsub(pTHX_ PERL_CONTEXT *cx);
10142 # define PERL_ARGS_ASSERT_CX_POPSUB             \
10143         assert(cx)
10144 
10145 PERL_STATIC_INLINE void
10146 Perl_cx_popsub_args(pTHX_ PERL_CONTEXT *cx);
10147 # define PERL_ARGS_ASSERT_CX_POPSUB_ARGS        \
10148         assert(cx)
10149 
10150 PERL_STATIC_INLINE void
10151 Perl_cx_popsub_common(pTHX_ PERL_CONTEXT *cx);
10152 # define PERL_ARGS_ASSERT_CX_POPSUB_COMMON      \
10153         assert(cx)
10154 
10155 PERL_STATIC_INLINE void
10156 Perl_cx_popwhen(pTHX_ PERL_CONTEXT *cx);
10157 # define PERL_ARGS_ASSERT_CX_POPWHEN            \
10158         assert(cx)
10159 
10160 PERL_STATIC_INLINE PERL_CONTEXT *
10161 Perl_cx_pushblock(pTHX_ U8 type, U8 gimme, SV **sp, I32 saveix);
10162 # define PERL_ARGS_ASSERT_CX_PUSHBLOCK          \
10163         assert(sp)
10164 
10165 PERL_STATIC_INLINE void
10166 Perl_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv);
10167 # define PERL_ARGS_ASSERT_CX_PUSHEVAL           \
10168         assert(cx)
10169 
10170 PERL_STATIC_INLINE void
10171 Perl_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv);
10172 # define PERL_ARGS_ASSERT_CX_PUSHFORMAT         \
10173         assert(cx); assert(cv)
10174 
10175 PERL_STATIC_INLINE void
10176 Perl_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv);
10177 # define PERL_ARGS_ASSERT_CX_PUSHGIVEN          \
10178         assert(cx)
10179 
10180 PERL_STATIC_INLINE void
10181 Perl_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV *itersave);
10182 # define PERL_ARGS_ASSERT_CX_PUSHLOOP_FOR       \
10183         assert(cx); assert(itervarp)
10184 
10185 PERL_STATIC_INLINE void
10186 Perl_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx);
10187 # define PERL_ARGS_ASSERT_CX_PUSHLOOP_PLAIN     \
10188         assert(cx)
10189 
10190 PERL_STATIC_INLINE void
10191 Perl_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs);
10192 # define PERL_ARGS_ASSERT_CX_PUSHSUB            \
10193         assert(cx); assert(cv)
10194 
10195 PERL_STATIC_INLINE void
10196 Perl_cx_pushtry(pTHX_ PERL_CONTEXT *cx, OP *retop);
10197 # define PERL_ARGS_ASSERT_CX_PUSHTRY            \
10198         assert(cx)
10199 
10200 PERL_STATIC_INLINE void
10201 Perl_cx_pushwhen(pTHX_ PERL_CONTEXT *cx);
10202 # define PERL_ARGS_ASSERT_CX_PUSHWHEN           \
10203         assert(cx)
10204 
10205 PERL_STATIC_INLINE void
10206 Perl_cx_topblock(pTHX_ PERL_CONTEXT *cx);
10207 # define PERL_ARGS_ASSERT_CX_TOPBLOCK           \
10208         assert(cx)
10209 
10210 PERL_STATIC_INLINE U8
10211 Perl_gimme_V(pTHX);
10212 # define PERL_ARGS_ASSERT_GIMME_V
10213 
10214 # if !defined(HAS_STRLCAT)
10215 PERL_STATIC_INLINE Size_t
10216 Perl_my_strlcat(char *dst, const char *src, Size_t size);
10217 #   define PERL_ARGS_ASSERT_MY_STRLCAT
10218 
10219 # endif
10220 # if !defined(HAS_STRNLEN)
10221 PERL_STATIC_INLINE Size_t
10222 Perl_my_strnlen(const char *str, Size_t maxlen);
10223 #   define PERL_ARGS_ASSERT_MY_STRNLEN          \
10224         assert(str)
10225 
10226 # endif
10227 # if defined(PERL_CORE) || defined(PERL_EXT)
10228 PERL_STATIC_INLINE bool
10229 Perl_is_utf8_non_invariant_string(const U8 * const s, STRLEN len)
10230         __attribute__warn_unused_result__;
10231 #   define PERL_ARGS_ASSERT_IS_UTF8_NON_INVARIANT_STRING \
10232         assert(s)
10233 
10234 PERL_STATIC_INLINE STRLEN
10235 S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp);
10236 #   define PERL_ARGS_ASSERT_SV_OR_PV_POS_U2B    \
10237         assert(sv); assert(pv)
10238 
10239 PERL_STATIC_INLINE Size_t
10240 S_variant_under_utf8_count(const U8 * const s, const U8 * const e)
10241         __attribute__warn_unused_result__;
10242 #   define PERL_ARGS_ASSERT_VARIANT_UNDER_UTF8_COUNT \
10243         assert(s); assert(e)
10244 
10245 #   if !defined(HAS_MEMRCHR)
10246 PERL_STATIC_INLINE void *
10247 S_my_memrchr(const char *s, const char c, const STRLEN len);
10248 #     define PERL_ARGS_ASSERT_MY_MEMRCHR        \
10249         assert(s)
10250 
10251 #   endif
10252 # endif /* defined(PERL_CORE) || defined(PERL_EXT) */
10253 # if defined(PERL_IN_DOOP_C)    || defined(PERL_IN_OP_C)        || \
10254      defined(PERL_IN_PP_C)      || defined(PERL_IN_REGCOMP_ANY) || \
10255      defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C)      || \
10256      defined(PERL_IN_UTF8_C)
10257 PERL_STATIC_INLINE bool
10258 S__invlist_contains_cp(SV * const invlist, const UV cp)
10259         __attribute__warn_unused_result__;
10260 #   define PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP \
10261         assert(invlist)
10262 
10263 PERL_STATIC_INLINE UV
10264 S__invlist_len(SV * const invlist)
10265         __attribute__warn_unused_result__;
10266 #   define PERL_ARGS_ASSERT__INVLIST_LEN        \
10267         assert(invlist)
10268 
10269 PERL_STATIC_INLINE bool *
10270 S_get_invlist_offset_addr(SV *invlist)
10271         __attribute__warn_unused_result__;
10272 #   define PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR \
10273         assert(invlist)
10274 
10275 PERL_STATIC_INLINE UV *
10276 S_invlist_array(SV * const invlist)
10277         __attribute__warn_unused_result__;
10278 #   define PERL_ARGS_ASSERT_INVLIST_ARRAY       \
10279         assert(invlist)
10280 
10281 PERL_STATIC_INLINE bool
10282 S_is_invlist(const SV * const invlist)
10283         __attribute__warn_unused_result__;
10284 #   define PERL_ARGS_ASSERT_IS_INVLIST
10285 
10286 # endif /* defined(PERL_IN_DOOP_C)    || defined(PERL_IN_OP_C)        ||
10287            defined(PERL_IN_PP_C)      || defined(PERL_IN_REGCOMP_ANY) ||
10288            defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C)      ||
10289            defined(PERL_IN_UTF8_C) */
10290 # if defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || \
10291      defined(PERL_IN_REGCOMP_ANY)
10292 PERL_STATIC_INLINE SV *
10293 S_add_cp_to_invlist(pTHX_ SV *invlist, const UV cp)
10294         __attribute__warn_unused_result__;
10295 #   define PERL_ARGS_ASSERT_ADD_CP_TO_INVLIST
10296 
10297 PERL_STATIC_INLINE void
10298 S_invlist_extend(pTHX_ SV * const invlist, const UV len);
10299 #   define PERL_ARGS_ASSERT_INVLIST_EXTEND      \
10300         assert(invlist)
10301 
10302 PERL_STATIC_INLINE UV
10303 S_invlist_highest(SV * const invlist)
10304         __attribute__warn_unused_result__;
10305 #   define PERL_ARGS_ASSERT_INVLIST_HIGHEST     \
10306         assert(invlist)
10307 
10308 PERL_STATIC_INLINE void
10309 S_invlist_set_len(pTHX_ SV * const invlist, const UV len, const bool offset);
10310 #   define PERL_ARGS_ASSERT_INVLIST_SET_LEN     \
10311         assert(invlist)
10312 
10313 # endif /* defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) ||
10314            defined(PERL_IN_REGCOMP_ANY) */
10315 # if defined(PERL_IN_OP_C) || defined(PERL_IN_PAD_C)
10316 PERL_STATIC_INLINE bool
10317 S_PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq);
10318 #   define PERL_ARGS_ASSERT_PADNAMEIN_SCOPE     \
10319         assert(pn)
10320 
10321 # endif
10322 # if defined(PERL_IN_OP_C) || defined(PERL_IN_REGCOMP_ANY)
10323 PERL_STATIC_INLINE STRLEN *
10324 S_get_invlist_iter_addr(SV *invlist)
10325         __attribute__warn_unused_result__;
10326 #   define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \
10327         assert(invlist)
10328 
10329 PERL_STATIC_INLINE void
10330 S_invlist_iterfinish(SV *invlist);
10331 #   define PERL_ARGS_ASSERT_INVLIST_ITERFINISH  \
10332         assert(invlist)
10333 
10334 PERL_STATIC_INLINE void
10335 S_invlist_iterinit(SV *invlist);
10336 #   define PERL_ARGS_ASSERT_INVLIST_ITERINIT    \
10337         assert(invlist)
10338 
10339 PERL_STATIC_INLINE bool
10340 S_invlist_iternext(SV *invlist, UV *start, UV *end)
10341         __attribute__warn_unused_result__;
10342 #   define PERL_ARGS_ASSERT_INVLIST_ITERNEXT    \
10343         assert(invlist); assert(start); assert(end)
10344 
10345 # endif /* defined(PERL_IN_OP_C) || defined(PERL_IN_REGCOMP_ANY) */
10346 # if defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C)
10347 PERL_STATIC_INLINE bool
10348 S_lossless_NV_to_IV(const NV nv, IV *ivp)
10349         __attribute__warn_unused_result__;
10350 #   define PERL_ARGS_ASSERT_LOSSLESS_NV_TO_IV   \
10351         assert(ivp)
10352 
10353 # endif
10354 # if defined(PERL_IN_PP_C)   || defined(PERL_IN_REGCOMP_ANY) || \
10355      defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C)
10356 PERL_STATIC_INLINE const char *
10357 S_get_regex_charset_name(const U32 flags, STRLEN * const lenp);
10358 #   define PERL_ARGS_ASSERT_GET_REGEX_CHARSET_NAME \
10359         assert(lenp)
10360 
10361 # endif
10362 # if defined(U64TYPE)
10363 PERL_STATIC_INLINE unsigned
10364 Perl_lsbit_pos64(U64 word)
10365         __attribute__warn_unused_result__;
10366 #   define PERL_ARGS_ASSERT_LSBIT_POS64
10367 
10368 PERL_STATIC_INLINE unsigned
10369 Perl_msbit_pos64(U64 word)
10370         __attribute__warn_unused_result__;
10371 #   define PERL_ARGS_ASSERT_MSBIT_POS64
10372 
10373 PERL_STATIC_INLINE unsigned
10374 Perl_single_1bit_pos64(U64 word)
10375         __attribute__warn_unused_result__;
10376 #   define PERL_ARGS_ASSERT_SINGLE_1BIT_POS64
10377 
10378 # endif /* defined(U64TYPE) */
10379 # if defined(USE_ITHREADS)
10380 PERL_STATIC_INLINE AV *
10381 Perl_cop_file_avn(pTHX_ const COP *cop);
10382 #   define PERL_ARGS_ASSERT_COP_FILE_AVN        \
10383         assert(cop)
10384 
10385 #   if !defined(PERL_IMPLICIT_SYS)
10386 PERL_STATIC_INLINE bool
10387 S_PerlEnv_putenv(pTHX_ char *str);
10388 #     define PERL_ARGS_ASSERT_PERLENV_PUTENV    \
10389         assert(str)
10390 
10391 #   endif
10392 # endif /* defined(USE_ITHREADS) */
10393 # if !defined(WIN32)
10394 PERL_STATIC_INLINE void *
10395 Perl_get_context(void)
10396         __attribute__warn_unused_result__;
10397 #   define PERL_ARGS_ASSERT_GET_CONTEXT
10398 
10399 # endif
10400 #endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */
10401 #if defined(PERL_RC_STACK)
10402 PERL_CALLCONV OP *
10403 Perl_pp_wrap(pTHX_ Perl_ppaddr_t real_pp_fn, I32 nargs, int nlists);
10404 # define PERL_ARGS_ASSERT_PP_WRAP               \
10405         assert(real_pp_fn)
10406 
10407 PERL_CALLCONV int
10408 Perl_runops_wrap(pTHX);
10409 # define PERL_ARGS_ASSERT_RUNOPS_WRAP
10410 
10411 PERL_CALLCONV void
10412 Perl_xs_wrap(pTHX_ XSUBADDR_t xsub, CV *cv);
10413 # define PERL_ARGS_ASSERT_XS_WRAP               \
10414         assert(xsub); assert(cv)
10415 
10416 #endif /* defined(PERL_RC_STACK) */
10417 #if defined(PERL_USE_3ARG_SIGHANDLER)
10418 PERL_CALLCONV Signal_t
10419 Perl_csighandler(int sig, Siginfo_t *info, void *uap);
10420 # define PERL_ARGS_ASSERT_CSIGHANDLER
10421 
10422 PERL_CALLCONV Signal_t
10423 Perl_sighandler(int sig, Siginfo_t *info, void *uap)
10424         __attribute__visibility__("hidden");
10425 # define PERL_ARGS_ASSERT_SIGHANDLER
10426 
10427 #else /* if !defined(PERL_USE_3ARG_SIGHANDLER) */
10428 PERL_CALLCONV Signal_t
10429 Perl_csighandler(int sig);
10430 # define PERL_ARGS_ASSERT_CSIGHANDLER
10431 
10432 PERL_CALLCONV Signal_t
10433 Perl_sighandler(int sig)
10434         __attribute__visibility__("hidden");
10435 # define PERL_ARGS_ASSERT_SIGHANDLER
10436 
10437 #endif /* !defined(PERL_USE_3ARG_SIGHANDLER) */
10438 #if defined(U64TYPE)
10439 
10440 #endif
10441 #if defined(UNLINK_ALL_VERSIONS)
10442 PERL_CALLCONV I32
10443 Perl_unlnk(pTHX_ const char *f);
10444 # define PERL_ARGS_ASSERT_UNLNK                 \
10445         assert(f)
10446 
10447 #endif
10448 #if defined(USE_C_BACKTRACE)
10449 PERL_CALLCONV bool
10450 Perl_dump_c_backtrace(pTHX_ PerlIO *fp, int max_depth, int skip);
10451 # define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE      \
10452         assert(fp)
10453 
10454 /* PERL_CALLCONV void
10455 free_c_backtrace(pTHX_ Perl_c_backtrace *bt); */
10456 
10457 PERL_CALLCONV Perl_c_backtrace *
10458 Perl_get_c_backtrace(pTHX_ int max_depth, int skip)
10459         __attribute__visibility__("hidden");
10460 # define PERL_ARGS_ASSERT_GET_C_BACKTRACE
10461 
10462 PERL_CALLCONV SV *
10463 Perl_get_c_backtrace_dump(pTHX_ int max_depth, int skip);
10464 # define PERL_ARGS_ASSERT_GET_C_BACKTRACE_DUMP
10465 
10466 #endif /* defined(USE_C_BACKTRACE) */
10467 #if defined(USE_DTRACE)
10468 PERL_CALLCONV void
10469 Perl_dtrace_probe_call(pTHX_ CV *cv, bool is_call);
10470 # define PERL_ARGS_ASSERT_DTRACE_PROBE_CALL     \
10471         assert(cv)
10472 
10473 PERL_CALLCONV void
10474 Perl_dtrace_probe_load(pTHX_ const char *name, bool is_loading);
10475 # define PERL_ARGS_ASSERT_DTRACE_PROBE_LOAD     \
10476         assert(name)
10477 
10478 PERL_CALLCONV void
10479 Perl_dtrace_probe_op(pTHX_ const OP *op);
10480 # define PERL_ARGS_ASSERT_DTRACE_PROBE_OP       \
10481         assert(op)
10482 
10483 PERL_CALLCONV void
10484 Perl_dtrace_probe_phase(pTHX_ enum perl_phase phase);
10485 # define PERL_ARGS_ASSERT_DTRACE_PROBE_PHASE
10486 
10487 #endif /* defined(USE_DTRACE) */
10488 #if defined(USE_ITHREADS)
10489 PERL_CALLCONV PADOFFSET
10490 Perl_alloccopstash(pTHX_ HV *hv);
10491 # define PERL_ARGS_ASSERT_ALLOCCOPSTASH         \
10492         assert(hv)
10493 
10494 PERL_CALLCONV void *
10495 Perl_any_dup(pTHX_ void *v, const PerlInterpreter *proto_perl)
10496         __attribute__warn_unused_result__;
10497 # define PERL_ARGS_ASSERT_ANY_DUP               \
10498         assert(proto_perl)
10499 
10500 PERL_CALLCONV void
10501 Perl_clone_params_del(CLONE_PARAMS *param);
10502 # define PERL_ARGS_ASSERT_CLONE_PARAMS_DEL      \
10503         assert(param)
10504 
10505 PERL_CALLCONV CLONE_PARAMS *
10506 Perl_clone_params_new(PerlInterpreter * const from, PerlInterpreter * const to)
10507         __attribute__warn_unused_result__;
10508 # define PERL_ARGS_ASSERT_CLONE_PARAMS_NEW      \
10509         assert(from); assert(to)
10510 
10511 PERL_CALLCONV PERL_CONTEXT *
10512 Perl_cx_dup(pTHX_ PERL_CONTEXT *cx, I32 ix, I32 max, CLONE_PARAMS *param)
10513         __attribute__warn_unused_result__;
10514 # define PERL_ARGS_ASSERT_CX_DUP                \
10515         assert(param)
10516 
10517 PERL_CALLCONV DIR *
10518 Perl_dirp_dup(pTHX_ DIR * const dp, CLONE_PARAMS * const param)
10519         __attribute__warn_unused_result__;
10520 # define PERL_ARGS_ASSERT_DIRP_DUP              \
10521         assert(param)
10522 
10523 PERL_CALLCONV PerlIO *
10524 Perl_fp_dup(pTHX_ PerlIO * const fp, const char type, CLONE_PARAMS * const param);
10525 # define PERL_ARGS_ASSERT_FP_DUP                \
10526         assert(param)
10527 
10528 PERL_CALLCONV GP *
10529 Perl_gp_dup(pTHX_ GP * const gp, CLONE_PARAMS * const param)
10530         __attribute__warn_unused_result__;
10531 # define PERL_ARGS_ASSERT_GP_DUP                \
10532         assert(param)
10533 
10534 PERL_CALLCONV HE *
10535 Perl_he_dup(pTHX_ const HE *e, bool shared, CLONE_PARAMS *param)
10536         __attribute__warn_unused_result__;
10537 # define PERL_ARGS_ASSERT_HE_DUP                \
10538         assert(param)
10539 
10540 PERL_CALLCONV HEK *
10541 Perl_hek_dup(pTHX_ HEK *e, CLONE_PARAMS *param)
10542         __attribute__warn_unused_result__;
10543 # define PERL_ARGS_ASSERT_HEK_DUP               \
10544         assert(param)
10545 
10546 PERL_CALLCONV MAGIC *
10547 Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS * const param)
10548         __attribute__warn_unused_result__;
10549 # define PERL_ARGS_ASSERT_MG_DUP                \
10550         assert(param)
10551 
10552 PERL_CALLCONV struct mro_meta *
10553 Perl_mro_meta_dup(pTHX_ struct mro_meta *smeta, CLONE_PARAMS *param)
10554         __attribute__visibility__("hidden");
10555 # define PERL_ARGS_ASSERT_MRO_META_DUP          \
10556         assert(smeta); assert(param)
10557 
10558 PERL_CALLCONV OP *
10559 Perl_newPADOP(pTHX_ I32 type, I32 flags, SV *sv)
10560         __attribute__warn_unused_result__;
10561 # define PERL_ARGS_ASSERT_NEWPADOP              \
10562         assert(sv)
10563 
10564 PERL_CALLCONV PADLIST *
10565 Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param)
10566         __attribute__warn_unused_result__
10567         __attribute__visibility__("hidden");
10568 # define PERL_ARGS_ASSERT_PADLIST_DUP           \
10569         assert(srcpad); assert(param)
10570 
10571 PERL_CALLCONV PADNAME *
10572 Perl_padname_dup(pTHX_ PADNAME *src, CLONE_PARAMS *param)
10573         __attribute__warn_unused_result__
10574         __attribute__visibility__("hidden");
10575 # define PERL_ARGS_ASSERT_PADNAME_DUP           \
10576         assert(src); assert(param)
10577 
10578 PERL_CALLCONV PADNAMELIST *
10579 Perl_padnamelist_dup(pTHX_ PADNAMELIST *srcpad, CLONE_PARAMS *param)
10580         __attribute__warn_unused_result__
10581         __attribute__visibility__("hidden");
10582 # define PERL_ARGS_ASSERT_PADNAMELIST_DUP       \
10583         assert(srcpad); assert(param)
10584 
10585 PERL_CALLCONV yy_parser *
10586 Perl_parser_dup(pTHX_ const yy_parser * const proto, CLONE_PARAMS * const param);
10587 # define PERL_ARGS_ASSERT_PARSER_DUP            \
10588         assert(param)
10589 
10590 PERL_CALLCONV PerlInterpreter *
10591 perl_clone(PerlInterpreter *proto_perl, UV flags);
10592 # define PERL_ARGS_ASSERT_PERL_CLONE            \
10593         assert(proto_perl)
10594 
10595 PERL_CALLCONV void
10596 Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS *param);
10597 # define PERL_ARGS_ASSERT_RE_DUP_GUTS           \
10598         assert(sstr); assert(dstr); assert(param)
10599 
10600 PERL_CALLCONV void *
10601 Perl_regdupe_internal(pTHX_ REGEXP * const r, CLONE_PARAMS *param);
10602 # define PERL_ARGS_ASSERT_REGDUPE_INTERNAL      \
10603         assert(r); assert(param)
10604 
10605 PERL_CALLCONV void
10606 Perl_rvpv_dup(pTHX_ SV * const dsv, const SV * const ssv, CLONE_PARAMS * const param);
10607 # define PERL_ARGS_ASSERT_RVPV_DUP              \
10608         assert(dsv); assert(ssv); assert(param)
10609 
10610 PERL_CALLCONV PERL_SI *
10611 Perl_si_dup(pTHX_ PERL_SI *si, CLONE_PARAMS *param)
10612         __attribute__warn_unused_result__;
10613 # define PERL_ARGS_ASSERT_SI_DUP                \
10614         assert(param)
10615 
10616 PERL_CALLCONV ANY *
10617 Perl_ss_dup(pTHX_ PerlInterpreter *proto_perl, CLONE_PARAMS *param)
10618         __attribute__warn_unused_result__;
10619 # define PERL_ARGS_ASSERT_SS_DUP                \
10620         assert(proto_perl); assert(param)
10621 
10622 PERL_CALLCONV SV *
10623 Perl_sv_dup(pTHX_ const SV * const ssv, CLONE_PARAMS * const param)
10624         __attribute__warn_unused_result__;
10625 # define PERL_ARGS_ASSERT_SV_DUP                \
10626         assert(param)
10627 
10628 PERL_CALLCONV SV *
10629 Perl_sv_dup_inc(pTHX_ const SV * const ssv, CLONE_PARAMS * const param)
10630         __attribute__warn_unused_result__;
10631 # define PERL_ARGS_ASSERT_SV_DUP_INC            \
10632         assert(param)
10633 
10634 # if defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C)
10635 PERL_CALLCONV void
10636 Perl_op_relocate_sv(pTHX_ SV **svp, PADOFFSET *targp)
10637         __attribute__visibility__("hidden");
10638 #   define PERL_ARGS_ASSERT_OP_RELOCATE_SV      \
10639         assert(svp); assert(targp)
10640 
10641 # endif
10642 #else /* if !defined(USE_ITHREADS) */
10643 /* PERL_CALLCONV void
10644 CopFILEGV_set(pTHX_ COP *c, GV *gv); */
10645 
10646 #endif
10647 #if defined(USE_LOCALE_COLLATE)
10648 PERL_CALLCONV int
10649 Perl_magic_freecollxfrm(pTHX_ SV *sv, MAGIC *mg)
10650         __attribute__visibility__("hidden");
10651 # define PERL_ARGS_ASSERT_MAGIC_FREECOLLXFRM    \
10652         assert(sv); assert(mg)
10653 
10654 PERL_CALLCONV int
10655 Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg)
10656         __attribute__visibility__("hidden");
10657 # define PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM     \
10658         assert(sv); assert(mg)
10659 
10660 PERL_CALLCONV SV *
10661 Perl_strxfrm(pTHX_ SV *src);
10662 # define PERL_ARGS_ASSERT_STRXFRM               \
10663         assert(src)
10664 
10665 PERL_CALLCONV char *
10666 Perl_sv_collxfrm_flags(pTHX_ SV * const sv, STRLEN * const nxp, I32 const flags);
10667 # define PERL_ARGS_ASSERT_SV_COLLXFRM_FLAGS     \
10668         assert(sv); assert(nxp)
10669 
10670 # if defined(PERL_IN_LOCALE_C) || defined(PERL_IN_MATHOMS_C) || \
10671      defined(PERL_IN_SV_C)
10672 PERL_CALLCONV char *
10673 Perl_mem_collxfrm_(pTHX_ const char *input_string, STRLEN len, STRLEN *xlen, bool utf8)
10674         __attribute__visibility__("hidden");
10675 #   define PERL_ARGS_ASSERT_MEM_COLLXFRM_       \
10676         assert(input_string); assert(xlen)
10677 
10678 # endif
10679 #endif /* defined(USE_LOCALE_COLLATE) */
10680 #if defined(USE_LOCALE_CTYPE)
10681 PERL_CALLCONV void
10682 Perl_warn_problematic_locale(void);
10683 # define PERL_ARGS_ASSERT_WARN_PROBLEMATIC_LOCALE
10684 
10685 #endif
10686 #if defined(USE_PERLIO)
10687 PERL_CALLCONV void
10688 Perl_PerlIO_clearerr(pTHX_ PerlIO *f);
10689 # define PERL_ARGS_ASSERT_PERLIO_CLEARERR
10690 
10691 PERL_CALLCONV int
10692 Perl_PerlIO_close(pTHX_ PerlIO *f);
10693 # define PERL_ARGS_ASSERT_PERLIO_CLOSE
10694 
10695 PERL_CALLCONV int
10696 Perl_PerlIO_eof(pTHX_ PerlIO *f);
10697 # define PERL_ARGS_ASSERT_PERLIO_EOF
10698 
10699 PERL_CALLCONV int
10700 Perl_PerlIO_error(pTHX_ PerlIO *f);
10701 # define PERL_ARGS_ASSERT_PERLIO_ERROR
10702 
10703 PERL_CALLCONV int
10704 Perl_PerlIO_fileno(pTHX_ PerlIO *f);
10705 # define PERL_ARGS_ASSERT_PERLIO_FILENO
10706 
10707 PERL_CALLCONV int
10708 Perl_PerlIO_fill(pTHX_ PerlIO *f);
10709 # define PERL_ARGS_ASSERT_PERLIO_FILL
10710 
10711 PERL_CALLCONV int
10712 Perl_PerlIO_flush(pTHX_ PerlIO *f);
10713 # define PERL_ARGS_ASSERT_PERLIO_FLUSH
10714 
10715 PERL_CALLCONV STDCHAR *
10716 Perl_PerlIO_get_base(pTHX_ PerlIO *f);
10717 # define PERL_ARGS_ASSERT_PERLIO_GET_BASE
10718 
10719 PERL_CALLCONV SSize_t
10720 Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f)
10721         __attribute__warn_unused_result__;
10722 # define PERL_ARGS_ASSERT_PERLIO_GET_BUFSIZ
10723 
10724 PERL_CALLCONV SSize_t
10725 Perl_PerlIO_get_cnt(pTHX_ PerlIO *f)
10726         __attribute__warn_unused_result__;
10727 # define PERL_ARGS_ASSERT_PERLIO_GET_CNT
10728 
10729 PERL_CALLCONV STDCHAR *
10730 Perl_PerlIO_get_ptr(pTHX_ PerlIO *f);
10731 # define PERL_ARGS_ASSERT_PERLIO_GET_PTR
10732 
10733 PERL_CALLCONV SSize_t
10734 Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
10735 # define PERL_ARGS_ASSERT_PERLIO_READ           \
10736         assert(vbuf)
10737 
10738 PERL_CALLCONV void
10739 Perl_PerlIO_restore_errno(pTHX_ PerlIO *f);
10740 # define PERL_ARGS_ASSERT_PERLIO_RESTORE_ERRNO
10741 
10742 PERL_CALLCONV void
10743 Perl_PerlIO_save_errno(pTHX_ PerlIO *f);
10744 # define PERL_ARGS_ASSERT_PERLIO_SAVE_ERRNO
10745 
10746 PERL_CALLCONV int
10747 Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
10748 # define PERL_ARGS_ASSERT_PERLIO_SEEK
10749 
10750 PERL_CALLCONV void
10751 Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, SSize_t cnt);
10752 # define PERL_ARGS_ASSERT_PERLIO_SET_CNT
10753 
10754 PERL_CALLCONV void
10755 Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR *ptr, SSize_t cnt);
10756 # define PERL_ARGS_ASSERT_PERLIO_SET_PTRCNT
10757 
10758 PERL_CALLCONV void
10759 Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f);
10760 # define PERL_ARGS_ASSERT_PERLIO_SETLINEBUF
10761 
10762 PERL_CALLCONV PerlIO *
10763 Perl_PerlIO_stderr(pTHX)
10764         __attribute__warn_unused_result__;
10765 # define PERL_ARGS_ASSERT_PERLIO_STDERR
10766 
10767 PERL_CALLCONV PerlIO *
10768 Perl_PerlIO_stdin(pTHX)
10769         __attribute__warn_unused_result__;
10770 # define PERL_ARGS_ASSERT_PERLIO_STDIN
10771 
10772 PERL_CALLCONV PerlIO *
10773 Perl_PerlIO_stdout(pTHX)
10774         __attribute__warn_unused_result__;
10775 # define PERL_ARGS_ASSERT_PERLIO_STDOUT
10776 
10777 PERL_CALLCONV Off_t
10778 Perl_PerlIO_tell(pTHX_ PerlIO *f);
10779 # define PERL_ARGS_ASSERT_PERLIO_TELL
10780 
10781 PERL_CALLCONV SSize_t
10782 Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
10783 # define PERL_ARGS_ASSERT_PERLIO_UNREAD         \
10784         assert(vbuf)
10785 
10786 PERL_CALLCONV SSize_t
10787 Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
10788 # define PERL_ARGS_ASSERT_PERLIO_WRITE          \
10789         assert(vbuf)
10790 
10791 #endif /* defined(USE_PERLIO) */
10792 #if defined(USE_PERL_SWITCH_LOCALE_CONTEXT)
10793 PERL_CALLCONV void
10794 Perl_switch_locale_context(pTHX);
10795 # define PERL_ARGS_ASSERT_SWITCH_LOCALE_CONTEXT
10796 
10797 #endif
10798 #if defined(USE_QUADMATH)
10799 PERL_CALLCONV bool
10800 Perl_quadmath_format_needed(const char *format)
10801         __attribute__visibility__("hidden");
10802 # define PERL_ARGS_ASSERT_QUADMATH_FORMAT_NEEDED \
10803         assert(format)
10804 
10805 PERL_CALLCONV bool
10806 Perl_quadmath_format_valid(const char *format)
10807         __attribute__visibility__("hidden");
10808 # define PERL_ARGS_ASSERT_QUADMATH_FORMAT_VALID \
10809         assert(format)
10810 
10811 #endif /* defined(USE_QUADMATH) */
10812 #if defined(USE_THREADS)
10813 PERL_CALLCONV void
10814 Perl_thread_locale_init(pTHX);
10815 # define PERL_ARGS_ASSERT_THREAD_LOCALE_INIT
10816 
10817 PERL_CALLCONV void
10818 Perl_thread_locale_term(pTHX);
10819 # define PERL_ARGS_ASSERT_THREAD_LOCALE_TERM
10820 
10821 #endif
10822 #if defined(VMS) || defined(WIN32)
10823 PERL_CALLCONV int
10824 Perl_do_aspawn(pTHX_ SV *really, SV **mark, SV **sp);
10825 # define PERL_ARGS_ASSERT_DO_ASPAWN             \
10826         assert(mark); assert(sp)
10827 
10828 PERL_CALLCONV int
10829 Perl_do_spawn(pTHX_ char *cmd);
10830 # define PERL_ARGS_ASSERT_DO_SPAWN              \
10831         assert(cmd)
10832 
10833 PERL_CALLCONV int
10834 Perl_do_spawn_nowait(pTHX_ char *cmd);
10835 # define PERL_ARGS_ASSERT_DO_SPAWN_NOWAIT       \
10836         assert(cmd)
10837 
10838 #endif /* defined(VMS) || defined(WIN32) */
10839 #if defined(WIN32)
10840 PERL_CALLCONV void *
10841 Perl_get_context(void)
10842         __attribute__warn_unused_result__;
10843 # define PERL_ARGS_ASSERT_GET_CONTEXT
10844 
10845 PERL_CALLCONV bool
10846 Perl_get_win32_message_utf8ness(pTHX_ const char *string)
10847         __attribute__visibility__("hidden");
10848 # define PERL_ARGS_ASSERT_GET_WIN32_MESSAGE_UTF8NESS
10849 
10850 PERL_CALLCONV_NO_RET void
10851 win32_croak_not_implemented(const char *fname)
10852         __attribute__noreturn__;
10853 # define PERL_ARGS_ASSERT_WIN32_CROAK_NOT_IMPLEMENTED \
10854         assert(fname)
10855 
10856 #else /* if !defined(WIN32) */
10857 PERL_CALLCONV bool
10858 Perl_do_exec3(pTHX_ const char *incmd, int fd, int do_report)
10859         __attribute__visibility__("hidden");
10860 # define PERL_ARGS_ASSERT_DO_EXEC3              \
10861         assert(incmd)
10862 
10863 #endif
10864 
10865 #ifdef PERL_CORE
10866 #  include "pp_proto.h"
10867 #endif
10868 END_EXTERN_C
10869 
10870 /* ex: set ro ft=c: */
10871