proto.h

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