diff --git a/proto.h b/proto.h index 64d50774ad2e..41611ffacd35 100644 --- a/proto.h +++ b/proto.h @@ -19,12 +19,18 @@ * Edit those files and run 'make regen_headers' to effect changes. */ +#ifdef HASATTRIBUTE_NONNULL +# define PERL_ASSUME_NON_NULL(what) +#else +# define PERL_ASSUME_NON_NULL(what) ASSUME(what) +#endif + START_EXTERN_C PERL_CALLCONV int Perl_Gv_AMupdate(pTHX_ HV *stash, bool destructing); #define PERL_ARGS_ASSERT_GV_AMUPDATE \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV const char * Perl_PerlIO_context_layers(pTHX_ const char *mode); @@ -46,14 +52,14 @@ Perl_PerlLIO_open3_cloexec(pTHX_ const char *file, int flag, int perm) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PERLLIO_OPEN3_CLOEXEC \ - assert(file) + ASSUME(file) PERL_CALLCONV int Perl_PerlLIO_open_cloexec(pTHX_ const char *file, int flag) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PERLLIO_OPEN_CLOEXEC \ - assert(file) + ASSUME(file) /* PERL_CALLCONV const XOP * Perl_custom_op_xop(pTHX_ const OP *o); */ @@ -63,9 +69,10 @@ Perl_langinfo(const nl_item item); #define PERL_ARGS_ASSERT_PERL_LANGINFO PERL_CALLCONV const char * -Perl_langinfo8(const nl_item item, utf8ness_t *utf8ness); +Perl_langinfo8(const nl_item item, utf8ness_t *utf8ness) + __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_PERL_LANGINFO8 \ - assert(utf8ness) + PERL_ASSUME_NON_NULL(utf8ness) PERL_CALLCONV HV * Perl_localeconv(pTHX); @@ -83,7 +90,7 @@ Perl_Slab_Alloc(pTHX_ size_t sz) PERL_CALLCONV void Perl_Slab_Free(pTHX_ void *op); #define PERL_ARGS_ASSERT_SLAB_FREE \ - assert(op) + ASSUME(op) /* PERL_CALLCONV void Perl_SvREFCNT_dec_set_NULL(pTHX_ SV *sv); */ @@ -91,7 +98,7 @@ Perl_SvREFCNT_dec_set_NULL(pTHX_ SV *sv); */ #define PERL_ARGS_ASSERT__BYTE_DUMP_STRING #define PERL_ARGS_ASSERT__INVERSE_FOLDS \ - assert(first_folds_to); assert(remaining_folds_to) + ASSUME(first_folds_to); ASSUME(remaining_folds_to) PERL_CALLCONV bool Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c) @@ -112,51 +119,51 @@ PERL_CALLCONV bool Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UTF8_FOO \ - assert(p); assert(e) + ASSUME(p); ASSUME(e) PERL_CALLCONV bool Perl__is_utf8_perl_idcont(pTHX_ const U8 *p, const U8 * const e) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT \ - assert(p); assert(e) + ASSUME(p); ASSUME(e) PERL_CALLCONV bool Perl__is_utf8_perl_idstart(pTHX_ const U8 *p, const U8 * const e) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \ - assert(p); assert(e) + ASSUME(p); ASSUME(e) PERL_CALLCONV UV Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags); #define PERL_ARGS_ASSERT__TO_UNI_FOLD_FLAGS \ - assert(p); assert(lenp) + ASSUME(p); ASSUME(lenp) PERL_CALLCONV UV Perl__to_utf8_fold_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, U8 flags); #define PERL_ARGS_ASSERT__TO_UTF8_FOLD_FLAGS \ - assert(p); assert(ustrp) + ASSUME(p); ASSUME(ustrp) PERL_CALLCONV UV Perl__to_utf8_lower_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); #define PERL_ARGS_ASSERT__TO_UTF8_LOWER_FLAGS \ - assert(p); assert(ustrp) + ASSUME(p); ASSUME(ustrp) PERL_CALLCONV UV Perl__to_utf8_title_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); #define PERL_ARGS_ASSERT__TO_UTF8_TITLE_FLAGS \ - assert(p); assert(ustrp) + ASSUME(p); ASSUME(ustrp) PERL_CALLCONV UV Perl__to_utf8_upper_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); #define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS \ - assert(p); assert(ustrp) + ASSUME(p); ASSUME(ustrp) PERL_CALLCONV_NO_RET void Perl_abort_execution(pTHX_ SV *msg_sv, const char * const name) __attribute__noreturn__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_ABORT_EXECUTION \ - assert(name) + ASSUME(name) PERL_CALLCONV LOGOP * Perl_alloc_LOGOP(pTHX_ I32 type, OP *first, OP *other) @@ -167,22 +174,22 @@ PERL_CALLCONV PADOFFSET Perl_allocmy(pTHX_ const char * const name, const STRLEN len, const U32 flags) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_ALLOCMY \ - assert(name) + ASSUME(name) PERL_CALLCONV bool Perl_amagic_applies(pTHX_ SV *sv, int method, int flags); #define PERL_ARGS_ASSERT_AMAGIC_APPLIES \ - assert(sv) + ASSUME(sv) PERL_CALLCONV SV * Perl_amagic_call(pTHX_ SV *left, SV *right, int method, int dir); #define PERL_ARGS_ASSERT_AMAGIC_CALL \ - assert(left); assert(right) + ASSUME(left); ASSUME(right) PERL_CALLCONV SV * Perl_amagic_deref_call(pTHX_ SV *ref, int method); #define PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL \ - assert(ref) + ASSUME(ref) PERL_CALLCONV bool Perl_amagic_is_enabled(pTHX_ int method) @@ -193,19 +200,19 @@ PERL_CALLCONV SSize_t Perl_apply(pTHX_ I32 type, SV **mark, SV **sp) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_APPLY \ - assert(mark); assert(sp) + ASSUME(mark); ASSUME(sp) PERL_CALLCONV void Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv, const char *attrstr, STRLEN len); #define PERL_ARGS_ASSERT_APPLY_ATTRS_STRING \ - assert(stashpv); assert(cv); \ - assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ - assert(attrstr) + ASSUME(stashpv); ASSUME(cv); \ + ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ + ASSUME(attrstr) PERL_CALLCONV OP * Perl_apply_builtin_cv_attributes(pTHX_ CV *cv, OP *attrlist); #define PERL_ARGS_ASSERT_APPLY_BUILTIN_CV_ATTRIBUTES \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_atfork_child(void); @@ -222,125 +229,125 @@ Perl_atfork_unlock(void); PERL_CALLCONV SV ** Perl_av_arylen_p(pTHX_ AV *av); #define PERL_ARGS_ASSERT_AV_ARYLEN_P \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_clear(pTHX_ AV *av); #define PERL_ARGS_ASSERT_AV_CLEAR \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_create_and_push(pTHX_ AV ** const avp, SV * const val); #define PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH \ - assert(avp); assert(val) + ASSUME(avp); ASSUME(val) PERL_CALLCONV SV ** Perl_av_create_and_unshift_one(pTHX_ AV ** const avp, SV * const val); #define PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE \ - assert(avp); assert(val) + ASSUME(avp); ASSUME(val) PERL_CALLCONV SV * Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags); #define PERL_ARGS_ASSERT_AV_DELETE \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_dump(pTHX_ AV *av); #define PERL_ARGS_ASSERT_AV_DUMP \ - assert(!av || SvTYPE(av) == SVt_PVAV) + ASSUME(!av || SvTYPE(av) == SVt_PVAV) PERL_CALLCONV bool Perl_av_exists(pTHX_ AV *av, SSize_t key) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_EXISTS \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_extend(pTHX_ AV *av, SSize_t key); #define PERL_ARGS_ASSERT_AV_EXTEND \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_extend_guts(pTHX_ AV *av, SSize_t key, SSize_t *maxp, SV ***allocp, SV ***arrayp) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_AV_EXTEND_GUTS \ - assert(!av || SvTYPE(av) == SVt_PVAV); assert(maxp); assert(allocp); \ - assert(arrayp) + ASSUME(!av || SvTYPE(av) == SVt_PVAV); ASSUME(maxp); ASSUME(allocp); \ + ASSUME(arrayp) PERL_CALLCONV SV ** Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_FETCH \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_fill(pTHX_ AV *av, SSize_t fill); #define PERL_ARGS_ASSERT_AV_FILL \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV IV * Perl_av_iter_p(pTHX_ AV *av); #define PERL_ARGS_ASSERT_AV_ITER_P \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV SSize_t Perl_av_len(pTHX_ AV *av) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_LEN \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV AV * Perl_av_make(pTHX_ SSize_t size, SV **strp) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_MAKE \ - assert(strp) + ASSUME(strp) PERL_CALLCONV SV * Perl_av_nonelem(pTHX_ AV *av, SSize_t ix) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_AV_NONELEM \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV SV * Perl_av_pop(pTHX_ AV *av); #define PERL_ARGS_ASSERT_AV_POP \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_push(pTHX_ AV *av, SV *val); #define PERL_ARGS_ASSERT_AV_PUSH \ - assert(av); assert(SvTYPE(av) == SVt_PVAV); assert(val) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV); ASSUME(val) #define PERL_ARGS_ASSERT_AV_REIFY \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV SV * Perl_av_shift(pTHX_ AV *av) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_SHIFT \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV SV ** Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val); #define PERL_ARGS_ASSERT_AV_STORE \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_undef(pTHX_ AV *av); #define PERL_ARGS_ASSERT_AV_UNDEF \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV void Perl_av_unshift(pTHX_ AV *av, SSize_t num); #define PERL_ARGS_ASSERT_AV_UNSHIFT \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV OP * Perl_bind_match(pTHX_ I32 type, OP *left, OP *right) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_BIND_MATCH \ - assert(left); assert(right) + ASSUME(left); ASSUME(right) PERL_CALLCONV OP * Perl_block_end(pTHX_ I32 floor, OP *seq) @@ -360,7 +367,7 @@ Perl_block_start(pTHX_ int full) PERL_CALLCONV void Perl_blockhook_register(pTHX_ BHK *hk); #define PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER \ - assert(hk) + ASSUME(hk) PERL_CALLCONV void Perl_boot_core_PerlIO(pTHX) @@ -386,22 +393,22 @@ PERL_CALLCONV OP * Perl_build_infix_plugin(pTHX_ OP *lhs, OP *rhs, void *tokendata) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_BUILD_INFIX_PLUGIN \ - assert(lhs); assert(rhs); assert(tokendata) + ASSUME(lhs); ASSUME(rhs); ASSUME(tokendata) PERL_CALLCONV int Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen); #define PERL_ARGS_ASSERT_BYTES_CMP_UTF8 \ - assert(b); assert(u) + ASSUME(b); ASSUME(u) PERL_CALLCONV U8 * Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *lenp, bool *is_utf8p); #define PERL_ARGS_ASSERT_BYTES_FROM_UTF8 \ - assert(s); assert(lenp); assert(is_utf8p) + ASSUME(s); ASSUME(lenp); ASSUME(is_utf8p) PERL_CALLCONV U8 * Perl_bytes_to_utf8_free_me(pTHX_ const U8 *s, STRLEN *lenp, void **free_me); #define PERL_ARGS_ASSERT_BYTES_TO_UTF8_FREE_ME \ - assert(s); assert(lenp) + ASSUME(s); ASSUME(lenp) /* PERL_CALLCONV bool Perl_c9strict_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p); */ @@ -409,7 +416,7 @@ Perl_c9strict_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_ PERL_CALLCONV SSize_t Perl_call_argv(pTHX_ const char *sub_name, I32 flags, char **argv); #define PERL_ARGS_ASSERT_CALL_ARGV \ - assert(sub_name); assert(argv) + ASSUME(sub_name); ASSUME(argv) PERL_CALLCONV void Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr); @@ -418,22 +425,22 @@ Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr); PERL_CALLCONV void Perl_call_list(pTHX_ I32 oldscope, AV *paramList); #define PERL_ARGS_ASSERT_CALL_LIST \ - assert(paramList); assert(SvTYPE(paramList) == SVt_PVAV) + ASSUME(paramList); ASSUME(SvTYPE(paramList) == SVt_PVAV) PERL_CALLCONV SSize_t Perl_call_method(pTHX_ const char *methname, I32 flags); #define PERL_ARGS_ASSERT_CALL_METHOD \ - assert(methname) + ASSUME(methname) PERL_CALLCONV SSize_t Perl_call_pv(pTHX_ const char *sub_name, I32 flags); #define PERL_ARGS_ASSERT_CALL_PV \ - assert(sub_name) + ASSUME(sub_name) PERL_CALLCONV SSize_t Perl_call_sv(pTHX_ SV *sv, I32 flags); #define PERL_ARGS_ASSERT_CALL_SV \ - assert(sv) + ASSUME(sv) PERL_CALLCONV const PERL_CONTEXT * Perl_caller_cx(pTHX_ I32 level, const PERL_CONTEXT **dbcxp); @@ -450,7 +457,7 @@ Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t *statbufp) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CANDO \ - assert(statbufp) + ASSUME(statbufp) PERL_CALLCONV I32 Perl_cast_i32(NV f) @@ -476,40 +483,40 @@ PERL_CALLCONV bool Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CHECK_UTF8_PRINT \ - assert(s) + ASSUME(s) PERL_CALLCONV OP * Perl_ck_entersub_args_core(pTHX_ OP *entersubop, GV *namegv, SV *protosv) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_CORE \ - assert(entersubop); assert(namegv); assert(protosv) + ASSUME(entersubop); ASSUME(namegv); ASSUME(protosv) PERL_CALLCONV OP * Perl_ck_entersub_args_list(pTHX_ OP *entersubop); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_LIST \ - assert(entersubop) + ASSUME(entersubop) PERL_CALLCONV OP * Perl_ck_entersub_args_proto(pTHX_ OP *entersubop, GV *namegv, SV *protosv); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO \ - assert(entersubop); assert(namegv); assert(protosv) + ASSUME(entersubop); ASSUME(namegv); ASSUME(protosv) PERL_CALLCONV OP * Perl_ck_entersub_args_proto_or_list(pTHX_ OP *entersubop, GV *namegv, SV *protosv); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO_OR_LIST \ - assert(entersubop); assert(namegv); assert(protosv) + ASSUME(entersubop); ASSUME(namegv); ASSUME(protosv) PERL_CALLCONV void Perl_ck_warner(pTHX_ U32 err, const char *pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_CK_WARNER \ - assert(pat) + ASSUME(pat) PERL_CALLCONV void Perl_ck_warner_d(pTHX_ U32 err, const char *pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_CK_WARNER_D \ - assert(pat) + ASSUME(pat) PERL_CALLCONV bool Perl_ckwarn(pTHX_ U32 w) @@ -526,27 +533,27 @@ Perl_ckwarn_d(pTHX_ U32 w) PERL_CALLCONV void Perl_clear_defarray(pTHX_ AV *av, bool abandon); #define PERL_ARGS_ASSERT_CLEAR_DEFARRAY \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV const COP * Perl_closest_cop(pTHX_ const COP *cop, const OP *o, const OP *curop, bool opnext) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CLOSEST_COP \ - assert(cop) + ASSUME(cop) PERL_CALLCONV OP * Perl_cmpchain_extend(pTHX_ I32 type, OP *ch, OP *right) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CMPCHAIN_EXTEND \ - assert(ch) + ASSUME(ch) PERL_CALLCONV OP * Perl_cmpchain_finish(pTHX_ OP *ch) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CMPCHAIN_FINISH \ - assert(ch) + ASSUME(ch) PERL_CALLCONV OP * Perl_cmpchain_start(pTHX_ I32 type, OP *left, OP *right) @@ -559,30 +566,30 @@ Perl_cmpchain_start(pTHX_ I32 type, OP *left, OP *right) PERL_CALLCONV const char * Perl_cop_fetch_label(pTHX_ COP * const cop, STRLEN *len, U32 *flags); #define PERL_ARGS_ASSERT_COP_FETCH_LABEL \ - assert(cop) + ASSUME(cop) PERL_CALLCONV void Perl_cop_store_label(pTHX_ COP * const cop, const char *label, STRLEN len, U32 flags); #define PERL_ARGS_ASSERT_COP_STORE_LABEL \ - assert(cop); assert(label) + ASSUME(cop); ASSUME(label) PERL_CALLCONV SV * Perl_core_prototype(pTHX_ SV *sv, const char *name, const int code, int * const opnum) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CORE_PROTOTYPE \ - assert(name) + ASSUME(name) PERL_CALLCONV OP * Perl_coresub_op(pTHX_ SV * const coreargssv, const int code, const int opnum) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CORESUB_OP \ - assert(coreargssv) + ASSUME(coreargssv) PERL_CALLCONV void Perl_create_eval_scope(pTHX_ OP *retop, SV **sp, U32 flags) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CREATE_EVAL_SCOPE \ - assert(sp) + ASSUME(sp) PERL_CALLCONV_NO_RET void Perl_croak(pTHX_ const char *pat, ...) @@ -610,10 +617,11 @@ Perl_croak_no_mem(void) PERL_CALLCONV_NO_RET void Perl_croak_no_mem_ext(const char *context, STRLEN len) + __attribute__nonnull__(1) __attribute__noreturn__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CROAK_NO_MEM_EXT \ - assert(context) + PERL_ASSUME_NON_NULL(context) PERL_CALLCONV_NO_RET void Perl_croak_no_modify(void) @@ -629,13 +637,15 @@ PERL_CALLCONV_NO_RET void Perl_croak_sv(pTHX_ SV *baseex) __attribute__noreturn__; #define PERL_ARGS_ASSERT_CROAK_SV \ - assert(baseex) + ASSUME(baseex) PERL_CALLCONV_NO_RET void Perl_croak_xs_usage(const CV * const cv, const char * const params) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__noreturn__; #define PERL_ARGS_ASSERT_CROAK_XS_USAGE \ - assert(cv); assert(params) + PERL_ASSUME_NON_NULL(cv); PERL_ASSUME_NON_NULL(params) PERL_CALLCONV Signal_t Perl_csighandler1(int sig); @@ -651,30 +661,30 @@ PERL_CALLCONV XOPRETANY Perl_custom_op_get_field(pTHX_ const OP *o, const xop_flags_enum field) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CUSTOM_OP_GET_FIELD \ - assert(o) + ASSUME(o) PERL_CALLCONV void Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop); #define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER \ - assert(ppaddr); assert(xop) + ASSUME(ppaddr); ASSUME(xop) #define PERL_ARGS_ASSERT_CV_CKPROTO_LEN_FLAGS \ - assert(cv) + ASSUME(cv) PERL_CALLCONV CV * Perl_cv_clone(pTHX_ CV *proto); #define PERL_ARGS_ASSERT_CV_CLONE \ - assert(proto); \ - assert(SvTYPE(proto) == SVt_PVCV || SvTYPE(proto) == SVt_PVFM) + ASSUME(proto); \ + ASSUME(SvTYPE(proto) == SVt_PVCV || SvTYPE(proto) == SVt_PVFM) PERL_CALLCONV CV * Perl_cv_clone_into(pTHX_ CV *proto, CV *target) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CV_CLONE_INTO \ - assert(proto); \ - assert(SvTYPE(proto) == SVt_PVCV || SvTYPE(proto) == SVt_PVFM); \ - assert(target); \ - assert(SvTYPE(target) == SVt_PVCV || SvTYPE(target) == SVt_PVFM) + ASSUME(proto); \ + ASSUME(SvTYPE(proto) == SVt_PVCV || SvTYPE(proto) == SVt_PVFM); \ + ASSUME(target); \ + ASSUME(SvTYPE(target) == SVt_PVCV || SvTYPE(target) == SVt_PVFM) PERL_CALLCONV SV * Perl_cv_const_sv(const CV * const cv) @@ -691,68 +701,68 @@ PERL_CALLCONV void Perl_cv_forget_slab(pTHX_ CV *cv) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CV_FORGET_SLAB \ - assert(!cv || SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(!cv || SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p); #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ - assert(ckfun_p); assert(ckobj_p) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ + ASSUME(ckfun_p); ASSUME(ckobj_p) PERL_CALLCONV void Perl_cv_get_call_checker_flags(pTHX_ CV *cv, U32 gflags, Perl_call_checker *ckfun_p, SV **ckobj_p, U32 *ckflags_p); #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER_FLAGS \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ - assert(ckfun_p); assert(ckobj_p); assert(ckflags_p) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ + ASSUME(ckfun_p); ASSUME(ckobj_p); ASSUME(ckflags_p) PERL_CALLCONV SV * Perl_cv_name(pTHX_ CV *cv, SV *sv, U32 flags); #define PERL_ARGS_ASSERT_CV_NAME \ - assert(cv) + ASSUME(cv) PERL_CALLCONV void Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj); #define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ - assert(ckfun); assert(ckobj) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ + ASSUME(ckfun); ASSUME(ckobj) PERL_CALLCONV void Perl_cv_set_call_checker_flags(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj, U32 ckflags); #define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER_FLAGS \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ - assert(ckfun); assert(ckobj) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ + ASSUME(ckfun); ASSUME(ckobj) PERL_CALLCONV void Perl_cv_undef(pTHX_ CV *cv); #define PERL_ARGS_ASSERT_CV_UNDEF \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_cv_undef_flags(pTHX_ CV *cv, U32 flags) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_CV_UNDEF_FLAGS \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV GV * Perl_cvgv_from_hek(pTHX_ CV *cv); #define PERL_ARGS_ASSERT_CVGV_FROM_HEK \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_cvgv_set(pTHX_ CV *cv, GV *gv); #define PERL_ARGS_ASSERT_CVGV_SET \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_cvstash_set(pTHX_ CV *cv, HV *stash); #define PERL_ARGS_ASSERT_CVSTASH_SET \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ - assert(!stash || SvTYPE(stash) == SVt_PVHV) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ + ASSUME(!stash || SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void Perl_cx_dump(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_DUMP \ - assert(cx) + ASSUME(cx) PERL_CALLCONV I32 Perl_cxinc(pTHX) @@ -763,7 +773,7 @@ PERL_CALLCONV void Perl_deb(pTHX_ const char *pat, ...) __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_DEB \ - assert(pat) + ASSUME(pat) PERL_CALLCONV void Perl_deb_stack_all(pTHX) @@ -773,7 +783,7 @@ Perl_deb_stack_all(pTHX) PERL_CALLCONV I32 Perl_debop(pTHX_ const OP *o); #define PERL_ARGS_ASSERT_DEBOP \ - assert(o) + ASSUME(o) PERL_CALLCONV void Perl_debprofdump(pTHX); @@ -797,7 +807,7 @@ Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DEFELEM_TARGET \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_delete_eval_scope(pTHX) @@ -805,14 +815,21 @@ Perl_delete_eval_scope(pTHX) #define PERL_ARGS_ASSERT_DELETE_EVAL_SCOPE PERL_CALLCONV char * -Perl_delimcpy(char *to, const char *to_end, const char *from, const char *from_end, const int delim, I32 *retlen); +Perl_delimcpy(char *to, const char *to_end, const char *from, const char *from_end, const int delim, I32 *retlen) + __attribute__nonnull__(1) + __attribute__nonnull__(2) + __attribute__nonnull__(3) + __attribute__nonnull__(4) + __attribute__nonnull__(6); #define PERL_ARGS_ASSERT_DELIMCPY \ - assert(to); assert(to_end); assert(from); assert(from_end); \ - assert(retlen) + PERL_ASSUME_NON_NULL(to); PERL_ASSUME_NON_NULL(to_end); \ + PERL_ASSUME_NON_NULL(from); PERL_ASSUME_NON_NULL(from_end); \ + PERL_ASSUME_NON_NULL(retlen) #define PERL_ARGS_ASSERT_DELIMCPY_NO_ESCAPE \ - assert(to); assert(to_end); assert(from); assert(from_end); \ - assert(retlen) + PERL_ASSUME_NON_NULL(to); PERL_ASSUME_NON_NULL(to_end); \ + PERL_ASSUME_NON_NULL(from); PERL_ASSUME_NON_NULL(from_end); \ + PERL_ASSUME_NON_NULL(retlen) PERL_CALLCONV void Perl_despatch_signals(pTHX); @@ -828,14 +845,14 @@ PERL_CALLCONV_NO_RET OP * Perl_die_sv(pTHX_ SV *baseex) __attribute__noreturn__; #define PERL_ARGS_ASSERT_DIE_SV \ - assert(baseex) + ASSUME(baseex) PERL_CALLCONV_NO_RET void Perl_die_unwind(pTHX_ SV *msv) __attribute__noreturn__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DIE_UNWIND \ - assert(msv) + ASSUME(msv) /* PERL_CALLCONV bool Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp); */ @@ -844,7 +861,7 @@ PERL_CALLCONV bool Perl_do_aexec5(pTHX_ SV *really, SV **mark, SV **sp, int fd, int do_report) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_AEXEC5 \ - assert(mark); assert(sp) + ASSUME(mark); ASSUME(sp) PERL_CALLCONV bool Perl_do_close(pTHX_ GV *gv, bool is_explicit); @@ -854,50 +871,50 @@ PERL_CALLCONV void Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_DUMP_PAD \ - assert(file) + ASSUME(file) PERL_CALLCONV bool Perl_do_eof(pTHX_ GV *gv) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_EOF \ - assert(gv) + ASSUME(gv) PERL_CALLCONV void Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv); #define PERL_ARGS_ASSERT_DO_GV_DUMP \ - assert(file); assert(name) + ASSUME(file); ASSUME(name) PERL_CALLCONV void Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv); #define PERL_ARGS_ASSERT_DO_GVGV_DUMP \ - assert(file); assert(name) + ASSUME(file); ASSUME(name) PERL_CALLCONV void Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv); #define PERL_ARGS_ASSERT_DO_HV_DUMP \ - assert(file); assert(name); assert(!sv || SvTYPE(sv) == SVt_PVHV) + ASSUME(file); ASSUME(name); ASSUME(!sv || SvTYPE(sv) == SVt_PVHV) PERL_CALLCONV void Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp); #define PERL_ARGS_ASSERT_DO_JOIN \ - assert(sv); assert(delim); assert(mark); assert(sp) + ASSUME(sv); ASSUME(delim); ASSUME(mark); ASSUME(sp) PERL_CALLCONV void Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim); #define PERL_ARGS_ASSERT_DO_MAGIC_DUMP \ - assert(file) + ASSUME(file) PERL_CALLCONV I32 Perl_do_ncmp(pTHX_ SV * const left, SV * const right) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_NCMP \ - assert(left); assert(right) + ASSUME(left); ASSUME(right) PERL_CALLCONV void Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o); #define PERL_ARGS_ASSERT_DO_OP_DUMP \ - assert(file) + ASSUME(file) /* PERL_CALLCONV bool Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp); */ @@ -906,29 +923,29 @@ PERL_CALLCONV bool Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_OPEN6 \ - assert(gv); assert(oname) + ASSUME(gv); ASSUME(oname) PERL_CALLCONV bool Perl_do_open_raw(pTHX_ GV *gv, const char *oname, STRLEN len, int rawmode, int rawperm, Stat_t *statbufp) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_OPEN_RAW \ - assert(gv); assert(oname) + ASSUME(gv); ASSUME(oname) PERL_CALLCONV bool Perl_do_openn(pTHX_ GV *gv, const char *oname, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV **svp, I32 num); #define PERL_ARGS_ASSERT_DO_OPENN \ - assert(gv); assert(oname) + ASSUME(gv); ASSUME(oname) PERL_CALLCONV void Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm); #define PERL_ARGS_ASSERT_DO_PMOP_DUMP \ - assert(file) + ASSUME(file) PERL_CALLCONV bool Perl_do_print(pTHX_ SV *sv, PerlIO *fp) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_PRINT \ - assert(fp) + ASSUME(fp) PERL_CALLCONV OP * Perl_do_readline(pTHX) @@ -944,58 +961,58 @@ Perl_do_seek(pTHX_ GV *gv, Off_t pos, int whence) PERL_CALLCONV void Perl_do_sprintf(pTHX_ SV *sv, SSize_t len, SV **sarg); #define PERL_ARGS_ASSERT_DO_SPRINTF \ - assert(sv); assert(sarg) + ASSUME(sv); ASSUME(sarg) PERL_CALLCONV void Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim); #define PERL_ARGS_ASSERT_DO_SV_DUMP \ - assert(file) + ASSUME(file) PERL_CALLCONV Off_t Perl_do_sysseek(pTHX_ GV *gv, Off_t pos, int whence) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_SYSSEEK \ - assert(gv) + ASSUME(gv) PERL_CALLCONV Off_t Perl_do_tell(pTHX_ GV *gv) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_TELL \ - assert(gv) + ASSUME(gv) PERL_CALLCONV Size_t Perl_do_trans(pTHX_ SV *sv) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_TRANS \ - assert(sv) + ASSUME(sv) #define PERL_ARGS_ASSERT_DO_UNIPROP_MATCH \ - assert(key) + PERL_ASSUME_NON_NULL(key) PERL_CALLCONV UV Perl_do_vecget(pTHX_ SV *sv, STRLEN offset, int size) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_VECGET \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_do_vecset(pTHX_ SV *sv) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_VECSET \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_do_vop(pTHX_ I32 optype, SV *sv, SV *left, SV *right) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DO_VOP \ - assert(sv); assert(left); assert(right) + ASSUME(sv); ASSUME(left); ASSUME(right) PERL_CALLCONV OP * Perl_dofile(pTHX_ OP *term, I32 force_builtin) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DOFILE \ - assert(term) + ASSUME(term) PERL_CALLCONV bool Perl_doing_taint(int argc, char **argv, char **env) @@ -1005,7 +1022,7 @@ Perl_doing_taint(int argc, char **argv, char **env) PERL_CALLCONV OP * Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref); #define PERL_ARGS_ASSERT_DOREF \ - assert(o) + ASSUME(o) PERL_CALLCONV void Perl_dounwind(pTHX_ I32 cxix); @@ -1018,14 +1035,16 @@ Perl_dowantarray(pTHX) #define PERL_ARGS_ASSERT_DOWANTARRAY PERL_CALLCONV void -Perl_drand48_init_r(perl_drand48_t *random_state, U32 seed); +Perl_drand48_init_r(perl_drand48_t *random_state, U32 seed) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_DRAND48_INIT_R \ - assert(random_state) + PERL_ASSUME_NON_NULL(random_state) PERL_CALLCONV double -Perl_drand48_r(perl_drand48_t *random_state); +Perl_drand48_r(perl_drand48_t *random_state) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_DRAND48_R \ - assert(random_state) + PERL_ASSUME_NON_NULL(random_state) PERL_CALLCONV void Perl_dump_all(pTHX); @@ -1043,55 +1062,55 @@ Perl_dump_eval(pTHX); PERL_CALLCONV void Perl_dump_form(pTHX_ const GV *gv); #define PERL_ARGS_ASSERT_DUMP_FORM \ - assert(gv) + ASSUME(gv) PERL_CALLCONV void Perl_dump_indent(pTHX_ I32 level, PerlIO *file, const char *pat, ...) __attribute__format__(__printf__,pTHX_3,pTHX_4); #define PERL_ARGS_ASSERT_DUMP_INDENT \ - assert(file); assert(pat) + ASSUME(file); ASSUME(pat) PERL_CALLCONV void Perl_dump_packsubs(pTHX_ const HV *stash); #define PERL_ARGS_ASSERT_DUMP_PACKSUBS \ - assert(stash) + ASSUME(stash) PERL_CALLCONV void Perl_dump_packsubs_perl(pTHX_ const HV *stash, bool justperl) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DUMP_PACKSUBS_PERL \ - assert(stash) + ASSUME(stash) PERL_CALLCONV void Perl_dump_sub(pTHX_ const GV *gv); #define PERL_ARGS_ASSERT_DUMP_SUB \ - assert(gv) + ASSUME(gv) PERL_CALLCONV void Perl_dump_sub_perl(pTHX_ const GV *gv, bool justperl) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_DUMP_SUB_PERL \ - assert(gv) + ASSUME(gv) PERL_CALLCONV void Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char *pat, va_list *args); #define PERL_ARGS_ASSERT_DUMP_VINDENT \ - assert(file); assert(pat) + ASSUME(file); ASSUME(pat) #define PERL_ARGS_ASSERT_DUP_WARNINGS #define PERL_ARGS_ASSERT_EMULATE_COP_IO \ - assert(c); assert(sv) + ASSUME(c); ASSUME(sv) PERL_CALLCONV SV * Perl_eval_pv(pTHX_ const char *p, I32 croak_on_error); #define PERL_ARGS_ASSERT_EVAL_PV \ - assert(p) + ASSUME(p) PERL_CALLCONV SSize_t Perl_eval_sv(pTHX_ SV *sv, I32 flags); #define PERL_ARGS_ASSERT_EVAL_SV \ - assert(sv) + ASSUME(sv) #define PERL_ARGS_ASSERT_EXPECTED_SIZE @@ -1102,18 +1121,18 @@ PERL_CALLCONV void Perl_fatal_warner(pTHX_ U32 err, const char *pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_FATAL_WARNER \ - assert(pat) + ASSUME(pat) PERL_CALLCONV void Perl_fbm_compile(pTHX_ SV *sv, U32 flags); #define PERL_ARGS_ASSERT_FBM_COMPILE \ - assert(sv) + ASSUME(sv) PERL_CALLCONV char * Perl_fbm_instr(pTHX_ unsigned char *big, unsigned char *bigend, SV *littlestr, U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_FBM_INSTR \ - assert(big); assert(bigend); assert(littlestr) + ASSUME(big); ASSUME(bigend); ASSUME(littlestr) PERL_CALLCONV SV * Perl_filter_add(pTHX_ filter_t funcp, SV *datasv); @@ -1122,13 +1141,13 @@ Perl_filter_add(pTHX_ filter_t funcp, SV *datasv); PERL_CALLCONV void Perl_filter_del(pTHX_ filter_t funcp); #define PERL_ARGS_ASSERT_FILTER_DEL \ - assert(funcp) + ASSUME(funcp) PERL_CALLCONV I32 Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_FILTER_READ \ - assert(buf_sv) + ASSUME(buf_sv) PERL_CALLCONV CV * Perl_find_lexical_cv(pTHX_ PADOFFSET off) @@ -1154,7 +1173,7 @@ PERL_CALLCONV char * Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char * const * const search_ext, I32 flags) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_FIND_SCRIPT \ - assert(scriptname) + ASSUME(scriptname) /* PERL_CALLCONV I32 Perl_foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ @@ -1162,12 +1181,12 @@ Perl_foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s PERL_CALLCONV I32 Perl_foldEQ_utf8_flags(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2, U32 flags); #define PERL_ARGS_ASSERT_FOLDEQ_UTF8_FLAGS \ - assert(s1); assert(s2) + ASSUME(s1); ASSUME(s2) PERL_CALLCONV void Perl_forbid_outofblock_ops(pTHX_ OP *o, const char *blockname); #define PERL_ARGS_ASSERT_FORBID_OUTOFBLOCK_OPS \ - assert(o); assert(blockname) + ASSUME(o); ASSUME(blockname) PERL_CALLCONV void Perl_force_locale_unlock(pTHX) @@ -1177,13 +1196,13 @@ Perl_force_locale_unlock(pTHX) PERL_CALLCONV void Perl_force_out_malformed_utf8_message_(pTHX_ const U8 * const p, const U8 * const e, U32 flags, const bool die_here); #define PERL_ARGS_ASSERT_FORCE_OUT_MALFORMED_UTF8_MESSAGE_ \ - assert(p); assert(e) + ASSUME(p); ASSUME(e) PERL_CALLCONV char * Perl_form(pTHX_ const char *pat, ...) __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_FORM \ - assert(pat) + ASSUME(pat) PERL_CALLCONV void Perl_free_tied_hv_pool(pTHX) @@ -1195,27 +1214,27 @@ Perl_free_tmps(pTHX); #define PERL_ARGS_ASSERT_FREE_TMPS #define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME \ - assert(s); assert(e); assert(error_msg) + ASSUME(s); ASSUME(e); ASSUME(error_msg) PERL_CALLCONV AV * Perl_get_av(pTHX_ const char *name, I32 flags); #define PERL_ARGS_ASSERT_GET_AV \ - assert(name) + ASSUME(name) PERL_CALLCONV CV * Perl_get_cv(pTHX_ const char *name, I32 flags); #define PERL_ARGS_ASSERT_GET_CV \ - assert(name) + ASSUME(name) PERL_CALLCONV CV * Perl_get_cvn_flags(pTHX_ const char *name, STRLEN len, I32 flags); #define PERL_ARGS_ASSERT_GET_CVN_FLAGS \ - assert(name) + ASSUME(name) PERL_CALLCONV void Perl_get_db_sub(pTHX_ SV **svp, CV *cv); #define PERL_ARGS_ASSERT_GET_DB_SUB \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) #define PERL_ARGS_ASSERT_GET_DEPRECATED_PROPERTY_MSG @@ -1228,12 +1247,12 @@ PERL_CALLCONV void Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_GET_HASH_SEED \ - assert(seed_buffer) + ASSUME(seed_buffer) PERL_CALLCONV HV * Perl_get_hv(pTHX_ const char *name, I32 flags); #define PERL_ARGS_ASSERT_GET_HV \ - assert(name) + ASSUME(name) PERL_CALLCONV const char * Perl_get_no_modify(pTHX) @@ -1283,12 +1302,12 @@ Perl_get_re_arg(pTHX_ SV *sv); PERL_CALLCONV SV * Perl_get_sv(pTHX_ const char *name, I32 flags); #define PERL_ARGS_ASSERT_GET_SV \ - assert(name) + ASSUME(name) PERL_CALLCONV int Perl_getcwd_sv(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_GETCWD_SV \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_gp_free(pTHX_ GV *gv); @@ -1299,50 +1318,52 @@ Perl_gp_ref(pTHX_ GP *gp); #define PERL_ARGS_ASSERT_GP_REF PERL_CALLCONV bool -Perl_grok_atoUV(const char *pv, UV *valptr, const char **endptr); +Perl_grok_atoUV(const char *pv, UV *valptr, const char **endptr) + __attribute__nonnull__(1) + __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_GROK_ATOUV \ - assert(pv); assert(valptr) + PERL_ASSUME_NON_NULL(pv); PERL_ASSUME_NON_NULL(valptr) PERL_CALLCONV UV Perl_grok_bin(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result); #define PERL_ARGS_ASSERT_GROK_BIN \ - assert(start); assert(len_p); assert(flags) + ASSUME(start); ASSUME(len_p); ASSUME(flags) PERL_CALLCONV UV Perl_grok_bin_oct_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result, const unsigned shift, const U8 lookup_bit, const char prefix); #define PERL_ARGS_ASSERT_GROK_BIN_OCT_HEX \ - assert(start); assert(len_p); assert(flags) + ASSUME(start); ASSUME(len_p); ASSUME(flags) PERL_CALLCONV UV Perl_grok_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result); #define PERL_ARGS_ASSERT_GROK_HEX \ - assert(start); assert(len_p); assert(flags) + ASSUME(start); ASSUME(len_p); ASSUME(flags) PERL_CALLCONV int Perl_grok_infnan(pTHX_ const char **sp, const char *send); #define PERL_ARGS_ASSERT_GROK_INFNAN \ - assert(sp); assert(send) + ASSUME(sp); ASSUME(send) PERL_CALLCONV int Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep); #define PERL_ARGS_ASSERT_GROK_NUMBER \ - assert(pv) + ASSUME(pv) PERL_CALLCONV int Perl_grok_number_flags(pTHX_ const char *pv, STRLEN len, UV *valuep, U32 flags); #define PERL_ARGS_ASSERT_GROK_NUMBER_FLAGS \ - assert(pv) + ASSUME(pv) PERL_CALLCONV bool Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GROK_NUMERIC_RADIX \ - assert(sp); assert(send) + ASSUME(sp); ASSUME(send) PERL_CALLCONV UV Perl_grok_oct(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result); #define PERL_ARGS_ASSERT_GROK_OCT \ - assert(start); assert(len_p); assert(flags) + ASSUME(start); ASSUME(len_p); ASSUME(flags) /* PERL_CALLCONV GV * Perl_gv_AVadd(pTHX_ GV *gv); */ @@ -1361,30 +1382,30 @@ PERL_CALLCONV GV * Perl_gv_autoload_pv(pTHX_ HV *stash, const char *namepv, U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PV \ - assert(namepv) + ASSUME(namepv) PERL_CALLCONV GV * Perl_gv_autoload_pvn(pTHX_ HV *stash, const char *name, STRLEN len, U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PVN \ - assert(name) + ASSUME(name) PERL_CALLCONV GV * Perl_gv_autoload_sv(pTHX_ HV *stash, SV *namesv, U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_AUTOLOAD_SV \ - assert(namesv) + ASSUME(namesv) PERL_CALLCONV void Perl_gv_check(pTHX_ HV *stash); #define PERL_ARGS_ASSERT_GV_CHECK \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV SV * Perl_gv_const_sv(pTHX_ GV *gv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_CONST_SV \ - assert(gv) + ASSUME(gv) PERL_CALLCONV void Perl_gv_dump(pTHX_ GV *gv); @@ -1396,17 +1417,17 @@ Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); */ PERL_CALLCONV void Perl_gv_efullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain); #define PERL_ARGS_ASSERT_GV_EFULLNAME4 \ - assert(sv); assert(gv) + ASSUME(sv); ASSUME(gv) PERL_CALLCONV GV * Perl_gv_fetchfile(pTHX_ const char *name); #define PERL_ARGS_ASSERT_GV_FETCHFILE \ - assert(name) + ASSUME(name) PERL_CALLCONV GV * Perl_gv_fetchfile_flags(pTHX_ const char * const name, const STRLEN len, const U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS \ - assert(name) + ASSUME(name) /* PERL_CALLCONV GV * Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level); */ @@ -1417,32 +1438,32 @@ Perl_gv_fetchmeth_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 le PERL_CALLCONV GV * Perl_gv_fetchmeth_pv(pTHX_ HV *stash, const char *name, I32 level, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV \ - assert(name) + ASSUME(name) PERL_CALLCONV GV * Perl_gv_fetchmeth_pv_autoload(pTHX_ HV *stash, const char *name, I32 level, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV_AUTOLOAD \ - assert(name) + ASSUME(name) PERL_CALLCONV GV * Perl_gv_fetchmeth_pvn(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN \ - assert(name) + ASSUME(name) PERL_CALLCONV GV * Perl_gv_fetchmeth_pvn_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN_AUTOLOAD \ - assert(name) + ASSUME(name) PERL_CALLCONV GV * Perl_gv_fetchmeth_sv(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV \ - assert(namesv) + ASSUME(namesv) PERL_CALLCONV GV * Perl_gv_fetchmeth_sv_autoload(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV_AUTOLOAD \ - assert(namesv) + ASSUME(namesv) /* PERL_CALLCONV GV * Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name); */ @@ -1450,37 +1471,37 @@ Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name); */ PERL_CALLCONV GV * Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD \ - assert(stash); assert(name) + ASSUME(stash); ASSUME(name) PERL_CALLCONV GV * Perl_gv_fetchmethod_pv_flags(pTHX_ HV *stash, const char *name, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PV_FLAGS \ - assert(stash); assert(name) + ASSUME(stash); ASSUME(name) PERL_CALLCONV GV * Perl_gv_fetchmethod_pvn_flags(pTHX_ HV *stash, const char *name, const STRLEN len, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PVN_FLAGS \ - assert(stash); assert(name) + ASSUME(stash); ASSUME(name) PERL_CALLCONV GV * Perl_gv_fetchmethod_sv_flags(pTHX_ HV *stash, SV *namesv, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_SV_FLAGS \ - assert(stash); assert(namesv) + ASSUME(stash); ASSUME(namesv) PERL_CALLCONV GV * Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 flags, const svtype sv_type); #define PERL_ARGS_ASSERT_GV_FETCHPV \ - assert(nambeg) + ASSUME(nambeg) PERL_CALLCONV GV * Perl_gv_fetchpvn_flags(pTHX_ const char *name, STRLEN len, I32 flags, const svtype sv_type); #define PERL_ARGS_ASSERT_GV_FETCHPVN_FLAGS \ - assert(name) + ASSUME(name) PERL_CALLCONV GV * Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type); #define PERL_ARGS_ASSERT_GV_FETCHSV \ - assert(name) + ASSUME(name) /* PERL_CALLCONV void Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); */ @@ -1488,13 +1509,13 @@ Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); */ PERL_CALLCONV void Perl_gv_fullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain); #define PERL_ARGS_ASSERT_GV_FULLNAME4 \ - assert(sv); assert(gv) + ASSUME(sv); ASSUME(gv) PERL_CALLCONV CV * Perl_gv_handler(pTHX_ HV *stash, I32 id) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_HANDLER \ - assert(!stash || SvTYPE(stash) == SVt_PVHV) + ASSUME(!stash || SvTYPE(stash) == SVt_PVHV) /* PERL_CALLCONV void Perl_gv_init(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, int multi); */ @@ -1502,81 +1523,81 @@ Perl_gv_init(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, int multi); PERL_CALLCONV void Perl_gv_init_pv(pTHX_ GV *gv, HV *stash, const char *name, U32 flags); #define PERL_ARGS_ASSERT_GV_INIT_PV \ - assert(gv); assert(!stash || SvTYPE(stash) == SVt_PVHV); assert(name) + ASSUME(gv); ASSUME(!stash || SvTYPE(stash) == SVt_PVHV); ASSUME(name) PERL_CALLCONV void Perl_gv_init_pvn(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, U32 flags); #define PERL_ARGS_ASSERT_GV_INIT_PVN \ - assert(gv); assert(!stash || SvTYPE(stash) == SVt_PVHV); assert(name) + ASSUME(gv); ASSUME(!stash || SvTYPE(stash) == SVt_PVHV); ASSUME(name) PERL_CALLCONV void Perl_gv_init_sv(pTHX_ GV *gv, HV *stash, SV *namesv, U32 flags); #define PERL_ARGS_ASSERT_GV_INIT_SV \ - assert(gv); assert(!stash || SvTYPE(stash) == SVt_PVHV); assert(namesv) + ASSUME(gv); ASSUME(!stash || SvTYPE(stash) == SVt_PVHV); ASSUME(namesv) PERL_CALLCONV void Perl_gv_name_set(pTHX_ GV *gv, const char *name, U32 len, U32 flags); #define PERL_ARGS_ASSERT_GV_NAME_SET \ - assert(gv); assert(name) + ASSUME(gv); ASSUME(name) PERL_CALLCONV GV * Perl_gv_override(pTHX_ const char * const name, const STRLEN len); #define PERL_ARGS_ASSERT_GV_OVERRIDE \ - assert(name) + ASSUME(name) PERL_CALLCONV void Perl_gv_setref(pTHX_ SV * const dsv, SV * const ssv) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_GV_SETREF \ - assert(dsv); assert(ssv) + ASSUME(dsv); ASSUME(ssv) PERL_CALLCONV HV * Perl_gv_stashpv(pTHX_ const char *name, I32 flags); #define PERL_ARGS_ASSERT_GV_STASHPV \ - assert(name) + ASSUME(name) PERL_CALLCONV HV * Perl_gv_stashpvn(pTHX_ const char *name, U32 namelen, I32 flags); #define PERL_ARGS_ASSERT_GV_STASHPVN \ - assert(name) + ASSUME(name) PERL_CALLCONV HV * Perl_gv_stashsv(pTHX_ SV *sv, I32 flags); #define PERL_ARGS_ASSERT_GV_STASHSV \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_gv_try_downgrade(pTHX_ GV *gv); #define PERL_ARGS_ASSERT_GV_TRY_DOWNGRADE \ - assert(gv) + ASSUME(gv) PERL_CALLCONV struct xpvhv_aux * Perl_hv_auxalloc(pTHX_ HV *hv) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_HV_AUXALLOC \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV AV ** Perl_hv_backreferences_p(pTHX_ HV *hv) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_HV_BACKREFERENCES_P \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV SV * Perl_hv_bucket_ratio(pTHX_ HV *hv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_BUCKET_RATIO \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_clear(pTHX_ HV *hv); #define PERL_ARGS_ASSERT_HV_CLEAR \ - assert(!hv || SvTYPE(hv) == SVt_PVHV) + ASSUME(!hv || SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_clear_placeholders(pTHX_ HV *hv); #define PERL_ARGS_ASSERT_HV_CLEAR_PLACEHOLDERS \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void * Perl_hv_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int flags, int action, SV *val, U32 hash); @@ -1585,18 +1606,18 @@ Perl_hv_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int flags, PERL_CALLCONV void * Perl_hv_common_key_len(pTHX_ HV *hv, const char *key, I32 klen_i32, const int action, SV *val, const U32 hash); #define PERL_ARGS_ASSERT_HV_COMMON_KEY_LEN \ - assert(!hv || SvTYPE(hv) == SVt_PVHV); assert(key) + ASSUME(!hv || SvTYPE(hv) == SVt_PVHV); ASSUME(key) PERL_CALLCONV HV * Perl_hv_copy_hints_hv(pTHX_ HV * const ohv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_COPY_HINTS_HV \ - assert(!ohv || SvTYPE(ohv) == SVt_PVHV) + ASSUME(!ohv || SvTYPE(ohv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_delayfree_ent(pTHX_ HV *notused, HE *entry); #define PERL_ARGS_ASSERT_HV_DELAYFREE_ENT \ - assert(!notused || SvTYPE(notused) == SVt_PVHV) + ASSUME(!notused || SvTYPE(notused) == SVt_PVHV) /* PERL_CALLCONV SV * Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags); */ @@ -1607,30 +1628,30 @@ Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash); */ PERL_CALLCONV void Perl_hv_dump(pTHX_ HV *hv); #define PERL_ARGS_ASSERT_HV_DUMP \ - assert(!hv || SvTYPE(hv) == SVt_PVHV) + ASSUME(!hv || SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV HE ** Perl_hv_eiter_p(pTHX_ HV *hv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_EITER_P \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter); #define PERL_ARGS_ASSERT_HV_EITER_SET \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_ename_add(pTHX_ HV *hv, const char *name, U32 len, U32 flags) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_HV_ENAME_ADD \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(name) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV); ASSUME(name) PERL_CALLCONV void Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len, U32 flags) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_HV_ENAME_DELETE \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(name) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV); ASSUME(name) /* PERL_CALLCONV bool Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen) @@ -1649,29 +1670,29 @@ Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash); */ PERL_CALLCONV STRLEN Perl_hv_fill(pTHX_ HV * const hv); #define PERL_ARGS_ASSERT_HV_FILL \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_free_ent(pTHX_ HV *notused, HE *entry); #define PERL_ARGS_ASSERT_HV_FREE_ENT \ - assert(!notused || SvTYPE(notused) == SVt_PVHV) + ASSUME(!notused || SvTYPE(notused) == SVt_PVHV) PERL_CALLCONV I32 Perl_hv_iterinit(pTHX_ HV *hv); #define PERL_ARGS_ASSERT_HV_ITERINIT \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV char * Perl_hv_iterkey(pTHX_ HE *entry, I32 *retlen) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERKEY \ - assert(entry); assert(retlen) + ASSUME(entry); ASSUME(retlen) PERL_CALLCONV SV * Perl_hv_iterkeysv(pTHX_ HE *entry) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERKEYSV \ - assert(entry) + ASSUME(entry) /* PERL_CALLCONV HE * Perl_hv_iternext(pTHX_ HV *hv) @@ -1681,24 +1702,24 @@ PERL_CALLCONV HE * Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERNEXT_FLAGS \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV SV * Perl_hv_iternextsv(pTHX_ HV *hv, char **key, I32 *retlen) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERNEXTSV \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(key); assert(retlen) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV); ASSUME(key); ASSUME(retlen) PERL_CALLCONV SV * Perl_hv_iterval(pTHX_ HV *hv, HE *entry) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERVAL \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(entry) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV); ASSUME(entry) PERL_CALLCONV void Perl_hv_ksplit(pTHX_ HV *hv, IV newmax); #define PERL_ARGS_ASSERT_HV_KSPLIT \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) /* PERL_CALLCONV void Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how); */ @@ -1706,52 +1727,52 @@ Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how); */ PERL_CALLCONV void Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags); #define PERL_ARGS_ASSERT_HV_NAME_SET \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV I32 Perl_hv_placeholders_get(pTHX_ const HV *hv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_GET \ - assert(hv) + ASSUME(hv) PERL_CALLCONV SSize_t * Perl_hv_placeholders_p(pTHX_ HV *hv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_P \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph); #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_SET \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_pushkv(pTHX_ HV *hv, U32 flags) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_HV_PUSHKV \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_rand_set(pTHX_ HV *hv, U32 new_xhv_rand); #define PERL_ARGS_ASSERT_HV_RAND_SET \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV I32 * Perl_hv_riter_p(pTHX_ HV *hv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_RITER_P \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_riter_set(pTHX_ HV *hv, I32 riter); #define PERL_ARGS_ASSERT_HV_RITER_SET \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV SV * Perl_hv_scalar(pTHX_ HV *hv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_SCALAR \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) /* PERL_CALLCONV SV ** Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash); */ @@ -1771,7 +1792,7 @@ Perl_hv_undef(pTHX_ HV *hv); */ PERL_CALLCONV void Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags); #define PERL_ARGS_ASSERT_HV_UNDEF_FLAGS \ - assert(!hv || SvTYPE(hv) == SVt_PVHV) + ASSUME(!hv || SvTYPE(hv) == SVt_PVHV) /* PERL_CALLCONV I32 Perl_ibcmp(pTHX_ const char *a, const char *b, I32 len) @@ -1789,13 +1810,13 @@ Perl_ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2 PERL_CALLCONV STRLEN Perl_infix_plugin_standard(pTHX_ char *operator_ptr, STRLEN operator_len, struct Perl_custom_infix **def); #define PERL_ARGS_ASSERT_INFIX_PLUGIN_STANDARD \ - assert(operator_ptr); assert(def) + ASSUME(operator_ptr); ASSUME(def) PERL_CALLCONV void Perl_init_argv_symbols(pTHX_ int argc, char **argv) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS \ - assert(argv) + ASSUME(argv) PERL_CALLCONV void Perl_init_constants(pTHX) @@ -1819,8 +1840,8 @@ Perl_init_i18nl10n(pTHX_ int printwarn); PERL_CALLCONV void Perl_init_named_cv(pTHX_ CV *cv, OP *nameop); #define PERL_ARGS_ASSERT_INIT_NAMED_CV \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ - assert(nameop) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ + ASSUME(nameop) PERL_CALLCONV void Perl_init_stacks(pTHX); @@ -1829,7 +1850,7 @@ Perl_init_stacks(pTHX); PERL_CALLCONV void Perl_init_tm(pTHX_ struct tm *ptm); #define PERL_ARGS_ASSERT_INIT_TM \ - assert(ptm) + ASSUME(ptm) PERL_CALLCONV void Perl_init_uniprops(pTHX) @@ -1855,13 +1876,13 @@ PERL_CALLCONV void Perl_invmap_dump(pTHX_ SV *invlist, UV *map) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_INVMAP_DUMP \ - assert(invlist); assert(map) + ASSUME(invlist); ASSUME(map) PERL_CALLCONV bool Perl_io_close(pTHX_ IO *io, GV *gv, bool is_explicit, bool warn_on_fail) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_IO_CLOSE \ - assert(io) + ASSUME(io) /* PERL_CALLCONV bool Perl_is_c9strict_utf8_string(const U8 *s, STRLEN len) @@ -1888,20 +1909,24 @@ Perl_is_strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ PERL_CALLCONV Size_t Perl_is_utf8_FF_helper_(const U8 * const s0, const U8 * const e, const bool require_partial) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__ __attribute__pure__; #define PERL_ARGS_ASSERT_IS_UTF8_FF_HELPER_ \ - assert(s0); assert(e) + PERL_ASSUME_NON_NULL(s0); PERL_ASSUME_NON_NULL(e) /* PERL_CALLCONV STRLEN Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end); */ PERL_CALLCONV STRLEN Perl_is_utf8_char_helper_(const U8 * const s, const U8 *e, const U32 flags) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__ __attribute__pure__; #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_HELPER_ \ - assert(s); assert(e) + PERL_ASSUME_NON_NULL(s); PERL_ASSUME_NON_NULL(e) /* PERL_CALLCONV bool Perl_is_utf8_fixed_width_buf_flags(const U8 * const s, STRLEN len, const U32 flags); */ @@ -1934,13 +1959,13 @@ PERL_CALLCONV bool Perl_isinfnansv(pTHX_ SV *sv) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_ISINFNANSV \ - assert(sv) + ASSUME(sv) PERL_CALLCONV OP * Perl_jmaybe(pTHX_ OP *o) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_JMAYBE \ - assert(o) + ASSUME(o) PERL_CALLCONV I32 Perl_keyword(pTHX_ const char *name, I32 len, bool all_keywords) @@ -1948,17 +1973,17 @@ Perl_keyword(pTHX_ const char *name, I32 len, bool all_keywords) __attribute__pure__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_KEYWORD \ - assert(name) + ASSUME(name) PERL_CALLCONV int Perl_keyword_plugin_standard(pTHX_ char *keyword_ptr, STRLEN keyword_len, OP **op_ptr); #define PERL_ARGS_ASSERT_KEYWORD_PLUGIN_STANDARD \ - assert(keyword_ptr); assert(op_ptr) + ASSUME(keyword_ptr); ASSUME(op_ptr) PERL_CALLCONV void Perl_leave_adjust_stacks(pTHX_ SV **from_sp, SV **to_sp, U8 gimme, int filter); #define PERL_ARGS_ASSERT_LEAVE_ADJUST_STACKS \ - assert(from_sp); assert(to_sp) + ASSUME(from_sp); ASSUME(to_sp) PERL_CALLCONV void Perl_leave_scope(pTHX_ I32 base); @@ -1971,7 +1996,7 @@ Perl_lex_bufutf8(pTHX); PERL_CALLCONV void Perl_lex_discard_to(pTHX_ char *ptr); #define PERL_ARGS_ASSERT_LEX_DISCARD_TO \ - assert(ptr) + ASSUME(ptr) PERL_CALLCONV char * Perl_lex_grow_linestr(pTHX_ STRLEN len); @@ -1992,7 +2017,7 @@ Perl_lex_read_space(pTHX_ U32 flags); PERL_CALLCONV void Perl_lex_read_to(pTHX_ char *ptr); #define PERL_ARGS_ASSERT_LEX_READ_TO \ - assert(ptr) + ASSUME(ptr) PERL_CALLCONV I32 Perl_lex_read_unichar(pTHX_ U32 flags); @@ -2005,22 +2030,22 @@ Perl_lex_start(pTHX_ SV *line, PerlIO *rsfp, U32 flags); PERL_CALLCONV void Perl_lex_stuff_pv(pTHX_ const char *pv, U32 flags); #define PERL_ARGS_ASSERT_LEX_STUFF_PV \ - assert(pv) + ASSUME(pv) PERL_CALLCONV void Perl_lex_stuff_pvn(pTHX_ const char *pv, STRLEN len, U32 flags); #define PERL_ARGS_ASSERT_LEX_STUFF_PVN \ - assert(pv) + ASSUME(pv) PERL_CALLCONV void Perl_lex_stuff_sv(pTHX_ SV *sv, U32 flags); #define PERL_ARGS_ASSERT_LEX_STUFF_SV \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_lex_unstuff(pTHX_ char *ptr); #define PERL_ARGS_ASSERT_LEX_UNSTUFF \ - assert(ptr) + ASSUME(ptr) PERL_CALLCONV OP * Perl_list(pTHX_ OP *o) @@ -2028,96 +2053,98 @@ Perl_list(pTHX_ OP *o) #define PERL_ARGS_ASSERT_LIST #define PERL_ARGS_ASSERT_LOAD_CHARNAMES \ - assert(char_name); assert(context); assert(error_msg) + ASSUME(char_name); ASSUME(context); ASSUME(error_msg) PERL_CALLCONV void Perl_load_module(pTHX_ U32 flags, SV *name, SV *ver, ...); #define PERL_ARGS_ASSERT_LOAD_MODULE \ - assert(name) + ASSUME(name) PERL_CALLCONV_NO_RET void Perl_locale_panic(const char *msg, const line_t immediate_caller_line, const char * const higher_caller_file, const line_t higher_caller_line) + __attribute__nonnull__(1) + __attribute__nonnull__(3) __attribute__noreturn__; #define PERL_ARGS_ASSERT_LOCALE_PANIC \ - assert(msg); assert(higher_caller_file) + PERL_ASSUME_NON_NULL(msg); PERL_ASSUME_NON_NULL(higher_caller_file) PERL_CALLCONV OP * Perl_localize(pTHX_ OP *o, I32 lex) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_LOCALIZE \ - assert(o) + ASSUME(o) PERL_CALLCONV I32 Perl_looks_like_number(pTHX_ SV * const sv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_LOOKS_LIKE_NUMBER \ - assert(sv) + ASSUME(sv) PERL_CALLCONV int Perl_magic_clear_all_env(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_cleararylen_p(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARARYLEN_P \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_clearenv(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARENV \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_clearhint(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARHINT \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_clearhints(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARHINTS \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_clearhook(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARHOOK \ - assert(mg) + ASSUME(mg) PERL_CALLCONV int Perl_magic_clearhookall(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARHOOKALL \ - assert(mg) + ASSUME(mg) PERL_CALLCONV int Perl_magic_clearisa(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARISA \ - assert(mg) + ASSUME(mg) PERL_CALLCONV int Perl_magic_clearpack(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARPACK \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_clearsig(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_CLEARSIG \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_copycallchecker(pTHX_ SV *sv, MAGIC *mg, SV *nsv, const char *name, I32 namlen) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER \ - assert(sv); assert(mg); assert(nsv) + ASSUME(sv); ASSUME(mg); ASSUME(nsv) PERL_CALLCONV void Perl_magic_dump(pTHX_ const MAGIC *mg); @@ -2127,307 +2154,307 @@ PERL_CALLCONV int Perl_magic_existspack(pTHX_ SV *sv, const MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_EXISTSPACK \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_freearylen_p(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_freedestruct(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_FREEDESTRUCT \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_freemglob(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_FREEMGLOB \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_freeovrld(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_FREEOVRLD \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_freeutf8(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_FREEUTF8 \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_get(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GET \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_getarylen(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETARYLEN \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_getdebugvar(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETDEBUGVAR \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETDEFELEM \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_getnkeys(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETNKEYS \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_getpack(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETPACK \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_getpos(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETPOS \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_getsig(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETSIG \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_getsubstr(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETSUBSTR \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_gettaint(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETTAINT \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_getuvar(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETUVAR \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_getvec(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_GETVEC \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV SV * Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, U32 argc, ...) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_METHCALL \ - assert(sv); assert(mg); assert(meth) + ASSUME(sv); ASSUME(mg); ASSUME(meth) PERL_CALLCONV int Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_NEXTPACK \ - assert(sv); assert(mg); assert(key) + ASSUME(sv); ASSUME(mg); ASSUME(key) PERL_CALLCONV U32 Perl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_REGDATA_CNT \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV SV * Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SCALARPACK \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(mg) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV); ASSUME(mg) PERL_CALLCONV int Perl_magic_set(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SET \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_set_all_env(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SET_ALL_ENV \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setarylen(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETARYLEN \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setdbline(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETDBLINE \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setdebugvar(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETDEBUGVAR \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setdefelem(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETDEFELEM \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setenv(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETENV \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_sethint(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETHINT \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_sethook(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETHOOK \ - assert(mg) + ASSUME(mg) PERL_CALLCONV int Perl_magic_sethookall(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETHOOKALL \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setisa(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETISA \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setlvref(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETLVREF \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setmglob(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETMGLOB \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setnkeys(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETNKEYS \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setnonelem(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETNONELEM \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setpack(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETPACK \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setpos(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETPOS \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setregexp(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETREGEXP \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setsig(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETSIG \ - assert(mg) + ASSUME(mg) PERL_CALLCONV int Perl_magic_setsigall(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETSIGALL \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setsubstr(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETSUBSTR \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_settaint(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETTAINT \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setutf8(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETUTF8 \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setuvar(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETUVAR \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setvec(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SETVEC \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV U32 Perl_magic_sizepack(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_SIZEPACK \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_wipepack(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MAGIC_WIPEPACK \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV Malloc_t Perl_malloc(MEM_SIZE nbytes) @@ -2445,12 +2472,12 @@ PERL_CALLCONV SV * Perl_mess(pTHX_ const char *pat, ...) __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_MESS \ - assert(pat) + ASSUME(pat) PERL_CALLCONV SV * Perl_mess_sv(pTHX_ SV *basemsg, bool consume); #define PERL_ARGS_ASSERT_MESS_SV \ - assert(basemsg) + ASSUME(basemsg) PERL_CALLCONV Free_t Perl_mfree(Malloc_t where); @@ -2459,12 +2486,12 @@ Perl_mfree(Malloc_t where); PERL_CALLCONV int Perl_mg_clear(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_MG_CLEAR \ - assert(sv) + ASSUME(sv) PERL_CALLCONV int Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen); #define PERL_ARGS_ASSERT_MG_COPY \ - assert(sv); assert(nsv) + ASSUME(sv); ASSUME(nsv) PERL_CALLCONV MAGIC * Perl_mg_find(const SV *sv, int type) @@ -2472,7 +2499,7 @@ Perl_mg_find(const SV *sv, int type) #define PERL_ARGS_ASSERT_MG_FIND #define PERL_ARGS_ASSERT_MG_FIND_MGLOB \ - assert(sv) + ASSUME(sv) PERL_CALLCONV MAGIC * Perl_mg_findext(const SV *sv, int type, const MGVTBL *vtbl) @@ -2482,48 +2509,50 @@ Perl_mg_findext(const SV *sv, int type, const MGVTBL *vtbl) PERL_CALLCONV int Perl_mg_free(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_MG_FREE \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_mg_free_type(pTHX_ SV *sv, int how); #define PERL_ARGS_ASSERT_MG_FREE_TYPE \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_mg_freeext(pTHX_ SV *sv, int how, const MGVTBL *vtbl); #define PERL_ARGS_ASSERT_MG_FREEEXT \ - assert(sv) + ASSUME(sv) PERL_CALLCONV int Perl_mg_get(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_MG_GET \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_mg_localize(pTHX_ SV *sv, SV *nsv, bool setmagic) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MG_LOCALIZE \ - assert(sv); assert(nsv) + ASSUME(sv); ASSUME(nsv) PERL_CALLCONV void -Perl_mg_magical(SV *sv); +Perl_mg_magical(SV *sv) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_MG_MAGICAL \ - assert(sv) + PERL_ASSUME_NON_NULL(sv) PERL_CALLCONV int Perl_mg_set(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_MG_SET \ - assert(sv) + ASSUME(sv) PERL_CALLCONV I32 Perl_mg_size(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_MG_SIZE \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void -Perl_mini_mktime(struct tm *ptm); +Perl_mini_mktime(struct tm *ptm) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_MINI_MKTIME \ - assert(ptm) + PERL_ASSUME_NON_NULL(ptm) PERL_CALLCONV int Perl_mode_from_discipline(pTHX_ const char *s, STRLEN len) @@ -2537,12 +2566,12 @@ Perl_more_bodies(pTHX_ const svtype sv_type); PERL_CALLCONV const char * Perl_moreswitches(pTHX_ const char *s); #define PERL_ARGS_ASSERT_MORESWITCHES \ - assert(s) + ASSUME(s) PERL_CALLCONV void Perl_mortal_destructor_sv(pTHX_ SV *coderef, SV *args); #define PERL_ARGS_ASSERT_MORTAL_DESTRUCTOR_SV \ - assert(coderef) + ASSUME(coderef) PERL_CALLCONV void Perl_mortal_svfunc_x(pTHX_ SVFUNC_t f, SV *p); @@ -2551,82 +2580,82 @@ Perl_mortal_svfunc_x(pTHX_ SVFUNC_t f, SV *p); PERL_CALLCONV const struct mro_alg * Perl_mro_get_from_name(pTHX_ SV *name); #define PERL_ARGS_ASSERT_MRO_GET_FROM_NAME \ - assert(name) + ASSUME(name) PERL_CALLCONV AV * Perl_mro_get_linear_isa(pTHX_ HV *stash); #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV SV * Perl_mro_get_private_data(pTHX_ struct mro_meta * const smeta, const struct mro_alg * const which); #define PERL_ARGS_ASSERT_MRO_GET_PRIVATE_DATA \ - assert(smeta); assert(which) + ASSUME(smeta); ASSUME(which) PERL_CALLCONV void Perl_mro_isa_changed_in(pTHX_ HV *stash) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV struct mro_meta * Perl_mro_meta_init(pTHX_ HV *stash); #define PERL_ARGS_ASSERT_MRO_META_INIT \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void Perl_mro_method_changed_in(pTHX_ HV *stash); #define PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash, const GV * const gv, U32 flags); #define PERL_ARGS_ASSERT_MRO_PACKAGE_MOVED \ - assert(!stash || SvTYPE(stash) == SVt_PVHV); \ - assert(!oldstash || SvTYPE(oldstash) == SVt_PVHV); assert(gv) + ASSUME(!stash || SvTYPE(stash) == SVt_PVHV); \ + ASSUME(!oldstash || SvTYPE(oldstash) == SVt_PVHV); ASSUME(gv) PERL_CALLCONV void Perl_mro_register(pTHX_ const struct mro_alg *mro); #define PERL_ARGS_ASSERT_MRO_REGISTER \ - assert(mro) + ASSUME(mro) PERL_CALLCONV void Perl_mro_set_mro(pTHX_ struct mro_meta * const meta, SV * const name); #define PERL_ARGS_ASSERT_MRO_SET_MRO \ - assert(meta); assert(name) + ASSUME(meta); ASSUME(name) PERL_CALLCONV SV * Perl_mro_set_private_data(pTHX_ struct mro_meta * const smeta, const struct mro_alg * const which, SV * const data); #define PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA \ - assert(smeta); assert(which); assert(data) + ASSUME(smeta); ASSUME(which); ASSUME(data) #define PERL_ARGS_ASSERT_MULTICONCAT_STRINGIFY \ - assert(o) + ASSUME(o) #define PERL_ARGS_ASSERT_MULTIDEREF_STRINGIFY \ - assert(o); \ - assert(!cv || SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(o); \ + ASSUME(!cv || SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV NV Perl_my_atof(pTHX_ const char *s); #define PERL_ARGS_ASSERT_MY_ATOF \ - assert(s) + ASSUME(s) PERL_CALLCONV char * Perl_my_atof2(pTHX_ const char *orig, NV *value); #define PERL_ARGS_ASSERT_MY_ATOF2 \ - assert(orig); assert(value) + ASSUME(orig); ASSUME(value) PERL_CALLCONV char * Perl_my_atof3(pTHX_ const char *orig, NV *value, const STRLEN len); #define PERL_ARGS_ASSERT_MY_ATOF3 \ - assert(orig); assert(value) + ASSUME(orig); ASSUME(value) PERL_CALLCONV OP * Perl_my_attrs(pTHX_ OP *o, OP *attrs) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MY_ATTRS \ - assert(o) + ASSUME(o) PERL_CALLCONV void Perl_my_clearenv(pTHX); @@ -2663,22 +2692,24 @@ Perl_my_lstat_flags(pTHX_ const U32 flags); PERL_CALLCONV int Perl_my_mkostemp_cloexec(char *templte, int flags) + __attribute__nonnull__(1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MY_MKOSTEMP_CLOEXEC \ - assert(templte) + PERL_ASSUME_NON_NULL(templte) PERL_CALLCONV int Perl_my_mkstemp_cloexec(char *templte) + __attribute__nonnull__(1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MY_MKSTEMP_CLOEXEC \ - assert(templte) + PERL_ASSUME_NON_NULL(templte) PERL_CALLCONV PerlIO * Perl_my_popen_list(pTHX_ const char *mode, int n, SV **args); #define PERL_ARGS_ASSERT_MY_POPEN_LIST \ - assert(mode); assert(args) + ASSUME(mode); ASSUME(args) PERL_CALLCONV void Perl_my_setenv(pTHX_ const char *nam, const char *val); @@ -2686,9 +2717,11 @@ Perl_my_setenv(pTHX_ const char *nam, const char *val); PERL_CALLCONV int Perl_my_snprintf(char *buffer, const Size_t len, const char *format, ...) + __attribute__nonnull__(1) + __attribute__nonnull__(3) __attribute__format__(__printf__,3,4); #define PERL_ARGS_ASSERT_MY_SNPRINTF \ - assert(buffer); assert(format) + PERL_ASSUME_NON_NULL(buffer); PERL_ASSUME_NON_NULL(format) PERL_CALLCONV int Perl_my_socketpair(int family, int type, int protocol, int fd[2]); @@ -2705,19 +2738,20 @@ PERL_CALLCONV const char * Perl_my_strerror(pTHX_ const int errnum, utf8ness_t *utf8ness) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_MY_STRERROR \ - assert(utf8ness) + ASSUME(utf8ness) PERL_CALLCONV char * Perl_my_strftime(pTHX_ const char *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst) __attribute__format__(__strftime__,pTHX_1,0); #define PERL_ARGS_ASSERT_MY_STRFTIME \ - assert(fmt) + ASSUME(fmt) PERL_CALLCONV NV Perl_my_strtod(const char * const s, char **e) + __attribute__nonnull__(1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_MY_STRTOD \ - assert(s) + PERL_ASSUME_NON_NULL(s) PERL_CALLCONV void Perl_my_unexec(pTHX) @@ -2725,9 +2759,11 @@ Perl_my_unexec(pTHX) #define PERL_ARGS_ASSERT_MY_UNEXEC PERL_CALLCONV int -Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap); +Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap) + __attribute__nonnull__(1) + __attribute__nonnull__(3); #define PERL_ARGS_ASSERT_MY_VSNPRINTF \ - assert(buffer); assert(format) + PERL_ASSUME_NON_NULL(buffer); PERL_ASSUME_NON_NULL(format) PERL_CALLCONV OP * Perl_newANONATTRSUB(pTHX_ I32 floor, OP *proto, OP *attrs, OP *block); @@ -2751,7 +2787,7 @@ PERL_CALLCONV OP * Perl_newARGDEFELEMOP(pTHX_ I32 flags, OP *expr, I32 argindex) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWARGDEFELEMOP \ - assert(expr) + ASSUME(expr) PERL_CALLCONV OP * Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right) @@ -2773,7 +2809,7 @@ PERL_CALLCONV OP * Perl_newAVREF(pTHX_ OP *o) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWAVREF \ - assert(o) + ASSUME(o) /* PERL_CALLCONV AV * Perl_newAV_alloc_x(pTHX_ SSize_t size) @@ -2791,13 +2827,13 @@ PERL_CALLCONV AV * Perl_newAVav(pTHX_ AV *oav) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWAVAV \ - assert(!oav || SvTYPE(oav) == SVt_PVAV) + ASSUME(!oav || SvTYPE(oav) == SVt_PVAV) PERL_CALLCONV AV * Perl_newAVhv(pTHX_ HV *ohv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWAVHV \ - assert(!ohv || SvTYPE(ohv) == SVt_PVHV) + ASSUME(!ohv || SvTYPE(ohv) == SVt_PVHV) PERL_CALLCONV OP * Perl_newBINOP(pTHX_ I32 type, I32 flags, OP *first, OP *last) @@ -2808,17 +2844,17 @@ PERL_CALLCONV OP * Perl_newCONDOP(pTHX_ I32 flags, OP *first, OP *trueop, OP *falseop) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWCONDOP \ - assert(first) + ASSUME(first) PERL_CALLCONV CV * Perl_newCONSTSUB(pTHX_ HV *stash, const char *name, SV *sv); #define PERL_ARGS_ASSERT_NEWCONSTSUB \ - assert(!stash || SvTYPE(stash) == SVt_PVHV) + ASSUME(!stash || SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV CV * Perl_newCONSTSUB_flags(pTHX_ HV *stash, const char *name, STRLEN len, U32 flags, SV *sv); #define PERL_ARGS_ASSERT_NEWCONSTSUB_FLAGS \ - assert(!stash || SvTYPE(stash) == SVt_PVHV) + ASSUME(!stash || SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV OP * Perl_newCVREF(pTHX_ I32 flags, OP *o) @@ -2829,7 +2865,7 @@ PERL_CALLCONV OP * Perl_newDEFEROP(pTHX_ I32 flags, OP *block) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWDEFEROP \ - assert(block) + ASSUME(block) PERL_CALLCONV OP * Perl_newDEFSVOP(pTHX) @@ -2844,24 +2880,24 @@ PERL_CALLCONV OP * Perl_newFOROP(pTHX_ I32 flags, OP *sv, OP *expr, OP *block, OP *cont) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWFOROP \ - assert(expr) + ASSUME(expr) PERL_CALLCONV OP * Perl_newGIVENOP(pTHX_ OP *cond, OP *block, PADOFFSET defsv_off) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWGIVENOP \ - assert(cond); assert(block) + ASSUME(cond); ASSUME(block) PERL_CALLCONV GP * Perl_newGP(pTHX_ GV * const gv); #define PERL_ARGS_ASSERT_NEWGP \ - assert(gv) + ASSUME(gv) PERL_CALLCONV OP * Perl_newGVOP(pTHX_ I32 type, I32 flags, GV *gv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWGVOP \ - assert(gv) + ASSUME(gv) PERL_CALLCONV OP * Perl_newGVREF(pTHX_ I32 type, OP *o) @@ -2875,7 +2911,7 @@ PERL_CALLCONV GV * Perl_newGVgen_flags(pTHX_ const char *pack, U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWGVGEN_FLAGS \ - assert(pack) + ASSUME(pack) /* PERL_CALLCONV HV * Perl_newHV(pTHX) @@ -2885,13 +2921,13 @@ PERL_CALLCONV OP * Perl_newHVREF(pTHX_ OP *o) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWHVREF \ - assert(o) + ASSUME(o) PERL_CALLCONV HV * Perl_newHVhv(pTHX_ HV *ohv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWHVHV \ - assert(!ohv || SvTYPE(ohv) == SVt_PVHV) + ASSUME(!ohv || SvTYPE(ohv) == SVt_PVHV) /* PERL_CALLCONV IO * Perl_newIO(pTHX) @@ -2911,36 +2947,36 @@ PERL_CALLCONV OP * Perl_newLOGOP(pTHX_ I32 optype, I32 flags, OP *first, OP *other) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWLOGOP \ - assert(first); assert(other) + ASSUME(first); ASSUME(other) PERL_CALLCONV OP * Perl_newLOOPEX(pTHX_ I32 type, OP *label) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWLOOPEX \ - assert(label) + ASSUME(label) PERL_CALLCONV OP * Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP *expr, OP *block) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWLOOPOP \ - assert(expr) + ASSUME(expr) PERL_CALLCONV OP * Perl_newMETHOP(pTHX_ I32 type, I32 flags, OP *dynamic_meth) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWMETHOP \ - assert(dynamic_meth) + ASSUME(dynamic_meth) PERL_CALLCONV OP * Perl_newMETHOP_named(pTHX_ I32 type, I32 flags, SV * const_meth) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWMETHOP_NAMED \ - assert(const_meth) + ASSUME(const_meth) PERL_CALLCONV CV * Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); #define PERL_ARGS_ASSERT_NEWMYSUB \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_newNULLLIST(pTHX) @@ -2959,15 +2995,17 @@ Perl_newPADNAMELIST(size_t max) PERL_CALLCONV PADNAME * Perl_newPADNAMEouter(PADNAME *outer) + __attribute__nonnull__(1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWPADNAMEOUTER \ - assert(outer) + PERL_ASSUME_NON_NULL(outer) PERL_CALLCONV PADNAME * Perl_newPADNAMEpvn(const char *s, STRLEN len) + __attribute__nonnull__(1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWPADNAMEPVN \ - assert(s) + PERL_ASSUME_NON_NULL(s) PERL_CALLCONV OP * Perl_newPMOP(pTHX_ I32 type, I32 flags) @@ -2977,7 +3015,7 @@ Perl_newPMOP(pTHX_ I32 type, I32 flags) PERL_CALLCONV void Perl_newPROG(pTHX_ OP *o); #define PERL_ARGS_ASSERT_NEWPROG \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_newPVOP(pTHX_ I32 type, I32 flags, char *pv) @@ -2988,13 +3026,13 @@ PERL_CALLCONV OP * Perl_newRANGE(pTHX_ I32 flags, OP *left, OP *right) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWRANGE \ - assert(left); assert(right) + ASSUME(left); ASSUME(right) PERL_CALLCONV SV * Perl_newRV(pTHX_ SV * const sv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWRV \ - assert(sv) + ASSUME(sv) PERL_CALLCONV OP * Perl_newSLICEOP(pTHX_ I32 flags, OP *subscript, OP *listop) @@ -3010,7 +3048,7 @@ PERL_CALLCONV CV * Perl_newSTUB(pTHX_ GV *gv, bool fake) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_NEWSTUB \ - assert(gv) + ASSUME(gv) /* PERL_CALLCONV CV * Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block); */ @@ -3024,13 +3062,13 @@ PERL_CALLCONV OP * Perl_newSVOP(pTHX_ I32 type, I32 flags, SV *sv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVOP \ - assert(sv) + ASSUME(sv) PERL_CALLCONV OP * Perl_newSVREF(pTHX_ OP *o) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVREF \ - assert(o) + ASSUME(o) PERL_CALLCONV SV * Perl_newSV_false(pTHX) @@ -3047,7 +3085,7 @@ Perl_newSVavdefelem(pTHX_ AV *av, SSize_t ix, bool extendible) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_NEWSVAVDEFELEM \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_CALLCONV SV * Perl_newSVbool(pTHX_ const bool bool_val) @@ -3089,7 +3127,7 @@ Perl_newSVpvf(pTHX_ const char * const pat, ...) __attribute__warn_unused_result__ __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_NEWSVPVF \ - assert(pat) + ASSUME(pat) PERL_CALLCONV SV * Perl_newSVpvn(pTHX_ const char * const s, const STRLEN len) @@ -3114,7 +3152,7 @@ Perl_newSVpvz(pTHX_ const STRLEN len) PERL_CALLCONV SV * Perl_newSVrv(pTHX_ SV * const rv, const char * const classname); #define PERL_ARGS_ASSERT_NEWSVRV \ - assert(rv) + ASSUME(rv) /* PERL_CALLCONV SV * Perl_newSVsv(pTHX_ SV * const old) @@ -3124,7 +3162,7 @@ PERL_CALLCONV SV * Perl_newSVsv_flags_NN(pTHX_ SV * const old, I32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVSV_FLAGS_NN \ - assert(old) + ASSUME(old) /* PERL_CALLCONV SV * Perl_newSVsv_nomg(pTHX_ SV * const old) @@ -3139,7 +3177,7 @@ PERL_CALLCONV OP * Perl_newTRYCATCHOP(pTHX_ I32 flags, OP *tryblock, OP *catchvar, OP *catchblock) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWTRYCATCHOP \ - assert(tryblock); assert(catchvar); assert(catchblock) + ASSUME(tryblock); ASSUME(catchvar); ASSUME(catchblock) PERL_CALLCONV OP * Perl_newUNOP(pTHX_ I32 type, I32 flags, OP *first) @@ -3155,7 +3193,7 @@ PERL_CALLCONV OP * Perl_newWHENOP(pTHX_ OP *cond, OP *block) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWWHENOP \ - assert(block) + ASSUME(block) PERL_CALLCONV OP * Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP *loop, OP *expr, OP *block, OP *cont, I32 has_my) @@ -3165,23 +3203,23 @@ Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP *loop, OP *expr, OP *block PERL_CALLCONV CV * Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename); #define PERL_ARGS_ASSERT_NEWXS \ - assert(subaddr); assert(filename) + ASSUME(subaddr); ASSUME(filename) PERL_CALLCONV CV * Perl_newXS_deffile(pTHX_ const char *name, XSUBADDR_t subaddr); #define PERL_ARGS_ASSERT_NEWXS_DEFFILE \ - assert(name); assert(subaddr) + ASSUME(name); ASSUME(subaddr) PERL_CALLCONV CV * Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr, const char * const filename, const char * const proto, U32 flags); #define PERL_ARGS_ASSERT_NEWXS_FLAGS \ - assert(subaddr); assert(filename) + ASSUME(subaddr); ASSUME(filename) PERL_CALLCONV CV * Perl_newXS_len_flags(pTHX_ const char *name, STRLEN len, XSUBADDR_t subaddr, const char * const filename, const char * const proto, SV ** const_svp, U32 flags) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_NEWXS_LEN_FLAGS \ - assert(subaddr) + ASSUME(subaddr) PERL_CALLCONV PERL_SI * Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems) @@ -3196,36 +3234,42 @@ Perl_new_stackinfo_flags(pTHX_ I32 stitems, I32 cxitems, UV flags) PERL_CALLCONV SV * Perl_new_version(pTHX_ SV *ver); #define PERL_ARGS_ASSERT_NEW_VERSION \ - assert(ver) + ASSUME(ver) #define PERL_ARGS_ASSERT_NEW_WARNINGS_BITFIELD \ - assert(bits) + ASSUME(bits) PERL_CALLCONV PerlIO * Perl_nextargv(pTHX_ GV *gv, bool nomagicopen) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_NEXTARGV \ - assert(gv) + ASSUME(gv) PERL_CALLCONV char * Perl_ninstr(const char *big, const char *bigend, const char *little, const char *lend) + __attribute__nonnull__(1) + __attribute__nonnull__(2) + __attribute__nonnull__(3) + __attribute__nonnull__(4) __attribute__warn_unused_result__ __attribute__pure__; #define PERL_ARGS_ASSERT_NINSTR \ - assert(big); assert(bigend); assert(little); assert(lend) + PERL_ASSUME_NON_NULL(big); PERL_ASSUME_NON_NULL(bigend); \ + PERL_ASSUME_NON_NULL(little); PERL_ASSUME_NON_NULL(lend) PERL_CALLCONV void Perl_no_bareword_filehandle(pTHX_ const char *fhname) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_NO_BAREWORD_FILEHANDLE \ - assert(fhname) + ASSUME(fhname) PERL_CALLCONV_NO_RET void Perl_noperl_die(const char *pat, ...) + __attribute__nonnull__(1) __attribute__noreturn__ __attribute__format__(__printf__,1,2); #define PERL_ARGS_ASSERT_NOPERL_DIE \ - assert(pat) + PERL_ASSUME_NON_NULL(pat) PERL_CALLCONV void Perl_noshutdownhook(void); @@ -3245,14 +3289,14 @@ Perl_oopsAV(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_OOPSAV \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_oopsHV(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_OOPSHV \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_op_append_elem(pTHX_ I32 optype, OP *first, OP *last); @@ -3267,12 +3311,12 @@ Perl_op_class(pTHX_ const OP *o); #define PERL_ARGS_ASSERT_OP_CLASS #define PERL_ARGS_ASSERT_OP_CLEAR \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_op_contextualize(pTHX_ OP *o, I32 context); #define PERL_ARGS_ASSERT_OP_CONTEXTUALIZE \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_op_convert_list(pTHX_ I32 optype, I32 flags, OP *o) @@ -3282,7 +3326,7 @@ Perl_op_convert_list(pTHX_ I32 optype, I32 flags, OP *o) PERL_CALLCONV void Perl_op_dump(pTHX_ const OP *o); #define PERL_ARGS_ASSERT_OP_DUMP \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_op_force_list(pTHX_ OP *o); @@ -3295,7 +3339,7 @@ Perl_op_free(pTHX_ OP *arg); PERL_CALLCONV OP * Perl_op_linklist(pTHX_ OP *o); #define PERL_ARGS_ASSERT_OP_LINKLIST \ - assert(o) + ASSUME(o) /* PERL_CALLCONV OP * Perl_op_lvalue(pTHX_ OP *o, I32 type); */ @@ -3307,12 +3351,13 @@ Perl_op_lvalue_flags(pTHX_ OP *o, I32 type, U32 flags); PERL_CALLCONV void Perl_op_null(pTHX_ OP *o); #define PERL_ARGS_ASSERT_OP_NULL \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * -Perl_op_parent(OP *o); +Perl_op_parent(OP *o) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_OP_PARENT \ - assert(o) + PERL_ASSUME_NON_NULL(o) PERL_CALLCONV OP * Perl_op_prepend_elem(pTHX_ I32 optype, OP *first, OP *last); @@ -3343,62 +3388,62 @@ PERL_CALLCONV OP * Perl_op_wrap_finally(pTHX_ OP *block, OP *finally) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_OP_WRAP_FINALLY \ - assert(block); assert(finally) + ASSUME(block); ASSUME(finally) PERL_CALLCONV void Perl_opdump_printf(pTHX_ struct Perl_OpDumpContext *ctx, const char *pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_OPDUMP_PRINTF \ - assert(ctx); assert(pat) + ASSUME(ctx); ASSUME(pat) PERL_CALLCONV void Perl_package(pTHX_ OP *o) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PACKAGE \ - assert(o) + ASSUME(o) PERL_CALLCONV void Perl_package_version(pTHX_ OP *v) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PACKAGE_VERSION \ - assert(v) + ASSUME(v) PERL_CALLCONV void Perl_packlist(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist); #define PERL_ARGS_ASSERT_PACKLIST \ - assert(cat); assert(pat); assert(patend); assert(beglist); \ - assert(endlist) + ASSUME(cat); ASSUME(pat); ASSUME(patend); ASSUME(beglist); \ + ASSUME(endlist) PERL_CALLCONV PADOFFSET Perl_pad_add_anon(pTHX_ CV *func, I32 optype); #define PERL_ARGS_ASSERT_PAD_ADD_ANON \ - assert(func); \ - assert(SvTYPE(func) == SVt_PVCV || SvTYPE(func) == SVt_PVFM) + ASSUME(func); \ + ASSUME(SvTYPE(func) == SVt_PVCV || SvTYPE(func) == SVt_PVFM) PERL_CALLCONV PADOFFSET Perl_pad_add_name_pv(pTHX_ const char *name, const U32 flags, HV *typestash, HV *ourstash); #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PV \ - assert(name); assert(!typestash || SvTYPE(typestash) == SVt_PVHV); \ - assert(!ourstash || SvTYPE(ourstash) == SVt_PVHV) + ASSUME(name); ASSUME(!typestash || SvTYPE(typestash) == SVt_PVHV); \ + ASSUME(!ourstash || SvTYPE(ourstash) == SVt_PVHV) PERL_CALLCONV PADOFFSET Perl_pad_add_name_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags, HV *typestash, HV *ourstash); #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PVN \ - assert(namepv); assert(!typestash || SvTYPE(typestash) == SVt_PVHV); \ - assert(!ourstash || SvTYPE(ourstash) == SVt_PVHV) + ASSUME(namepv); ASSUME(!typestash || SvTYPE(typestash) == SVt_PVHV); \ + ASSUME(!ourstash || SvTYPE(ourstash) == SVt_PVHV) PERL_CALLCONV PADOFFSET Perl_pad_add_name_sv(pTHX_ SV *name, U32 flags, HV *typestash, HV *ourstash); #define PERL_ARGS_ASSERT_PAD_ADD_NAME_SV \ - assert(name); assert(!typestash || SvTYPE(typestash) == SVt_PVHV); \ - assert(!ourstash || SvTYPE(ourstash) == SVt_PVHV) + ASSUME(name); ASSUME(!typestash || SvTYPE(typestash) == SVt_PVHV); \ + ASSUME(!ourstash || SvTYPE(ourstash) == SVt_PVHV) PERL_CALLCONV void Perl_pad_add_weakref(pTHX_ CV *func) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PAD_ADD_WEAKREF \ - assert(func); \ - assert(SvTYPE(func) == SVt_PVCV || SvTYPE(func) == SVt_PVFM) + ASSUME(func); \ + ASSUME(SvTYPE(func) == SVt_PVCV || SvTYPE(func) == SVt_PVFM) PERL_CALLCONV PADOFFSET Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype); @@ -3412,26 +3457,26 @@ Perl_pad_block_start(pTHX_ int full) PERL_CALLCONV PADOFFSET Perl_pad_findmy_pv(pTHX_ const char *name, U32 flags); #define PERL_ARGS_ASSERT_PAD_FINDMY_PV \ - assert(name) + ASSUME(name) PERL_CALLCONV PADOFFSET Perl_pad_findmy_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags); #define PERL_ARGS_ASSERT_PAD_FINDMY_PVN \ - assert(namepv) + ASSUME(namepv) PERL_CALLCONV PADOFFSET Perl_pad_findmy_sv(pTHX_ SV *name, U32 flags); #define PERL_ARGS_ASSERT_PAD_FINDMY_SV \ - assert(name) + ASSUME(name) PERL_CALLCONV void Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PAD_FIXUP_INNER_ANONS \ - assert(padlist); assert(old_cv); \ - assert(SvTYPE(old_cv) == SVt_PVCV || SvTYPE(old_cv) == SVt_PVFM); \ - assert(new_cv); \ - assert(SvTYPE(new_cv) == SVt_PVCV || SvTYPE(new_cv) == SVt_PVFM) + ASSUME(padlist); ASSUME(old_cv); \ + ASSUME(SvTYPE(old_cv) == SVt_PVCV || SvTYPE(old_cv) == SVt_PVFM); \ + ASSUME(new_cv); \ + ASSUME(SvTYPE(new_cv) == SVt_PVCV || SvTYPE(new_cv) == SVt_PVFM) PERL_CALLCONV void Perl_pad_free(pTHX_ PADOFFSET po) @@ -3451,7 +3496,7 @@ Perl_pad_new(pTHX_ int flags) PERL_CALLCONV void Perl_pad_push(pTHX_ PADLIST *padlist, int depth); #define PERL_ARGS_ASSERT_PAD_PUSH \ - assert(padlist) + ASSUME(padlist) PERL_CALLCONV void Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust) @@ -3466,28 +3511,29 @@ PERL_CALLCONV PAD ** Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PADLIST_STORE \ - assert(padlist) + ASSUME(padlist) PERL_CALLCONV void Perl_padname_free(pTHX_ PADNAME *pn); #define PERL_ARGS_ASSERT_PADNAME_FREE \ - assert(pn) + ASSUME(pn) PERL_CALLCONV PADNAME * Perl_padnamelist_fetch(PADNAMELIST *pnl, SSize_t key) + __attribute__nonnull__(1) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_PADNAMELIST_FETCH \ - assert(pnl) + PERL_ASSUME_NON_NULL(pnl) PERL_CALLCONV void Perl_padnamelist_free(pTHX_ PADNAMELIST *pnl); #define PERL_ARGS_ASSERT_PADNAMELIST_FREE \ - assert(pnl) + ASSUME(pnl) PERL_CALLCONV PADNAME ** Perl_padnamelist_store(pTHX_ PADNAMELIST *pnl, SSize_t key, PADNAME *val); #define PERL_ARGS_ASSERT_PADNAMELIST_STORE \ - assert(pnl) + ASSUME(pnl) PERL_CALLCONV OP * Perl_parse_arithexpr(pTHX_ U32 flags); @@ -3533,13 +3579,13 @@ PERL_CALLCONV U32 Perl_parse_unicode_opts(pTHX_ const char **popt) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PARSE_UNICODE_OPTS \ - assert(popt) + ASSUME(popt) PERL_CALLCONV void Perl_parser_free(pTHX_ const yy_parser *parser) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PARSER_FREE \ - assert(parser) + ASSUME(parser) PERL_CALLCONV void Perl_peep(pTHX_ OP *o) @@ -3551,29 +3597,34 @@ perl_alloc(void); #define PERL_ARGS_ASSERT_PERL_ALLOC PERL_CALLCONV void -perl_construct(PerlInterpreter *my_perl); +perl_construct(PerlInterpreter *my_perl) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_PERL_CONSTRUCT \ - assert(my_perl) + PERL_ASSUME_NON_NULL(my_perl) PERL_CALLCONV int -perl_destruct(PerlInterpreter *my_perl); +perl_destruct(PerlInterpreter *my_perl) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_PERL_DESTRUCT \ - assert(my_perl) + PERL_ASSUME_NON_NULL(my_perl) PERL_CALLCONV void -perl_free(PerlInterpreter *my_perl); +perl_free(PerlInterpreter *my_perl) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_PERL_FREE \ - assert(my_perl) + PERL_ASSUME_NON_NULL(my_perl) PERL_CALLCONV int -perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char **argv, char **env); +perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char **argv, char **env) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_PERL_PARSE \ - assert(my_perl) + PERL_ASSUME_NON_NULL(my_perl) PERL_CALLCONV int -perl_run(PerlInterpreter *my_perl); +perl_run(PerlInterpreter *my_perl) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_PERL_RUN \ - assert(my_perl) + PERL_ASSUME_NON_NULL(my_perl) PERL_CALLCONV Signal_t Perl_perly_sighandler(int sig, Siginfo_t *info, void *uap, bool safe); @@ -3590,7 +3641,7 @@ PERL_CALLCONV OP * Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl, UV flags, I32 floor) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_PMRUNTIME \ - assert(o); assert(expr) + ASSUME(o); ASSUME(expr) PERL_CALLCONV void Perl_pop_scope(pTHX); @@ -3600,18 +3651,18 @@ PERL_CALLCONV void Perl_populate_isa(pTHX_ const char *name, STRLEN len, ...) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_POPULATE_ISA \ - assert(name) + ASSUME(name) PERL_CALLCONV REGEXP * Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags); #define PERL_ARGS_ASSERT_PREGCOMP \ - assert(pattern) + ASSUME(pattern) PERL_CALLCONV I32 Perl_pregexec(pTHX_ REGEXP * const prog, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *screamer, U32 nosave); #define PERL_ARGS_ASSERT_PREGEXEC \ - assert(prog); assert(stringarg); assert(strend); assert(strbeg); \ - assert(screamer) + ASSUME(prog); ASSUME(stringarg); ASSUME(strend); ASSUME(strbeg); \ + ASSUME(screamer) PERL_CALLCONV void Perl_pregfree(pTHX_ REGEXP *r); @@ -3620,18 +3671,18 @@ Perl_pregfree(pTHX_ REGEXP *r); PERL_CALLCONV void Perl_pregfree2(pTHX_ REGEXP *rx); #define PERL_ARGS_ASSERT_PREGFREE2 \ - assert(rx) + ASSUME(rx) PERL_CALLCONV const char * Perl_prescan_version(pTHX_ const char *s, bool strict, const char **errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha); #define PERL_ARGS_ASSERT_PRESCAN_VERSION \ - assert(s) + ASSUME(s) PERL_CALLCONV void * Perl_ptr_table_fetch(pTHX_ PTR_TBL_t * const tbl, const void * const sv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_PTR_TABLE_FETCH \ - assert(tbl) + ASSUME(tbl) PERL_CALLCONV void Perl_ptr_table_free(pTHX_ PTR_TBL_t * const tbl); @@ -3645,12 +3696,12 @@ Perl_ptr_table_new(pTHX) PERL_CALLCONV void Perl_ptr_table_split(pTHX_ PTR_TBL_t * const tbl); #define PERL_ARGS_ASSERT_PTR_TABLE_SPLIT \ - assert(tbl) + ASSUME(tbl) PERL_CALLCONV void Perl_ptr_table_store(pTHX_ PTR_TBL_t * const tbl, const void * const oldsv, void * const newsv); #define PERL_ARGS_ASSERT_PTR_TABLE_STORE \ - assert(tbl); assert(newsv) + ASSUME(tbl); ASSUME(newsv) PERL_CALLCONV void Perl_push_scope(pTHX); @@ -3659,22 +3710,22 @@ Perl_push_scope(pTHX); PERL_CALLCONV char * Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim); #define PERL_ARGS_ASSERT_PV_DISPLAY \ - assert(dsv); assert(pv) + ASSUME(dsv); ASSUME(pv) PERL_CALLCONV char * Perl_pv_escape(pTHX_ SV *dsv, char const * const str, const STRLEN count, STRLEN max, STRLEN * const escaped, U32 flags); #define PERL_ARGS_ASSERT_PV_ESCAPE \ - assert(str) + ASSUME(str) PERL_CALLCONV char * Perl_pv_pretty(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags); #define PERL_ARGS_ASSERT_PV_PRETTY \ - assert(dsv); assert(str) + ASSUME(dsv); ASSUME(str) PERL_CALLCONV char * Perl_pv_uni_display(pTHX_ SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV flags); #define PERL_ARGS_ASSERT_PV_UNI_DISPLAY \ - assert(dsv); assert(spv) + ASSUME(dsv); ASSUME(spv) #define PERL_ARGS_ASSERT_QERROR @@ -3695,22 +3746,22 @@ Perl_rcpv_new(pTHX_ const char * const pv, STRLEN len, U32 flags) PERL_CALLCONV REGEXP * Perl_re_compile(pTHX_ SV * const pattern, U32 orig_rx_flags); #define PERL_ARGS_ASSERT_RE_COMPILE \ - assert(pattern) + ASSUME(pattern) PERL_CALLCONV char * Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV *sv, const char * const strbeg, char *strpos, char *strend, const U32 flags, re_scream_pos_data *data); #define PERL_ARGS_ASSERT_RE_INTUIT_START \ - assert(rx); assert(strbeg); assert(strpos); assert(strend) + ASSUME(rx); ASSUME(strbeg); ASSUME(strpos); ASSUME(strend) PERL_CALLCONV SV * Perl_re_intuit_string(pTHX_ REGEXP * const r); #define PERL_ARGS_ASSERT_RE_INTUIT_STRING \ - assert(r) + ASSUME(r) PERL_CALLCONV REGEXP * Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, OP *expr, const regexp_engine *eng, REGEXP *old_re, bool *is_bare_re, const U32 rx_flags, const U32 pm_flags); #define PERL_ARGS_ASSERT_RE_OP_COMPILE \ - assert(eng) + ASSUME(eng) PERL_CALLCONV Malloc_t Perl_realloc(Malloc_t where, MEM_SIZE nbytes) @@ -3726,9 +3777,10 @@ Perl_reentrant_init(pTHX); #define PERL_ARGS_ASSERT_REENTRANT_INIT PERL_CALLCONV void * -Perl_reentrant_retry(const char *f, ...); +Perl_reentrant_retry(const char *f, ...) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_REENTRANT_RETRY \ - assert(f) + PERL_ASSUME_NON_NULL(f) PERL_CALLCONV void Perl_reentrant_size(pTHX); @@ -3741,17 +3793,17 @@ Perl_refcounted_he_chain_2hv(pTHX_ const struct refcounted_he *c, U32 flags); PERL_CALLCONV SV * Perl_refcounted_he_fetch_pv(pTHX_ const struct refcounted_he *chain, const char *key, U32 hash, U32 flags); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PV \ - assert(key) + ASSUME(key) PERL_CALLCONV SV * Perl_refcounted_he_fetch_pvn(pTHX_ const struct refcounted_he *chain, const char *keypv, STRLEN keylen, U32 hash, U32 flags); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PVN \ - assert(keypv) + ASSUME(keypv) PERL_CALLCONV SV * Perl_refcounted_he_fetch_sv(pTHX_ const struct refcounted_he *chain, SV *key, U32 hash, U32 flags); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_SV \ - assert(key) + ASSUME(key) PERL_CALLCONV void Perl_refcounted_he_free(pTHX_ struct refcounted_he *he); @@ -3764,87 +3816,87 @@ Perl_refcounted_he_inc(pTHX_ struct refcounted_he *he); PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_pv(pTHX_ struct refcounted_he *parent, const char *key, U32 hash, SV *value, U32 flags); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PV \ - assert(key) + ASSUME(key) PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_pvn(pTHX_ struct refcounted_he *parent, const char *keypv, STRLEN keylen, U32 hash, SV *value, U32 flags); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PVN \ - assert(keypv) + ASSUME(keypv) PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_sv(pTHX_ struct refcounted_he *parent, SV *key, U32 hash, SV *value, U32 flags); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_SV \ - assert(key) + ASSUME(key) #define PERL_ARGS_ASSERT_REG_NAMED_BUFF \ - assert(rx) + ASSUME(rx) PERL_CALLCONV SV * Perl_reg_named_buff_all(pTHX_ REGEXP * const rx, const U32 flags); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ALL \ - assert(rx) + ASSUME(rx) PERL_CALLCONV bool Perl_reg_named_buff_exists(pTHX_ REGEXP * const rx, SV * const key, const U32 flags); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_EXISTS \ - assert(rx); assert(key) + ASSUME(rx); ASSUME(key) PERL_CALLCONV SV * Perl_reg_named_buff_fetch(pTHX_ REGEXP * const rx, SV * const namesv, const U32 flags); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FETCH \ - assert(rx); assert(namesv) + ASSUME(rx); ASSUME(namesv) PERL_CALLCONV SV * Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const rx, const U32 flags); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FIRSTKEY \ - assert(rx) + ASSUME(rx) #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ITER \ - assert(rx) + ASSUME(rx) PERL_CALLCONV SV * Perl_reg_named_buff_nextkey(pTHX_ REGEXP * const rx, const U32 flags); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_NEXTKEY \ - assert(rx) + ASSUME(rx) PERL_CALLCONV SV * Perl_reg_named_buff_scalar(pTHX_ REGEXP * const rx, const U32 flags); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_SCALAR \ - assert(rx) + ASSUME(rx) #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_FETCH \ - assert(re) + ASSUME(re) #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_FETCH_FLAGS \ - assert(re) + ASSUME(re) #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_LENGTH \ - assert(rx); assert(sv) + ASSUME(rx); ASSUME(sv) #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_STORE \ - assert(rx) + ASSUME(rx) #define PERL_ARGS_ASSERT_REG_QR_PACKAGE \ - assert(rx) + ASSUME(rx) #define PERL_ARGS_ASSERT_REG_TEMP_COPY \ - assert(ssv) + ASSUME(ssv) PERL_CALLCONV void Perl_regdump(pTHX_ const regexp *r); #define PERL_ARGS_ASSERT_REGDUMP \ - assert(r) + ASSUME(r) PERL_CALLCONV I32 Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *sv, void *data, U32 flags); #define PERL_ARGS_ASSERT_REGEXEC_FLAGS \ - assert(rx); assert(stringarg); assert(strend); assert(strbeg); \ - assert(sv) + ASSUME(rx); ASSUME(stringarg); ASSUME(strend); ASSUME(strbeg); \ + ASSUME(sv) PERL_CALLCONV void Perl_regfree_internal(pTHX_ REGEXP * const rx); #define PERL_ARGS_ASSERT_REGFREE_INTERNAL \ - assert(rx) + ASSUME(rx) PERL_CALLCONV void Perl_reginitcolors(pTHX); @@ -3854,12 +3906,14 @@ PERL_CALLCONV void Perl_release_RExC_state(pTHX_ void *vstate) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_RELEASE_REXC_STATE \ - assert(vstate) + ASSUME(vstate) PERL_CALLCONV void -Perl_repeatcpy(char *to, const char *from, SSize_t len, IV count); +Perl_repeatcpy(char *to, const char *from, SSize_t len, IV count) + __attribute__nonnull__(1) + __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_REPEATCPY \ - assert(to); assert(from) + PERL_ASSUME_NON_NULL(to); PERL_ASSUME_NON_NULL(from) PERL_CALLCONV void Perl_report_evil_fh(pTHX_ const GV *gv) @@ -3876,12 +3930,12 @@ Perl_report_wrongway_fh(pTHX_ const GV *gv, const char have) PERL_CALLCONV void Perl_require_pv(pTHX_ const char *pv); #define PERL_ARGS_ASSERT_REQUIRE_PV \ - assert(pv) + ASSUME(pv) PERL_CALLCONV void Perl_resume_compcv(pTHX_ struct suspended_compcv *buffer, bool save); #define PERL_ARGS_ASSERT_RESUME_COMPCV \ - assert(buffer) + ASSUME(buffer) /* PERL_CALLCONV void Perl_resume_compcv_and_save(pTHX_ struct suspended_compcv *buffer); */ @@ -3891,10 +3945,15 @@ Perl_resume_compcv_final(pTHX_ struct suspended_compcv *buffer); */ PERL_CALLCONV char * Perl_rninstr(const char *big, const char *bigend, const char *little, const char *lend) + __attribute__nonnull__(1) + __attribute__nonnull__(2) + __attribute__nonnull__(3) + __attribute__nonnull__(4) __attribute__warn_unused_result__ __attribute__pure__; #define PERL_ARGS_ASSERT_RNINSTR \ - assert(big); assert(bigend); assert(little); assert(lend) + PERL_ASSUME_NON_NULL(big); PERL_ASSUME_NON_NULL(bigend); \ + PERL_ASSUME_NON_NULL(little); PERL_ASSUME_NON_NULL(lend) PERL_CALLCONV void Perl_rpeep(pTHX_ OP *o) @@ -3904,7 +3963,7 @@ Perl_rpeep(pTHX_ OP *o) PERL_CALLCONV void Perl_rpp_free_2_(pTHX_ SV * const sv1, SV * const sv2, const U32 rc1, const U32 rc2); #define PERL_ARGS_ASSERT_RPP_FREE_2_ \ - assert(sv1); assert(sv2) + ASSUME(sv1); ASSUME(sv2) PERL_CALLCONV void Perl_rpp_obliterate_stack_to(pTHX_ I32 ix); @@ -3923,7 +3982,7 @@ PERL_CALLCONV int Perl_rsignal_save(pTHX_ int i, Sighandler_t t1, Sigsave_t *save) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_RSIGNAL_SAVE \ - assert(save) + ASSUME(save) PERL_CALLCONV Sighandler_t Perl_rsignal_state(pTHX_ int i); @@ -3940,13 +3999,13 @@ Perl_runops_standard(pTHX); PERL_CALLCONV CV * Perl_rv2cv_op_cv(pTHX_ OP *cvop, U32 flags); #define PERL_ARGS_ASSERT_RV2CV_OP_CV \ - assert(cvop) + ASSUME(cvop) PERL_CALLCONV void Perl_rxres_save(pTHX_ void **rsp, REGEXP *rx) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_RXRES_SAVE \ - assert(rsp); assert(rx) + ASSUME(rsp); ASSUME(rx) PERL_CALLCONV Malloc_t Perl_safesyscalloc(MEM_SIZE elements, MEM_SIZE size) @@ -3972,22 +4031,22 @@ Perl_safesysrealloc(Malloc_t where, MEM_SIZE nbytes) PERL_CALLCONV void Perl_save_I16(pTHX_ I16 *intp); #define PERL_ARGS_ASSERT_SAVE_I16 \ - assert(intp) + ASSUME(intp) PERL_CALLCONV void Perl_save_I32(pTHX_ I32 *intp); #define PERL_ARGS_ASSERT_SAVE_I32 \ - assert(intp) + ASSUME(intp) PERL_CALLCONV void Perl_save_I8(pTHX_ I8 *bytep); #define PERL_ARGS_ASSERT_SAVE_I8 \ - assert(bytep) + ASSUME(bytep) PERL_CALLCONV void Perl_save_adelete(pTHX_ AV *av, SSize_t key); #define PERL_ARGS_ASSERT_SAVE_ADELETE \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) /* PERL_CALLCONV void Perl_save_aelem(pTHX_ AV *av, SSize_t idx, SV **sptr); */ @@ -3995,7 +4054,7 @@ Perl_save_aelem(pTHX_ AV *av, SSize_t idx, SV **sptr); */ PERL_CALLCONV void Perl_save_aelem_flags(pTHX_ AV *av, SSize_t idx, SV **sptr, const U32 flags); #define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS \ - assert(av); assert(SvTYPE(av) == SVt_PVAV); assert(sptr) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV); ASSUME(sptr) PERL_CALLCONV SSize_t Perl_save_alloc(pTHX_ SSize_t size, I32 pad); @@ -4004,32 +4063,32 @@ Perl_save_alloc(pTHX_ SSize_t size, I32 pad); PERL_CALLCONV void Perl_save_aptr(pTHX_ AV **aptr); #define PERL_ARGS_ASSERT_SAVE_APTR \ - assert(aptr) + ASSUME(aptr) PERL_CALLCONV AV * Perl_save_ary(pTHX_ GV *gv); #define PERL_ARGS_ASSERT_SAVE_ARY \ - assert(gv) + ASSUME(gv) PERL_CALLCONV void Perl_save_bool(pTHX_ bool *boolp); #define PERL_ARGS_ASSERT_SAVE_BOOL \ - assert(boolp) + ASSUME(boolp) PERL_CALLCONV void Perl_save_clearsv(pTHX_ SV **svp); #define PERL_ARGS_ASSERT_SAVE_CLEARSV \ - assert(svp) + ASSUME(svp) PERL_CALLCONV void Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen); #define PERL_ARGS_ASSERT_SAVE_DELETE \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(key) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV); ASSUME(key) PERL_CALLCONV void Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void *p); #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR \ - assert(p) + ASSUME(p) PERL_CALLCONV void Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void *p); @@ -4044,7 +4103,7 @@ Perl_save_freepv(pTHX_ char *pv); */ PERL_CALLCONV void Perl_save_freercpv(pTHX_ char *rcpv); #define PERL_ARGS_ASSERT_SAVE_FREERCPV \ - assert(rcpv) + ASSUME(rcpv) /* PERL_CALLCONV void Perl_save_freesv(pTHX_ SV *sv); */ @@ -4052,27 +4111,27 @@ Perl_save_freesv(pTHX_ SV *sv); */ PERL_CALLCONV void Perl_save_generic_pvref(pTHX_ char **str); #define PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF \ - assert(str) + ASSUME(str) PERL_CALLCONV void Perl_save_generic_svref(pTHX_ SV **sptr); #define PERL_ARGS_ASSERT_SAVE_GENERIC_SVREF \ - assert(sptr) + ASSUME(sptr) PERL_CALLCONV void Perl_save_gp(pTHX_ GV *gv, I32 empty); #define PERL_ARGS_ASSERT_SAVE_GP \ - assert(gv) + ASSUME(gv) PERL_CALLCONV HV * Perl_save_hash(pTHX_ GV *gv); #define PERL_ARGS_ASSERT_SAVE_HASH \ - assert(gv) + ASSUME(gv) PERL_CALLCONV void Perl_save_hdelete(pTHX_ HV *hv, SV *keysv); #define PERL_ARGS_ASSERT_SAVE_HDELETE \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(keysv) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV); ASSUME(keysv) /* PERL_CALLCONV void Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr); */ @@ -4080,7 +4139,7 @@ Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr); */ PERL_CALLCONV void Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags); #define PERL_ARGS_ASSERT_SAVE_HELEM_FLAGS \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(key); assert(sptr) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV); ASSUME(key); ASSUME(sptr) PERL_CALLCONV void Perl_save_hints(pTHX); @@ -4089,22 +4148,22 @@ Perl_save_hints(pTHX); PERL_CALLCONV void Perl_save_hptr(pTHX_ HV **hptr); #define PERL_ARGS_ASSERT_SAVE_HPTR \ - assert(hptr) + ASSUME(hptr) PERL_CALLCONV void Perl_save_int(pTHX_ int *intp); #define PERL_ARGS_ASSERT_SAVE_INT \ - assert(intp) + ASSUME(intp) PERL_CALLCONV void Perl_save_item(pTHX_ SV *item); #define PERL_ARGS_ASSERT_SAVE_ITEM \ - assert(item) + ASSUME(item) PERL_CALLCONV void Perl_save_iv(pTHX_ IV *ivp); #define PERL_ARGS_ASSERT_SAVE_IV \ - assert(ivp) + ASSUME(ivp) /* PERL_CALLCONV void Perl_save_mortalizesv(pTHX_ SV *sv); */ @@ -4119,7 +4178,7 @@ Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off); PERL_CALLCONV void Perl_save_pptr(pTHX_ char **pptr); #define PERL_ARGS_ASSERT_SAVE_PPTR \ - assert(pptr) + ASSUME(pptr) PERL_CALLCONV void Perl_save_pushi32ptr(pTHX_ const I32 i, void * const ptr, const int type); @@ -4136,7 +4195,7 @@ Perl_save_pushptrptr(pTHX_ void * const ptr1, void * const ptr2, const int type) PERL_CALLCONV void Perl_save_rcpv(pTHX_ char **prcpv); #define PERL_ARGS_ASSERT_SAVE_RCPV \ - assert(prcpv) + ASSUME(prcpv) PERL_CALLCONV void Perl_save_re_context(pTHX); @@ -4145,37 +4204,37 @@ Perl_save_re_context(pTHX); PERL_CALLCONV SV * Perl_save_scalar(pTHX_ GV *gv); #define PERL_ARGS_ASSERT_SAVE_SCALAR \ - assert(gv) + ASSUME(gv) PERL_CALLCONV void Perl_save_set_svflags(pTHX_ SV *sv, U32 mask, U32 val); #define PERL_ARGS_ASSERT_SAVE_SET_SVFLAGS \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_save_shared_pvref(pTHX_ char **str); #define PERL_ARGS_ASSERT_SAVE_SHARED_PVREF \ - assert(str) + ASSUME(str) PERL_CALLCONV void Perl_save_sptr(pTHX_ SV **sptr); #define PERL_ARGS_ASSERT_SAVE_SPTR \ - assert(sptr) + ASSUME(sptr) PERL_CALLCONV void Perl_save_strlen(pTHX_ STRLEN *ptr); #define PERL_ARGS_ASSERT_SAVE_STRLEN \ - assert(ptr) + ASSUME(ptr) PERL_CALLCONV SV * Perl_save_svref(pTHX_ SV **sptr); #define PERL_ARGS_ASSERT_SAVE_SVREF \ - assert(sptr) + ASSUME(sptr) PERL_CALLCONV void Perl_save_vptr(pTHX_ void *ptr); #define PERL_ARGS_ASSERT_SAVE_VPTR \ - assert(ptr) + ASSUME(ptr) PERL_CALLCONV char * Perl_savesharedpv(pTHX_ const char *pv) @@ -4215,43 +4274,43 @@ PERL_CALLCONV OP * Perl_scalarvoid(pTHX_ OP *o) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SCALARVOID \ - assert(o) + ASSUME(o) PERL_CALLCONV NV Perl_scan_bin(pTHX_ const char *start, STRLEN len, STRLEN *retlen); #define PERL_ARGS_ASSERT_SCAN_BIN \ - assert(start); assert(retlen) + ASSUME(start); ASSUME(retlen) PERL_CALLCONV NV Perl_scan_hex(pTHX_ const char *start, STRLEN len, STRLEN *retlen); #define PERL_ARGS_ASSERT_SCAN_HEX \ - assert(start); assert(retlen) + ASSUME(start); ASSUME(retlen) PERL_CALLCONV char * Perl_scan_num(pTHX_ const char *s, YYSTYPE *lvalp); #define PERL_ARGS_ASSERT_SCAN_NUM \ - assert(s); assert(lvalp) + ASSUME(s); ASSUME(lvalp) PERL_CALLCONV NV Perl_scan_oct(pTHX_ const char *start, STRLEN len, STRLEN *retlen); #define PERL_ARGS_ASSERT_SCAN_OCT \ - assert(start); assert(retlen) + ASSUME(start); ASSUME(retlen) #define PERL_ARGS_ASSERT_SCAN_STR \ - assert(start) + ASSUME(start) PERL_CALLCONV const char * Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv); #define PERL_ARGS_ASSERT_SCAN_VERSION \ - assert(s); assert(rv) + ASSUME(s); ASSUME(rv) PERL_CALLCONV char * Perl_scan_vstring(pTHX_ const char *s, const char * const e, SV *sv); #define PERL_ARGS_ASSERT_SCAN_VSTRING \ - assert(s); assert(e); assert(sv) + ASSUME(s); ASSUME(e); ASSUME(sv) #define PERL_ARGS_ASSERT_SCAN_WORD \ - assert(s); assert(dest); assert(slp) + ASSUME(s); ASSUME(dest); ASSUME(slp) PERL_CALLCONV U32 Perl_seed(pTHX); @@ -4262,24 +4321,25 @@ Perl_set_caret_X(pTHX); #define PERL_ARGS_ASSERT_SET_CARET_X PERL_CALLCONV void -Perl_set_context(void *t); +Perl_set_context(void *t) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_SET_CONTEXT \ - assert(t) + PERL_ASSUME_NON_NULL(t) PERL_CALLCONV void Perl_set_numeric_standard(pTHX_ const char *file, const line_t caller_line); #define PERL_ARGS_ASSERT_SET_NUMERIC_STANDARD \ - assert(file) + ASSUME(file) PERL_CALLCONV void Perl_set_numeric_underlying(pTHX_ const char *file, const line_t caller_line); #define PERL_ARGS_ASSERT_SET_NUMERIC_UNDERLYING \ - assert(file) + ASSUME(file) PERL_CALLCONV void Perl_setdefout(pTHX_ GV *gv); #define PERL_ARGS_ASSERT_SETDEFOUT \ - assert(gv) + ASSUME(gv) PERL_CALLCONV void Perl_setfd_cloexec(int fd) @@ -4309,7 +4369,7 @@ Perl_setfd_inhexec_for_sysfd(pTHX_ int fd) PERL_CALLCONV HEK * Perl_share_hek(pTHX_ const char *str, SSize_t len, U32 hash); #define PERL_ARGS_ASSERT_SHARE_HEK \ - assert(str) + ASSUME(str) PERL_CALLCONV Signal_t Perl_sighandler1(int sig) @@ -4322,28 +4382,28 @@ Perl_sighandler3(int sig, Siginfo_t *info, void *uap) #define PERL_ARGS_ASSERT_SIGHANDLER3 #define PERL_ARGS_ASSERT_SKIPSPACE_FLAGS \ - assert(s) + ASSUME(s) PERL_CALLCONV void Perl_sortsv(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp); #define PERL_ARGS_ASSERT_SORTSV \ - assert(cmp) + ASSUME(cmp) PERL_CALLCONV void Perl_sortsv_flags(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp, U32 flags); #define PERL_ARGS_ASSERT_SORTSV_FLAGS \ - assert(cmp) + ASSUME(cmp) PERL_CALLCONV SV ** Perl_stack_grow(pTHX_ SV **sp, SV **p, SSize_t n); #define PERL_ARGS_ASSERT_STACK_GROW \ - assert(sp); assert(p) + ASSUME(sp); ASSUME(p) PERL_CALLCONV PerlIO * Perl_start_glob(pTHX_ SV *tmpglob, IO *io) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_START_GLOB \ - assert(tmpglob); assert(io) + ASSUME(tmpglob); ASSUME(io) PERL_CALLCONV I32 Perl_start_subparse(pTHX_ I32 is_format, U32 flags); @@ -4353,7 +4413,7 @@ PERL_CALLCONV NV Perl_str_to_version(pTHX_ SV *sv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_STR_TO_VERSION \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV bool Perl_strict_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p); */ @@ -4362,13 +4422,13 @@ PERL_CALLCONV void Perl_sub_crush_depth(pTHX_ CV *cv) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SUB_CRUSH_DEPTH \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_subsignature_append_fence_op(pTHX_ OP *o) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SUBSIGNATURE_APPEND_FENCE_OP \ - assert(o) + ASSUME(o) PERL_CALLCONV void Perl_subsignature_append_positional(pTHX_ PADOFFSET padix, OPCODE defmode, OP *defexpr) @@ -4393,7 +4453,7 @@ Perl_subsignature_start(pTHX) PERL_CALLCONV void Perl_suspend_compcv(pTHX_ struct suspended_compcv *buffer); #define PERL_ARGS_ASSERT_SUSPEND_COMPCV \ - assert(buffer) + ASSUME(buffer) /* PERL_CALLCONV bool Perl_sv_2bool(pTHX_ SV * const sv); */ @@ -4401,17 +4461,17 @@ Perl_sv_2bool(pTHX_ SV * const sv); */ PERL_CALLCONV bool Perl_sv_2bool_flags(pTHX_ SV *sv, I32 flags); #define PERL_ARGS_ASSERT_SV_2BOOL_FLAGS \ - assert(sv) + ASSUME(sv) PERL_CALLCONV CV * Perl_sv_2cv(pTHX_ SV *sv, HV ** const st, GV ** const gvp, const I32 lref); #define PERL_ARGS_ASSERT_SV_2CV \ - assert(st); assert(gvp) + ASSUME(st); ASSUME(gvp) PERL_CALLCONV IO * Perl_sv_2io(pTHX_ SV * const sv); #define PERL_ARGS_ASSERT_SV_2IO \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV IV Perl_sv_2iv(pTHX_ SV *sv); */ @@ -4419,7 +4479,7 @@ Perl_sv_2iv(pTHX_ SV *sv); */ PERL_CALLCONV IV Perl_sv_2iv_flags(pTHX_ SV * const sv, const I32 flags); #define PERL_ARGS_ASSERT_SV_2IV_FLAGS \ - assert(sv) + ASSUME(sv) PERL_CALLCONV SV * Perl_sv_2mortal(pTHX_ SV * const sv); @@ -4429,12 +4489,12 @@ PERL_CALLCONV SV * Perl_sv_2num(pTHX_ SV * const sv) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_SV_2NUM \ - assert(sv) + ASSUME(sv) PERL_CALLCONV NV Perl_sv_2nv_flags(pTHX_ SV * const sv, const I32 flags); #define PERL_ARGS_ASSERT_SV_2NV_FLAGS \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV char * Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp); */ @@ -4442,7 +4502,7 @@ Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp); */ PERL_CALLCONV char * Perl_sv_2pv_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags); #define PERL_ARGS_ASSERT_SV_2PV_FLAGS \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV char * Perl_sv_2pv_nolen(pTHX_ SV *sv) @@ -4454,7 +4514,7 @@ Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN * const lp); */ PERL_CALLCONV char * Perl_sv_2pvbyte_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags); #define PERL_ARGS_ASSERT_SV_2PVBYTE_FLAGS \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV char * Perl_sv_2pvbyte_nolen(pTHX_ SV *sv) @@ -4466,7 +4526,7 @@ Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN * const lp); */ PERL_CALLCONV char * Perl_sv_2pvutf8_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags); #define PERL_ARGS_ASSERT_SV_2PVUTF8_FLAGS \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV char * Perl_sv_2pvutf8_nolen(pTHX_ SV *sv) @@ -4478,54 +4538,55 @@ Perl_sv_2uv(pTHX_ SV *sv); */ PERL_CALLCONV UV Perl_sv_2uv_flags(pTHX_ SV * const sv, const I32 flags); #define PERL_ARGS_ASSERT_SV_2UV_FLAGS \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void -Perl_sv_backoff(SV * const sv); +Perl_sv_backoff(SV * const sv) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_SV_BACKOFF \ - assert(sv) + PERL_ASSUME_NON_NULL(sv) PERL_CALLCONV SV * Perl_sv_bless(pTHX_ SV * const sv, HV * const stash); #define PERL_ARGS_ASSERT_SV_BLESS \ - assert(sv); assert(stash) + ASSUME(sv); ASSUME(stash) PERL_CALLCONV bool Perl_sv_can_swipe_pv_buf(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_SV_CAN_SWIPE_PV_BUF \ - assert(sv) + ASSUME(sv) PERL_CALLCONV bool Perl_sv_cat_decode(pTHX_ SV *dsv, SV *encoding, SV *ssv, int *offset, char *tstr, int tlen); #define PERL_ARGS_ASSERT_SV_CAT_DECODE \ - assert(dsv); assert(encoding); assert(ssv); assert(offset); assert(tstr) + ASSUME(dsv); ASSUME(encoding); ASSUME(ssv); ASSUME(offset); ASSUME(tstr) PERL_CALLCONV void Perl_sv_catpv(pTHX_ SV * const dsv, const char *sstr); #define PERL_ARGS_ASSERT_SV_CATPV \ - assert(dsv) + ASSUME(dsv) PERL_CALLCONV void Perl_sv_catpv_flags(pTHX_ SV * const dsv, const char *sstr, const I32 flags); #define PERL_ARGS_ASSERT_SV_CATPV_FLAGS \ - assert(dsv); assert(sstr) + ASSUME(dsv); ASSUME(sstr) PERL_CALLCONV void Perl_sv_catpv_mg(pTHX_ SV * const dsv, const char * const sstr); #define PERL_ARGS_ASSERT_SV_CATPV_MG \ - assert(dsv) + ASSUME(dsv) PERL_CALLCONV void Perl_sv_catpvf(pTHX_ SV * const sv, const char * const pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_SV_CATPVF \ - assert(sv); assert(pat) + ASSUME(sv); ASSUME(pat) PERL_CALLCONV void Perl_sv_catpvf_mg(pTHX_ SV * const sv, const char * const pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_SV_CATPVF_MG \ - assert(sv); assert(pat) + ASSUME(sv); ASSUME(pat) /* PERL_CALLCONV void Perl_sv_catpvn(pTHX_ SV * const dsv, const char *sstr, STRLEN len); */ @@ -4533,7 +4594,7 @@ Perl_sv_catpvn(pTHX_ SV * const dsv, const char *sstr, STRLEN len); */ PERL_CALLCONV void Perl_sv_catpvn_flags(pTHX_ SV * const dsv, const char *sstr, const STRLEN len, const I32 flags); #define PERL_ARGS_ASSERT_SV_CATPVN_FLAGS \ - assert(dsv); assert(sstr) + ASSUME(dsv); ASSUME(sstr) /* PERL_CALLCONV void Perl_sv_catpvn_mg(pTHX_ SV * const dsv, const char *sstr, STRLEN len); */ @@ -4544,7 +4605,7 @@ Perl_sv_catsv(pTHX_ SV * const dsv, SV * const sstr); */ PERL_CALLCONV void Perl_sv_catsv_flags(pTHX_ SV * const dsv, SV * const sstr, const I32 flags); #define PERL_ARGS_ASSERT_SV_CATSV_FLAGS \ - assert(dsv) + ASSUME(dsv) /* PERL_CALLCONV void Perl_sv_catsv_mg(pTHX_ SV * const dsv, SV * const sstr); */ @@ -4552,7 +4613,7 @@ Perl_sv_catsv_mg(pTHX_ SV * const dsv, SV * const sstr); */ PERL_CALLCONV void Perl_sv_chop(pTHX_ SV * const sv, const char * const ptr); #define PERL_ARGS_ASSERT_SV_CHOP \ - assert(sv) + ASSUME(sv) PERL_CALLCONV SSize_t Perl_sv_clean_all(pTHX) @@ -4567,7 +4628,7 @@ Perl_sv_clean_objs(pTHX) PERL_CALLCONV void Perl_sv_clear(pTHX_ SV * const orig_sv); #define PERL_ARGS_ASSERT_SV_CLEAR \ - assert(orig_sv) + ASSUME(orig_sv) PERL_CALLCONV I32 Perl_sv_cmp(pTHX_ SV * const sv1, SV * const sv2); @@ -4591,7 +4652,7 @@ Perl_sv_copypv(pTHX_ SV * const dsv, SV * const ssv); */ PERL_CALLCONV void Perl_sv_copypv_flags(pTHX_ SV * const dsv, SV * const ssv, const I32 flags); #define PERL_ARGS_ASSERT_SV_COPYPV_FLAGS \ - assert(dsv); assert(ssv) + ASSUME(dsv); ASSUME(ssv) /* PERL_CALLCONV void Perl_sv_copypv_nomg(pTHX_ SV * const dsv, SV * const ssv); */ @@ -4607,37 +4668,37 @@ Perl_sv_dec_nomg(pTHX_ SV * const sv); PERL_CALLCONV void Perl_sv_del_backref(pTHX_ SV * const tsv, SV * const sv); #define PERL_ARGS_ASSERT_SV_DEL_BACKREF \ - assert(tsv); assert(sv) + ASSUME(tsv); ASSUME(sv) PERL_CALLCONV bool Perl_sv_derived_from(pTHX_ SV *sv, const char * const name) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DERIVED_FROM \ - assert(sv); assert(name) + ASSUME(sv); ASSUME(name) PERL_CALLCONV bool Perl_sv_derived_from_hv(pTHX_ SV *sv, HV *hv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_HV \ - assert(sv); assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(sv); ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV bool Perl_sv_derived_from_pv(pTHX_ SV *sv, const char * const name, U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PV \ - assert(sv); assert(name) + ASSUME(sv); ASSUME(name) PERL_CALLCONV bool Perl_sv_derived_from_pvn(pTHX_ SV *sv, const char * const name, const STRLEN len, U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PVN \ - assert(sv); assert(name) + ASSUME(sv); ASSUME(name) PERL_CALLCONV bool Perl_sv_derived_from_sv(pTHX_ SV *sv, SV *namesv, U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_SV \ - assert(sv); assert(namesv) + ASSUME(sv); ASSUME(namesv) PERL_CALLCONV bool Perl_sv_destroyable(pTHX_ SV *sv); @@ -4647,25 +4708,25 @@ PERL_CALLCONV bool Perl_sv_does(pTHX_ SV *sv, const char * const name) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DOES \ - assert(sv); assert(name) + ASSUME(sv); ASSUME(name) PERL_CALLCONV bool Perl_sv_does_pv(pTHX_ SV *sv, const char * const name, U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DOES_PV \ - assert(sv); assert(name) + ASSUME(sv); ASSUME(name) PERL_CALLCONV bool Perl_sv_does_pvn(pTHX_ SV *sv, const char * const name, const STRLEN len, U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DOES_PVN \ - assert(sv); assert(name) + ASSUME(sv); ASSUME(name) PERL_CALLCONV bool Perl_sv_does_sv(pTHX_ SV *sv, SV *namesv, U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DOES_SV \ - assert(sv); assert(namesv) + ASSUME(sv); ASSUME(namesv) PERL_CALLCONV void Perl_sv_dump(pTHX_ SV *sv); @@ -4688,7 +4749,7 @@ Perl_sv_force_normal(pTHX_ SV *sv); */ PERL_CALLCONV void Perl_sv_force_normal_flags(pTHX_ SV * const sv, const U32 flags); #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_free(pTHX_ SV * const sv); @@ -4697,7 +4758,7 @@ Perl_sv_free(pTHX_ SV * const sv); PERL_CALLCONV void Perl_sv_free2(pTHX_ SV * const sv, const U32 refcnt); #define PERL_ARGS_ASSERT_SV_FREE2 \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_free_arenas(pTHX) @@ -4705,24 +4766,25 @@ Perl_sv_free_arenas(pTHX) #define PERL_ARGS_ASSERT_SV_FREE_ARENAS PERL_CALLCONV SV * -Perl_sv_get_backrefs(SV * const sv); +Perl_sv_get_backrefs(SV * const sv) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_SV_GET_BACKREFS \ - assert(sv) + PERL_ASSUME_NON_NULL(sv) PERL_CALLCONV char * Perl_sv_gets(pTHX_ SV * const sv, PerlIO * const fp, SSize_t append); #define PERL_ARGS_ASSERT_SV_GETS \ - assert(sv); assert(fp) + ASSUME(sv); ASSUME(fp) PERL_CALLCONV char * Perl_sv_grow(pTHX_ SV * const sv, STRLEN newlen); #define PERL_ARGS_ASSERT_SV_GROW \ - assert(sv) + ASSUME(sv) PERL_CALLCONV char * Perl_sv_grow_fresh(pTHX_ SV * const sv, STRLEN newlen); #define PERL_ARGS_ASSERT_SV_GROW_FRESH \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_inc(pTHX_ SV * const sv); @@ -4738,18 +4800,18 @@ Perl_sv_insert(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, c PERL_CALLCONV void Perl_sv_insert_flags(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char *little, const STRLEN littlelen, const U32 flags); #define PERL_ARGS_ASSERT_SV_INSERT_FLAGS \ - assert(bigstr); assert(little) + ASSUME(bigstr); ASSUME(little) PERL_CALLCONV int Perl_sv_isa(pTHX_ SV *sv, const char * const name); #define PERL_ARGS_ASSERT_SV_ISA \ - assert(name) + ASSUME(name) PERL_CALLCONV bool Perl_sv_isa_sv(pTHX_ SV *sv, SV *namesv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_ISA_SV \ - assert(sv); assert(namesv) + ASSUME(sv); ASSUME(namesv) PERL_CALLCONV int Perl_sv_isobject(pTHX_ SV *sv); @@ -4770,20 +4832,20 @@ Perl_sv_len_utf8(pTHX_ SV * const sv); PERL_CALLCONV STRLEN Perl_sv_len_utf8_nomg(pTHX_ SV * const sv); #define PERL_ARGS_ASSERT_SV_LEN_UTF8_NOMG \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_magic(pTHX_ SV * const sv, SV * const obj, const int how, const char * const name, const I32 namlen); #define PERL_ARGS_ASSERT_SV_MAGIC \ - assert(sv) + ASSUME(sv) PERL_CALLCONV MAGIC * Perl_sv_magicext(pTHX_ SV * const sv, SV * const obj, const int how, const MGVTBL * const vtbl, const char * const name, const I32 namlen); #define PERL_ARGS_ASSERT_SV_MAGICEXT \ - assert(sv) + ASSUME(sv) #define PERL_ARGS_ASSERT_SV_MAGICEXT_MGLOB \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV SV * Perl_sv_mortalcopy(pTHX_ SV * const oldsv) @@ -4821,22 +4883,22 @@ Perl_sv_peek(pTHX_ SV *sv); PERL_CALLCONV void Perl_sv_pos_b2u(pTHX_ SV * const sv, I32 * const offsetp); #define PERL_ARGS_ASSERT_SV_POS_B2U \ - assert(offsetp) + ASSUME(offsetp) PERL_CALLCONV STRLEN Perl_sv_pos_b2u_flags(pTHX_ SV * const sv, STRLEN const offset, U32 flags); #define PERL_ARGS_ASSERT_SV_POS_B2U_FLAGS \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_pos_u2b(pTHX_ SV * const sv, I32 * const offsetp, I32 * const lenp); #define PERL_ARGS_ASSERT_SV_POS_U2B \ - assert(offsetp) + ASSUME(offsetp) PERL_CALLCONV STRLEN Perl_sv_pos_u2b_flags(pTHX_ SV * const sv, STRLEN uoffset, STRLEN * const lenp, U32 flags); #define PERL_ARGS_ASSERT_SV_POS_U2B_FLAGS \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV char * Perl_sv_pv(pTHX_ SV *sv) @@ -4849,7 +4911,7 @@ Perl_sv_pvbyte(pTHX_ SV *sv) PERL_CALLCONV char * Perl_sv_pvbyten_force(pTHX_ SV * const sv, STRLEN * const lp); #define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV char * Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp); */ @@ -4857,7 +4919,7 @@ Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp); */ PERL_CALLCONV char * Perl_sv_pvn_force_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags); #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV char * Perl_sv_pvutf8(pTHX_ SV *sv) @@ -4866,44 +4928,44 @@ Perl_sv_pvutf8(pTHX_ SV *sv) PERL_CALLCONV char * Perl_sv_pvutf8n_force(pTHX_ SV * const sv, STRLEN * const lp); #define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE \ - assert(sv) + ASSUME(sv) PERL_CALLCONV char * Perl_sv_recode_to_utf8(pTHX_ SV *sv, SV *encoding); #define PERL_ARGS_ASSERT_SV_RECODE_TO_UTF8 \ - assert(sv); assert(encoding) + ASSUME(sv); ASSUME(encoding) PERL_CALLCONV SV * Perl_sv_ref(pTHX_ SV *dst, const SV * const sv, const int ob); #define PERL_ARGS_ASSERT_SV_REF \ - assert(sv) + ASSUME(sv) PERL_CALLCONV const char * Perl_sv_reftype(pTHX_ const SV * const sv, const int ob) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_REFTYPE \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_regex_global_pos_clear(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_SV_REGEX_GLOBAL_POS_CLEAR \ - assert(sv) + ASSUME(sv) PERL_CALLCONV bool Perl_sv_regex_global_pos_get(pTHX_ SV *sv, STRLEN *posp, U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_REGEX_GLOBAL_POS_GET \ - assert(sv); assert(posp) + ASSUME(sv); ASSUME(posp) PERL_CALLCONV void Perl_sv_regex_global_pos_set(pTHX_ SV *sv, STRLEN pos, U32 flags); #define PERL_ARGS_ASSERT_SV_REGEX_GLOBAL_POS_SET \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_replace(pTHX_ SV * const sv, SV * const nsv); #define PERL_ARGS_ASSERT_SV_REPLACE \ - assert(sv); assert(nsv) + ASSUME(sv); ASSUME(nsv) PERL_CALLCONV void Perl_sv_report_used(pTHX); @@ -4912,7 +4974,7 @@ Perl_sv_report_used(pTHX); PERL_CALLCONV void Perl_sv_reset(pTHX_ const char *s, HV * const stash); #define PERL_ARGS_ASSERT_SV_RESET \ - assert(s); assert(!stash || SvTYPE(stash) == SVt_PVHV) + ASSUME(s); ASSUME(!stash || SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void Perl_sv_resetpvn(pTHX_ const char *s, STRLEN len, HV * const stash) @@ -4922,144 +4984,144 @@ Perl_sv_resetpvn(pTHX_ const char *s, STRLEN len, HV * const stash) PERL_CALLCONV SV * Perl_sv_rvunweaken(pTHX_ SV * const sv); #define PERL_ARGS_ASSERT_SV_RVUNWEAKEN \ - assert(sv) + ASSUME(sv) PERL_CALLCONV SV * Perl_sv_rvweaken(pTHX_ SV * const sv); #define PERL_ARGS_ASSERT_SV_RVWEAKEN \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_set_bool(pTHX_ SV *sv, const bool bool_val); #define PERL_ARGS_ASSERT_SV_SET_BOOL \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_set_false(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_SV_SET_FALSE \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_set_true(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_SV_SET_TRUE \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_set_undef(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_SV_SET_UNDEF \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_sethek(pTHX_ SV * const sv, const HEK * const hek); #define PERL_ARGS_ASSERT_SV_SETHEK \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_setiv(pTHX_ SV * const sv, const IV num); #define PERL_ARGS_ASSERT_SV_SETIV \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_setiv_mg(pTHX_ SV * const sv, const IV i); #define PERL_ARGS_ASSERT_SV_SETIV_MG \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_setnv(pTHX_ SV * const sv, const NV num); #define PERL_ARGS_ASSERT_SV_SETNV \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_setnv_mg(pTHX_ SV * const sv, const NV num); #define PERL_ARGS_ASSERT_SV_SETNV_MG \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_setpv(pTHX_ SV * const sv, const char * const ptr); #define PERL_ARGS_ASSERT_SV_SETPV \ - assert(sv) + ASSUME(sv) PERL_CALLCONV char * Perl_sv_setpv_bufsize(pTHX_ SV * const sv, const STRLEN cur, const STRLEN len); #define PERL_ARGS_ASSERT_SV_SETPV_BUFSIZE \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_setpv_mg(pTHX_ SV * const sv, const char * const ptr); #define PERL_ARGS_ASSERT_SV_SETPV_MG \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_setpvf(pTHX_ SV * const sv, const char * const pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_SV_SETPVF \ - assert(sv); assert(pat) + ASSUME(sv); ASSUME(pat) PERL_CALLCONV void Perl_sv_setpvf_mg(pTHX_ SV * const sv, const char * const pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_SV_SETPVF_MG \ - assert(sv); assert(pat) + ASSUME(sv); ASSUME(pat) PERL_CALLCONV void Perl_sv_setpvn(pTHX_ SV * const sv, const char * const ptr, const STRLEN len); #define PERL_ARGS_ASSERT_SV_SETPVN \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_setpvn_fresh(pTHX_ SV * const sv, const char * const ptr, const STRLEN len); #define PERL_ARGS_ASSERT_SV_SETPVN_FRESH \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_setpvn_mg(pTHX_ SV * const sv, const char * const ptr, const STRLEN len); #define PERL_ARGS_ASSERT_SV_SETPVN_MG \ - assert(sv); assert(ptr) + ASSUME(sv); ASSUME(ptr) PERL_CALLCONV SV * Perl_sv_setref_iv(pTHX_ SV * const rv, const char * const classname, const IV iv); #define PERL_ARGS_ASSERT_SV_SETREF_IV \ - assert(rv) + ASSUME(rv) PERL_CALLCONV SV * Perl_sv_setref_nv(pTHX_ SV * const rv, const char * const classname, const NV nv); #define PERL_ARGS_ASSERT_SV_SETREF_NV \ - assert(rv) + ASSUME(rv) PERL_CALLCONV SV * Perl_sv_setref_pv(pTHX_ SV * const rv, const char * const classname, void * const pv); #define PERL_ARGS_ASSERT_SV_SETREF_PV \ - assert(rv) + ASSUME(rv) PERL_CALLCONV SV * Perl_sv_setref_pvn(pTHX_ SV * const rv, const char * const classname, const char * const pv, const STRLEN n); #define PERL_ARGS_ASSERT_SV_SETREF_PVN \ - assert(rv); assert(pv) + ASSUME(rv); ASSUME(pv) PERL_CALLCONV SV * Perl_sv_setref_uv(pTHX_ SV * const rv, const char * const classname, const UV uv); #define PERL_ARGS_ASSERT_SV_SETREF_UV \ - assert(rv) + ASSUME(rv) PERL_CALLCONV void Perl_sv_setrv_inc(pTHX_ SV * const sv, SV * const ref); #define PERL_ARGS_ASSERT_SV_SETRV_INC \ - assert(sv); assert(ref) + ASSUME(sv); ASSUME(ref) PERL_CALLCONV void Perl_sv_setrv_inc_mg(pTHX_ SV * const sv, SV * const ref); #define PERL_ARGS_ASSERT_SV_SETRV_INC_MG \ - assert(sv); assert(ref) + ASSUME(sv); ASSUME(ref) PERL_CALLCONV void Perl_sv_setrv_noinc(pTHX_ SV * const sv, SV * const ref); #define PERL_ARGS_ASSERT_SV_SETRV_NOINC \ - assert(sv); assert(ref) + ASSUME(sv); ASSUME(ref) PERL_CALLCONV void Perl_sv_setrv_noinc_mg(pTHX_ SV * const sv, SV * const ref); #define PERL_ARGS_ASSERT_SV_SETRV_NOINC_MG \ - assert(sv); assert(ref) + ASSUME(sv); ASSUME(ref) /* PERL_CALLCONV void Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv); */ @@ -5067,22 +5129,22 @@ Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv); */ PERL_CALLCONV void Perl_sv_setsv_flags(pTHX_ SV *dsv, SV *ssv, const I32 flags); #define PERL_ARGS_ASSERT_SV_SETSV_FLAGS \ - assert(dsv) + ASSUME(dsv) PERL_CALLCONV void Perl_sv_setsv_mg(pTHX_ SV * const dsv, SV * const ssv); #define PERL_ARGS_ASSERT_SV_SETSV_MG \ - assert(dsv) + ASSUME(dsv) PERL_CALLCONV void Perl_sv_setuv(pTHX_ SV * const sv, const UV num); #define PERL_ARGS_ASSERT_SV_SETUV \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_setuv_mg(pTHX_ SV * const sv, const UV u); #define PERL_ARGS_ASSERT_SV_SETUV_MG \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV bool Perl_sv_streq(pTHX_ SV *sv1, SV *sv2); */ @@ -5094,12 +5156,12 @@ Perl_sv_streq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags); PERL_CALLCONV SV * Perl_sv_strftime_ints(pTHX_ SV *fmt, int sec, int min, int hour, int mday, int mon, int year, int isdst); #define PERL_ARGS_ASSERT_SV_STRFTIME_INTS \ - assert(fmt) + ASSUME(fmt) PERL_CALLCONV SV * Perl_sv_strftime_tm(pTHX_ SV *fmt, const struct tm *mytm); #define PERL_ARGS_ASSERT_SV_STRFTIME_TM \ - assert(fmt); assert(mytm) + ASSUME(fmt); ASSUME(mytm) PERL_CALLCONV SV * Perl_sv_string_from_errnum(pTHX_ int errnum, SV *tgtsv); @@ -5112,7 +5174,7 @@ PERL_CALLCONV bool Perl_sv_tainted(pTHX_ SV * const sv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_TAINTED \ - assert(sv) + ASSUME(sv) PERL_CALLCONV I32 Perl_sv_true(pTHX_ SV * const sv); @@ -5122,17 +5184,17 @@ PERL_CALLCONV char * Perl_sv_uni_display(pTHX_ SV *dsv, SV *ssv, STRLEN pvlim, UV flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_UNI_DISPLAY \ - assert(dsv); assert(ssv) + ASSUME(dsv); ASSUME(ssv) PERL_CALLCONV int Perl_sv_unmagic(pTHX_ SV * const sv, const int type); #define PERL_ARGS_ASSERT_SV_UNMAGIC \ - assert(sv) + ASSUME(sv) PERL_CALLCONV int Perl_sv_unmagicext(pTHX_ SV * const sv, const int type, const MGVTBL *vtbl); #define PERL_ARGS_ASSERT_SV_UNMAGICEXT \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV void Perl_sv_unref(pTHX_ SV *sv); */ @@ -5140,17 +5202,17 @@ Perl_sv_unref(pTHX_ SV *sv); */ PERL_CALLCONV void Perl_sv_unref_flags(pTHX_ SV * const ref, const U32 flags); #define PERL_ARGS_ASSERT_SV_UNREF_FLAGS \ - assert(ref) + ASSUME(ref) PERL_CALLCONV void Perl_sv_untaint(pTHX_ SV * const sv); #define PERL_ARGS_ASSERT_SV_UNTAINT \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_sv_upgrade(pTHX_ SV * const sv, svtype new_type); #define PERL_ARGS_ASSERT_SV_UPGRADE \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV void Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len); */ @@ -5158,7 +5220,7 @@ Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len); */ PERL_CALLCONV void Perl_sv_usepvn_flags(pTHX_ SV * const sv, char *ptr, const STRLEN len, const U32 flags); #define PERL_ARGS_ASSERT_SV_USEPVN_FLAGS \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV void Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len); */ @@ -5166,7 +5228,7 @@ Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len); */ PERL_CALLCONV bool Perl_sv_utf8_decode(pTHX_ SV * const sv); #define PERL_ARGS_ASSERT_SV_UTF8_DECODE \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV bool Perl_sv_utf8_downgrade(pTHX_ SV * const sv, const bool fail_ok); */ @@ -5174,7 +5236,7 @@ Perl_sv_utf8_downgrade(pTHX_ SV * const sv, const bool fail_ok); */ PERL_CALLCONV bool Perl_sv_utf8_downgrade_flags(pTHX_ SV * const sv, const bool fail_ok, const U32 flags); #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_FLAGS \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV bool Perl_sv_utf8_downgrade_nomg(pTHX_ SV * const sv, const bool fail_ok); */ @@ -5182,7 +5244,7 @@ Perl_sv_utf8_downgrade_nomg(pTHX_ SV * const sv, const bool fail_ok); */ PERL_CALLCONV void Perl_sv_utf8_encode(pTHX_ SV * const sv); #define PERL_ARGS_ASSERT_SV_UTF8_ENCODE \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade(pTHX_ SV *sv); */ @@ -5193,7 +5255,7 @@ Perl_sv_utf8_upgrade_flags(pTHX_ SV * const sv, const I32 flags); */ PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV * const sv, const I32 flags, STRLEN extra); #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW \ - assert(sv) + ASSUME(sv) /* PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_nomg(pTHX_ SV *sv); */ @@ -5201,42 +5263,42 @@ Perl_sv_utf8_upgrade_nomg(pTHX_ SV *sv); */ PERL_CALLCONV void Perl_sv_vcatpvf(pTHX_ SV * const sv, const char * const pat, va_list * const args); #define PERL_ARGS_ASSERT_SV_VCATPVF \ - assert(sv); assert(pat) + ASSUME(sv); ASSUME(pat) PERL_CALLCONV void Perl_sv_vcatpvf_mg(pTHX_ SV * const sv, const char * const pat, va_list * const args); #define PERL_ARGS_ASSERT_SV_VCATPVF_MG \ - assert(sv); assert(pat) + ASSUME(sv); ASSUME(pat) PERL_CALLCONV void Perl_sv_vcatpvfn(pTHX_ SV * const sv, const char * const pat, const STRLEN patlen, va_list * const args, SV ** const svargs, const Size_t sv_count, bool * const maybe_tainted); #define PERL_ARGS_ASSERT_SV_VCATPVFN \ - assert(sv); assert(pat) + ASSUME(sv); ASSUME(pat) PERL_CALLCONV void Perl_sv_vcatpvfn_flags(pTHX_ SV * const sv, const char * const pat, const STRLEN patlen, va_list * const args, SV ** const svargs, const Size_t sv_count, bool * const maybe_tainted, const U32 flags); #define PERL_ARGS_ASSERT_SV_VCATPVFN_FLAGS \ - assert(sv); assert(pat) + ASSUME(sv); ASSUME(pat) PERL_CALLCONV void Perl_sv_vsetpvf(pTHX_ SV * const sv, const char * const pat, va_list * const args); #define PERL_ARGS_ASSERT_SV_VSETPVF \ - assert(sv); assert(pat) + ASSUME(sv); ASSUME(pat) PERL_CALLCONV void Perl_sv_vsetpvf_mg(pTHX_ SV * const sv, const char * const pat, va_list * const args); #define PERL_ARGS_ASSERT_SV_VSETPVF_MG \ - assert(sv); assert(pat) + ASSUME(sv); ASSUME(pat) PERL_CALLCONV void Perl_sv_vsetpvfn(pTHX_ SV * const sv, const char * const pat, const STRLEN patlen, va_list * const args, SV ** const svargs, const Size_t sv_count, bool * const maybe_tainted); #define PERL_ARGS_ASSERT_SV_VSETPVFN \ - assert(sv); assert(pat) + ASSUME(sv); ASSUME(pat) PERL_CALLCONV const char * Perl_sv_vstring_get(pTHX_ SV * const sv, STRLEN *lenp); #define PERL_ARGS_ASSERT_SV_VSTRING_GET \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_switch_to_global_locale(pTHX); @@ -5247,14 +5309,20 @@ Perl_sync_locale(pTHX); #define PERL_ARGS_ASSERT_SYNC_LOCALE PERL_CALLCONV void -Perl_sys_init(int *argc, char ***argv); +Perl_sys_init(int *argc, char ***argv) + __attribute__nonnull__(1) + __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_SYS_INIT \ - assert(argc); assert(argv) + PERL_ASSUME_NON_NULL(argc); PERL_ASSUME_NON_NULL(argv) PERL_CALLCONV void -Perl_sys_init3(int *argc, char ***argv, char ***env); +Perl_sys_init3(int *argc, char ***argv, char ***env) + __attribute__nonnull__(1) + __attribute__nonnull__(2) + __attribute__nonnull__(3); #define PERL_ARGS_ASSERT_SYS_INIT3 \ - assert(argc); assert(argv); assert(env) + PERL_ASSUME_NON_NULL(argc); PERL_ASSUME_NON_NULL(argv); \ + PERL_ASSUME_NON_NULL(env) PERL_CALLCONV void Perl_sys_term(void); @@ -5267,13 +5335,13 @@ Perl_taint_env(pTHX); PERL_CALLCONV void Perl_taint_proper(pTHX_ const char *f, const char * const s); #define PERL_ARGS_ASSERT_TAINT_PROPER \ - assert(s) + ASSUME(s) PERL_CALLCONV OP * Perl_tied_method(pTHX_ SV *methname, SV **mark, SV * const sv, const MAGIC * const mg, const U32 flags, U32 argc, ...) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_TIED_METHOD \ - assert(methname); assert(mark); assert(sv); assert(mg) + ASSUME(methname); ASSUME(mark); ASSUME(sv); ASSUME(mg) PERL_CALLCONV SSize_t Perl_tmps_grow_p(pTHX_ SSize_t ix); @@ -5285,17 +5353,17 @@ Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp); */ PERL_CALLCONV UV Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp); #define PERL_ARGS_ASSERT_TO_UNI_LOWER \ - assert(p); assert(lenp) + ASSUME(p); ASSUME(lenp) PERL_CALLCONV UV Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp); #define PERL_ARGS_ASSERT_TO_UNI_TITLE \ - assert(p); assert(lenp) + ASSUME(p); ASSUME(lenp) PERL_CALLCONV UV Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp); #define PERL_ARGS_ASSERT_TO_UNI_UPPER \ - assert(p); assert(lenp) + ASSUME(p); ASSUME(lenp) PERL_CALLCONV bool Perl_try_amagic_bin(pTHX_ int method, int flags); @@ -5307,14 +5375,16 @@ Perl_try_amagic_un(pTHX_ int method, int flags); PERL_CALLCONV char * Perl_uiv_2buf(char * const buf, const IV iv, UV uv, const int is_uv, char ** const peob) + __attribute__nonnull__(1) + __attribute__nonnull__(5) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_UIV_2BUF \ - assert(buf); assert(peob) + PERL_ASSUME_NON_NULL(buf); PERL_ASSUME_NON_NULL(peob) PERL_CALLCONV SSize_t Perl_unpackstring(pTHX_ const char *pat, const char *patend, const char *s, const char *strend, U32 flags); #define PERL_ARGS_ASSERT_UNPACKSTRING \ - assert(pat); assert(patend); assert(s); assert(strend) + ASSUME(pat); ASSUME(patend); ASSUME(s); ASSUME(strend) PERL_CALLCONV void Perl_unshare_hek(pTHX_ HEK *hek); @@ -5327,16 +5397,16 @@ Perl_unsharepvn(pTHX_ const char *sv, I32 len, U32 hash); PERL_CALLCONV SV * Perl_upg_version(pTHX_ SV *ver, bool qv); #define PERL_ARGS_ASSERT_UPG_VERSION \ - assert(ver) + ASSUME(ver) #define PERL_ARGS_ASSERT_UTF16_TO_UTF8 \ - assert(p); assert(d); assert(newlen) + ASSUME(p); ASSUME(d); ASSUME(newlen) #define PERL_ARGS_ASSERT_UTF16_TO_UTF8_BASE \ - assert(p); assert(d); assert(newlen) + ASSUME(p); ASSUME(d); ASSUME(newlen) #define PERL_ARGS_ASSERT_UTF16_TO_UTF8_REVERSED \ - assert(p); assert(d); assert(newlen) + ASSUME(p); ASSUME(d); ASSUME(newlen) /* PERL_CALLCONV U8 * Perl_utf8_hop_back(const U8 *s, SSize_t off, const U8 * const start) @@ -5354,20 +5424,20 @@ PERL_CALLCONV STRLEN Perl_utf8_length(pTHX_ const U8 *s0, const U8 *e) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_UTF8_LENGTH \ - assert(s0); assert(e) + ASSUME(s0); ASSUME(e) PERL_CALLCONV U8 * Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *lenp); #define PERL_ARGS_ASSERT_UTF8_TO_BYTES \ - assert(s); assert(lenp) + ASSUME(s); ASSUME(lenp) PERL_CALLCONV bool Perl_utf8_to_bytes_(pTHX_ U8 **s_ptr, STRLEN *lenp, void **free_me, Perl_utf8_to_bytes_arg result_as); #define PERL_ARGS_ASSERT_UTF8_TO_BYTES_ \ - assert(s_ptr); assert(lenp); assert(free_me) + ASSUME(s_ptr); ASSUME(lenp); ASSUME(free_me) #define PERL_ARGS_ASSERT_UTF8_TO_UTF16_BASE \ - assert(s); assert(d); assert(newlen) + ASSUME(s); ASSUME(d); ASSUME(newlen) /* PERL_CALLCONV bool Perl_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p); */ @@ -5379,9 +5449,13 @@ Perl_utf8_to_uv_errors(const U8 * const s, const U8 * const e, UV *cp_p, Size_t Perl_utf8_to_uv_flags(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p, U32 flags); */ PERL_CALLCONV bool -Perl_utf8_to_uv_msgs_helper_(const U8 * const s0, const U8 * const e, UV *cp_p, Size_t *advance_p, U32 flags, U32 *errors, AV **msgs); +Perl_utf8_to_uv_msgs_helper_(const U8 * const s0, const U8 * const e, UV *cp_p, Size_t *advance_p, U32 flags, U32 *errors, AV **msgs) + __attribute__nonnull__(1) + __attribute__nonnull__(2) + __attribute__nonnull__(3); #define PERL_ARGS_ASSERT_UTF8_TO_UV_MSGS_HELPER_ \ - assert(s0); assert(e); assert(cp_p) + PERL_ASSUME_NON_NULL(s0); PERL_ASSUME_NON_NULL(e); \ + PERL_ASSUME_NON_NULL(cp_p) /* PERL_CALLCONV UV Perl_utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags); */ @@ -5393,7 +5467,7 @@ PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_UTILIZE \ - assert(idop) + ASSUME(idop) /* PERL_CALLCONV U8 * Perl_uv_to_utf8_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs); */ @@ -5413,17 +5487,17 @@ Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); */ PERL_CALLCONV U8 * Perl_uvoffuni_to_utf8_flags_msgs(pTHX_ U8 *d, UV input_uv, const UV flags, HV **msgs); #define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS_MSGS \ - assert(d) + ASSUME(d) PERL_CALLCONV bool Perl_valid_identifier_pve(pTHX_ const char *s, const char *end, U32 flags); #define PERL_ARGS_ASSERT_VALID_IDENTIFIER_PVE \ - assert(s); assert(end) + ASSUME(s); ASSUME(end) PERL_CALLCONV bool Perl_valid_identifier_pvn(pTHX_ const char *s, STRLEN len, U32 flags); #define PERL_ARGS_ASSERT_VALID_IDENTIFIER_PVN \ - assert(s) + ASSUME(s) PERL_CALLCONV bool Perl_valid_identifier_sv(pTHX_ SV *sv); @@ -5434,12 +5508,12 @@ Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen) __attribute__warn_unused_result__; */ #define PERL_ARGS_ASSERT_VALIDATE_PROTO \ - assert(name) + ASSUME(name) PERL_CALLCONV int Perl_vcmp(pTHX_ SV *lhv, SV *rhv); #define PERL_ARGS_ASSERT_VCMP \ - assert(lhv); assert(rhv) + ASSUME(lhv); ASSUME(rhv) PERL_CALLCONV_NO_RET void Perl_vcroak(pTHX_ const char *pat, va_list *args) @@ -5449,96 +5523,96 @@ Perl_vcroak(pTHX_ const char *pat, va_list *args) PERL_CALLCONV void Perl_vdeb(pTHX_ const char *pat, va_list *args); #define PERL_ARGS_ASSERT_VDEB \ - assert(pat) + ASSUME(pat) PERL_CALLCONV void Perl_vfatal_warner(pTHX_ U32 err, const char *pat, va_list *args); #define PERL_ARGS_ASSERT_VFATAL_WARNER \ - assert(pat) + ASSUME(pat) PERL_CALLCONV char * Perl_vform(pTHX_ const char *pat, va_list *args); #define PERL_ARGS_ASSERT_VFORM \ - assert(pat) + ASSUME(pat) #define PERL_ARGS_ASSERT_VIVIFY_DEFELEM \ - assert(sv) + ASSUME(sv) PERL_CALLCONV SV * Perl_vivify_ref(pTHX_ SV *sv, U32 to_what) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_VIVIFY_REF \ - assert(sv) + ASSUME(sv) PERL_CALLCONV void Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args); #define PERL_ARGS_ASSERT_VLOAD_MODULE \ - assert(name) + ASSUME(name) PERL_CALLCONV SV * Perl_vmess(pTHX_ const char *pat, va_list *args); #define PERL_ARGS_ASSERT_VMESS \ - assert(pat) + ASSUME(pat) PERL_CALLCONV SV * Perl_vnewSVpvf(pTHX_ const char * const pat, va_list * const args) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_VNEWSVPVF \ - assert(pat) + ASSUME(pat) PERL_CALLCONV SV * Perl_vnormal(pTHX_ SV *vs); #define PERL_ARGS_ASSERT_VNORMAL \ - assert(vs) + ASSUME(vs) PERL_CALLCONV SV * Perl_vnumify(pTHX_ SV *vs); #define PERL_ARGS_ASSERT_VNUMIFY \ - assert(vs) + ASSUME(vs) PERL_CALLCONV SV * Perl_vstringify(pTHX_ SV *vs); #define PERL_ARGS_ASSERT_VSTRINGIFY \ - assert(vs) + ASSUME(vs) PERL_CALLCONV SV * Perl_vverify(pTHX_ SV *vs); #define PERL_ARGS_ASSERT_VVERIFY \ - assert(vs) + ASSUME(vs) PERL_CALLCONV void Perl_vwarn(pTHX_ const char *pat, va_list *args); #define PERL_ARGS_ASSERT_VWARN \ - assert(pat) + ASSUME(pat) PERL_CALLCONV void Perl_vwarner(pTHX_ U32 err, const char *pat, va_list *args); #define PERL_ARGS_ASSERT_VWARNER \ - assert(pat) + ASSUME(pat) PERL_CALLCONV I32 Perl_wait4pid(pTHX_ Pid_t pid, int *statusp, int flags) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_WAIT4PID \ - assert(statusp) + ASSUME(statusp) PERL_CALLCONV void Perl_warn(pTHX_ const char *pat, ...) __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_WARN \ - assert(pat) + ASSUME(pat) PERL_CALLCONV void Perl_warn_sv(pTHX_ SV *baseex); #define PERL_ARGS_ASSERT_WARN_SV \ - assert(baseex) + ASSUME(baseex) PERL_CALLCONV void Perl_warner(pTHX_ U32 err, const char *pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_WARNER \ - assert(pat) + ASSUME(pat) PERL_CALLCONV I32 Perl_was_lvalue_sub(pTHX) @@ -5549,7 +5623,7 @@ PERL_CALLCONV void Perl_watch(pTHX_ char **addr) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_WATCH \ - assert(addr) + ASSUME(addr) /* PERL_CALLCONV I32 Perl_whichsig(pTHX_ const char *sig); */ @@ -5557,59 +5631,61 @@ Perl_whichsig(pTHX_ const char *sig); */ PERL_CALLCONV I32 Perl_whichsig_pv(pTHX_ const char *sig); #define PERL_ARGS_ASSERT_WHICHSIG_PV \ - assert(sig) + ASSUME(sig) PERL_CALLCONV I32 Perl_whichsig_pvn(pTHX_ const char *sig, STRLEN len); #define PERL_ARGS_ASSERT_WHICHSIG_PVN \ - assert(sig) + ASSUME(sig) PERL_CALLCONV I32 Perl_whichsig_sv(pTHX_ SV *sigsv); #define PERL_ARGS_ASSERT_WHICHSIG_SV \ - assert(sigsv) + ASSUME(sigsv) PERL_CALLCONV void Perl_wrap_infix_plugin(pTHX_ Perl_infix_plugin_t new_plugin, Perl_infix_plugin_t *old_plugin_p); #define PERL_ARGS_ASSERT_WRAP_INFIX_PLUGIN \ - assert(new_plugin); assert(old_plugin_p) + ASSUME(new_plugin); ASSUME(old_plugin_p) PERL_CALLCONV void Perl_wrap_keyword_plugin(pTHX_ Perl_keyword_plugin_t new_plugin, Perl_keyword_plugin_t *old_plugin_p); #define PERL_ARGS_ASSERT_WRAP_KEYWORD_PLUGIN \ - assert(new_plugin); assert(old_plugin_p) + ASSUME(new_plugin); ASSUME(old_plugin_p) PERL_CALLCONV void Perl_wrap_op_checker(pTHX_ Optype opcode, Perl_check_t new_checker, Perl_check_t *old_checker_p); #define PERL_ARGS_ASSERT_WRAP_OP_CHECKER \ - assert(new_checker); assert(old_checker_p) + ASSUME(new_checker); ASSUME(old_checker_p) PERL_CALLCONV void Perl_write_to_stderr(pTHX_ SV *msv) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_WRITE_TO_STDERR \ - assert(msv) + ASSUME(msv) PERL_CALLCONV void Perl_xs_boot_epilog(pTHX_ const SSize_t ax); #define PERL_ARGS_ASSERT_XS_BOOT_EPILOG PERL_CALLCONV Stack_off_t -Perl_xs_handshake(const U32 key, void *v_my_perl, const char *file, ...); +Perl_xs_handshake(const U32 key, void *v_my_perl, const char *file, ...) + __attribute__nonnull__(2) + __attribute__nonnull__(3); #define PERL_ARGS_ASSERT_XS_HANDSHAKE \ - assert(v_my_perl); assert(file) + PERL_ASSUME_NON_NULL(v_my_perl); PERL_ASSUME_NON_NULL(file) PERL_CALLCONV int Perl_yyerror(pTHX_ const char * const s) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_YYERROR \ - assert(s) + ASSUME(s) PERL_CALLCONV int Perl_yyerror_pv(pTHX_ const char * const s, U32 flags) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_YYERROR_PV \ - assert(s) + ASSUME(s) PERL_CALLCONV int Perl_yyerror_pvn(pTHX_ const char * const s, STRLEN len, U32 flags) @@ -5639,26 +5715,28 @@ Perl_get_debug_opts(pTHX_ const char **s, bool givehelp) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_GET_DEBUG_OPTS \ - assert(s) + ASSUME(s) PERL_CALLCONV void Perl_hv_assert(pTHX_ HV *hv); # define PERL_ARGS_ASSERT_HV_ASSERT \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_pad_setsv(pTHX_ PADOFFSET po, SV *sv); # define PERL_ARGS_ASSERT_PAD_SETSV \ - assert(sv) + ASSUME(sv) PERL_CALLCONV SV * Perl_pad_sv(pTHX_ PADOFFSET po); # define PERL_ARGS_ASSERT_PAD_SV PERL_CALLCONV void -Perl_set_padlist(CV *cv, PADLIST *padlist); +Perl_set_padlist(CV *cv, PADLIST *padlist) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_SET_PADLIST \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + PERL_ASSUME_NON_NULL(cv); \ + ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) #endif /* defined(DEBUGGING) */ #if defined(DEBUG_LEAKING_SCALARS_FORK_DUMP) @@ -5666,7 +5744,7 @@ PERL_CALLCONV void Perl_dump_sv_child(pTHX_ SV *sv) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DUMP_SV_CHILD \ - assert(sv) + ASSUME(sv) #endif #if !defined(EBCDIC) @@ -5691,23 +5769,25 @@ PERL_CALLCONV char * Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_GETENV_LEN \ - assert(env_elem); assert(len) + ASSUME(env_elem); ASSUME(len) #endif #if !defined(HAS_MKOSTEMP) PERL_CALLCONV int Perl_my_mkostemp(char *templte, int flags) + __attribute__nonnull__(1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MY_MKOSTEMP \ - assert(templte) + PERL_ASSUME_NON_NULL(templte) #endif #if !defined(HAS_MKSTEMP) PERL_CALLCONV int Perl_my_mkstemp(char *templte) + __attribute__nonnull__(1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MY_MKSTEMP \ - assert(templte) + PERL_ASSUME_NON_NULL(templte) #endif #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) @@ -5715,37 +5795,37 @@ PERL_CALLCONV I32 Perl_do_ipcctl(pTHX_ I32 optype, SV **mark, SV **sp) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_IPCCTL \ - assert(mark); assert(sp) + ASSUME(mark); ASSUME(sp) PERL_CALLCONV I32 Perl_do_ipcget(pTHX_ I32 optype, SV **mark, SV **sp) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_IPCGET \ - assert(mark); assert(sp) + ASSUME(mark); ASSUME(sp) PERL_CALLCONV SSize_t Perl_do_msgrcv(pTHX_ SV **mark, SV **sp) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_MSGRCV \ - assert(mark); assert(sp) + ASSUME(mark); ASSUME(sp) PERL_CALLCONV I32 Perl_do_msgsnd(pTHX_ SV **mark, SV **sp) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_MSGSND \ - assert(mark); assert(sp) + ASSUME(mark); ASSUME(sp) PERL_CALLCONV I32 Perl_do_semop(pTHX_ SV **mark, SV **sp) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_SEMOP \ - assert(mark); assert(sp) + ASSUME(mark); ASSUME(sp) PERL_CALLCONV I32 Perl_do_shmio(pTHX_ I32 optype, SV **mark, SV **sp) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_SHMIO \ - assert(mark); assert(sp) + ASSUME(mark); ASSUME(sp) #endif /* defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) */ #if defined(HAS_PIPE) @@ -5754,7 +5834,7 @@ Perl_PerlProc_pipe_cloexec(pTHX_ int *pipefd) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_PERLPROC_PIPE_CLOEXEC \ - assert(pipefd) + ASSUME(pipefd) #endif #if !defined(HAS_RENAME) @@ -5762,7 +5842,7 @@ PERL_CALLCONV I32 Perl_same_dirent(pTHX_ const char *a, const char *b) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_SAME_DIRENT \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) #endif #if !defined(HAS_SIGNBIT) @@ -5795,7 +5875,7 @@ Perl_PerlSock_socketpair_cloexec(pTHX_ int domain, int type, int protocol, int * __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_PERLSOCK_SOCKETPAIR_CLOEXEC \ - assert(pairfd) + ASSUME(pairfd) #endif #if !defined(HAS_STRLCPY) @@ -5804,6 +5884,17 @@ Perl_my_strlcpy(char *dst, const char *src, Size_t size); # define PERL_ARGS_ASSERT_MY_STRLCPY #endif +#if !defined(HAS_STRNLEN) + +# if !defined(PERL_NO_INLINE_FUNCTIONS) +PERL_STATIC_INLINE Size_t +Perl_my_strnlen(const char *str, Size_t maxlen) + __attribute__nonnull__(1); +# define PERL_ARGS_ASSERT_MY_STRNLEN \ + PERL_ASSUME_NON_NULL(str) + +# endif +#endif /* !defined(HAS_STRNLEN) */ #if defined(HAVE_INTERP_INTERN) PERL_CALLCONV void Perl_sys_intern_clear(pTHX); @@ -5817,7 +5908,7 @@ Perl_sys_intern_init(pTHX); PERL_CALLCONV void Perl_sys_intern_dup(pTHX_ struct interp_intern *src, struct interp_intern *dst); # define PERL_ARGS_ASSERT_SYS_INTERN_DUP \ - assert(src); assert(dst) + ASSUME(src); ASSUME(dst) # endif #endif /* defined(HAVE_INTERP_INTERN) */ @@ -5826,7 +5917,7 @@ PERL_CALLCONV int Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) #else PERL_CALLCONV_NO_RET int @@ -5834,7 +5925,7 @@ Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg) __attribute__noreturn__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) #endif #if defined(MULTIPLICITY) @@ -5846,9 +5937,10 @@ Perl_croak_nocontext(const char *pat, ...) PERL_CALLCONV void Perl_deb_nocontext(const char *pat, ...) + __attribute__nonnull__(1) __attribute__format__(__printf__,1,2); # define PERL_ARGS_ASSERT_DEB_NOCONTEXT \ - assert(pat) + PERL_ASSUME_NON_NULL(pat) PERL_CALLCONV_NO_RET OP * Perl_die_nocontext(const char *pat, ...) @@ -5858,79 +5950,93 @@ Perl_die_nocontext(const char *pat, ...) PERL_CALLCONV char * Perl_form_nocontext(const char *pat, ...) + __attribute__nonnull__(1) __attribute__format__(__printf__,1,2); # define PERL_ARGS_ASSERT_FORM_NOCONTEXT \ - assert(pat) + PERL_ASSUME_NON_NULL(pat) PERL_CALLCONV void -Perl_load_module_nocontext(U32 flags, SV *name, SV *ver, ...); +Perl_load_module_nocontext(U32 flags, SV *name, SV *ver, ...) + __attribute__nonnull__(2); # define PERL_ARGS_ASSERT_LOAD_MODULE_NOCONTEXT \ - assert(name) + PERL_ASSUME_NON_NULL(name) PERL_CALLCONV SV * Perl_mess_nocontext(const char *pat, ...) + __attribute__nonnull__(1) __attribute__format__(__printf__,1,2); # define PERL_ARGS_ASSERT_MESS_NOCONTEXT \ - assert(pat) + PERL_ASSUME_NON_NULL(pat) PERL_CALLCONV void * Perl_my_cxt_init(pTHX_ int *indexp, size_t size); # define PERL_ARGS_ASSERT_MY_CXT_INIT \ - assert(indexp) + ASSUME(indexp) PERL_CALLCONV SV * Perl_newSVpvf_nocontext(const char * const pat, ...) + __attribute__nonnull__(1) __attribute__format__(__printf__,1,2); # define PERL_ARGS_ASSERT_NEWSVPVF_NOCONTEXT \ - assert(pat) + PERL_ASSUME_NON_NULL(pat) PERL_CALLCONV void Perl_sv_catpvf_mg_nocontext(SV * const sv, const char * const pat, ...) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__format__(__printf__,2,3); # define PERL_ARGS_ASSERT_SV_CATPVF_MG_NOCONTEXT \ - assert(sv); assert(pat) + PERL_ASSUME_NON_NULL(sv); PERL_ASSUME_NON_NULL(pat) PERL_CALLCONV void Perl_sv_catpvf_nocontext(SV * const sv, const char * const pat, ...) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__format__(__printf__,2,3); # define PERL_ARGS_ASSERT_SV_CATPVF_NOCONTEXT \ - assert(sv); assert(pat) + PERL_ASSUME_NON_NULL(sv); PERL_ASSUME_NON_NULL(pat) PERL_CALLCONV void Perl_sv_setpvf_mg_nocontext(SV * const sv, const char * const pat, ...) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__format__(__printf__,2,3); # define PERL_ARGS_ASSERT_SV_SETPVF_MG_NOCONTEXT \ - assert(sv); assert(pat) + PERL_ASSUME_NON_NULL(sv); PERL_ASSUME_NON_NULL(pat) PERL_CALLCONV void Perl_sv_setpvf_nocontext(SV * const sv, const char * const pat, ...) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__format__(__printf__,2,3); # define PERL_ARGS_ASSERT_SV_SETPVF_NOCONTEXT \ - assert(sv); assert(pat) + PERL_ASSUME_NON_NULL(sv); PERL_ASSUME_NON_NULL(pat) PERL_CALLCONV void Perl_warn_nocontext(const char *pat, ...) + __attribute__nonnull__(1) __attribute__format__(__printf__,1,2); # define PERL_ARGS_ASSERT_WARN_NOCONTEXT \ - assert(pat) + PERL_ASSUME_NON_NULL(pat) PERL_CALLCONV void Perl_warner_nocontext(U32 err, const char *pat, ...) + __attribute__nonnull__(2) __attribute__format__(__printf__,2,3); # define PERL_ARGS_ASSERT_WARNER_NOCONTEXT \ - assert(pat) + PERL_ASSUME_NON_NULL(pat) #endif /* defined(MULTIPLICITY) */ #if defined(MYMALLOC) PERL_CALLCONV void Perl_dump_mstats(pTHX_ const char *s); # define PERL_ARGS_ASSERT_DUMP_MSTATS \ - assert(s) + ASSUME(s) PERL_CALLCONV int Perl_get_mstats(pTHX_ perl_mstats_t *buf, int buflen, int level); # define PERL_ARGS_ASSERT_GET_MSTATS \ - assert(buf) + ASSUME(buf) PERL_CALLCONV MEM_SIZE Perl_malloc_good_size(size_t nbytes) @@ -5940,10 +6046,11 @@ Perl_malloc_good_size(size_t nbytes) PERL_CALLCONV MEM_SIZE Perl_malloced_size(void *p) + __attribute__nonnull__(1) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MALLOCED_SIZE \ - assert(p) + PERL_ASSUME_NON_NULL(p) #endif /* defined(MYMALLOC) */ #if !defined(NO_MATHOMS) @@ -5955,25 +6062,25 @@ PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) __attribute__deprecated__; # define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \ - assert(s) + ASSUME(s) PERL_CALLCONV UV Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) __attribute__deprecated__; # define PERL_ARGS_ASSERT_UTF8_TO_UVUNI \ - assert(s) + ASSUME(s) PERL_CALLCONV UV Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) __attribute__deprecated__; # define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI \ - assert(s) + ASSUME(s) PERL_CALLCONV U8 * Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv) __attribute__deprecated__; # define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \ - assert(d) + ASSUME(d) # if defined(PERL_IN_MATHOMS_C) || defined(PERL_IN_OP_C) || \ defined(PERL_IN_PERLY_C) || defined(PERL_IN_TOKE_C) @@ -5985,7 +6092,7 @@ Perl_ref(pTHX_ OP *o, I32 type); #endif /* !defined(NO_MATHOMS) */ #if defined(PERL_ANY_COW) # define PERL_ARGS_ASSERT_SV_SETSV_COW \ - assert(ssv) + ASSUME(ssv) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV SV * @@ -5997,44 +6104,45 @@ PERL_CALLCONV void Perl_opslab_force_free(pTHX_ OPSLAB *slab) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OPSLAB_FORCE_FREE \ - assert(slab) + ASSUME(slab) PERL_CALLCONV void Perl_opslab_free(pTHX_ OPSLAB *slab) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OPSLAB_FREE \ - assert(slab) + ASSUME(slab) PERL_CALLCONV void Perl_opslab_free_nopad(pTHX_ OPSLAB *slab) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OPSLAB_FREE_NOPAD \ - assert(slab) + ASSUME(slab) PERL_CALLCONV void Perl_parser_free_nexttoke_ops(pTHX_ yy_parser *parser, OPSLAB *slab) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_PARSER_FREE_NEXTTOKE_OPS \ - assert(parser); assert(slab) + ASSUME(parser); ASSUME(slab) # if defined(PERL_DEBUG_READONLY_OPS) PERL_CALLCONV void Perl_Slab_to_ro(pTHX_ OPSLAB *slab); # define PERL_ARGS_ASSERT_SLAB_TO_RO \ - assert(slab) + ASSUME(slab) PERL_CALLCONV void Perl_Slab_to_rw(pTHX_ OPSLAB * const slab); # define PERL_ARGS_ASSERT_SLAB_TO_RW \ - assert(slab) + ASSUME(slab) # endif /* defined(PERL_DEBUG_READONLY_OPS) */ # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE bool S_should_warn_nl(const char *pv) + __attribute__nonnull__(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SHOULD_WARN_NL \ - assert(pv) + PERL_ASSUME_NON_NULL(pv) # endif #endif /* defined(PERL_CORE) */ @@ -6054,9 +6162,15 @@ Perl_current_re_engine(pTHX); PERL_CALLCONV void Perl_cv_ckproto_len_flags(pTHX_ const CV *cv, const GV *gv, const char *p, const STRLEN len, const U32 flags); PERL_CALLCONV char * -Perl_delimcpy_no_escape(char *to, const char *to_end, const char *from, const char *from_end, const int delim, I32 *retlen); +Perl_delimcpy_no_escape(char *to, const char *to_end, const char *from, const char *from_end, const int delim, I32 *retlen) + __attribute__nonnull__(1) + __attribute__nonnull__(2) + __attribute__nonnull__(3) + __attribute__nonnull__(4) + __attribute__nonnull__(6); PERL_CALLCONV I16 Perl_do_uniprop_match(const char * const key, const U16 key_len) + __attribute__nonnull__(1) __attribute__warn_unused_result__; PERL_CALLCONV char * Perl_dup_warnings(pTHX_ char *warnings); @@ -6142,14 +6256,18 @@ PERL_CALLCONV bool Perl_isSCRIPT_RUN(pTHX_ const U8 *s, const U8 *send, const bool utf8_target) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_ISSCRIPT_RUN \ - assert(s); assert(send) + ASSUME(s); ASSUME(send) +# if !defined(HAS_MEMRCHR) + +# endif # if defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || \ defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_ANY) || \ defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C) || \ defined(PERL_IN_UTF8_C) PERL_CALLCONV SSize_t Perl__invlist_search(SV * const invlist, const UV cp) + __attribute__nonnull__(1) __attribute__warn_unused_result__; # endif # if defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || \ @@ -6216,7 +6334,9 @@ Perl_is_grapheme(pTHX_ const U8 *strbeg, const U8 *s, const U8 *strend, const UV # if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || \ defined(PERL_IN_UTF8_C) PERL_CALLCONV UV -Perl__to_fold_latin1(const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags); +Perl__to_fold_latin1(const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags) + __attribute__nonnull__(2) + __attribute__nonnull__(3); # endif # if defined(PERL_IN_REGCOMP_DEBUG_C) && defined(DEBUGGING) STATIC U8 @@ -6239,12 +6359,12 @@ S_regdump_intflags(pTHX_ const char *lead, const U32 flags); PERL_CALLCONV void Perl_finalize_optree(pTHX_ OP *o); # define PERL_ARGS_ASSERT_FINALIZE_OPTREE \ - assert(o) + ASSUME(o) PERL_CALLCONV void Perl_optimize_optree(pTHX_ OP *o); # define PERL_ARGS_ASSERT_OPTIMIZE_OPTREE \ - assert(o) + ASSUME(o) #endif /* defined(PERL_CORE) || defined(PERL_USE_VOLATILE_API) */ #if defined(PERL_DEBUG_READONLY_COW) @@ -6252,14 +6372,14 @@ PERL_CALLCONV void Perl_sv_buf_to_ro(pTHX_ SV *sv) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_SV_BUF_TO_RO \ - assert(sv) + ASSUME(sv) #endif #if defined(PERL_DEBUG_READONLY_OPS) PERL_CALLCONV PADOFFSET Perl_op_refcnt_dec(pTHX_ OP *o); # define PERL_ARGS_ASSERT_OP_REFCNT_DEC \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_op_refcnt_inc(pTHX_ OP *o); @@ -6271,14 +6391,14 @@ PERL_CALLCONV bool Perl_do_exec(pTHX_ const char *cmd) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_EXEC \ - assert(cmd) + ASSUME(cmd) #else PERL_CALLCONV bool Perl_do_exec(pTHX_ const char *cmd) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_EXEC \ - assert(cmd) + ASSUME(cmd) #endif #if defined(PERL_DONT_CREATE_GVSV) @@ -6288,19 +6408,44 @@ Perl_gv_SVadd(pTHX_ GV *gv); */ #endif #if defined(PERL_IMPLICIT_SYS) PERL_CALLCONV PerlInterpreter * -perl_alloc_using(const struct IPerlMem **ipM, const struct IPerlMem **ipMS, const struct IPerlMem **ipMP, const struct IPerlEnv **ipE, const struct IPerlStdIO **ipStd, const struct IPerlLIO **ipLIO, const struct IPerlDir **ipD, const struct IPerlSock **ipS, const struct IPerlProc **ipP); +perl_alloc_using(const struct IPerlMem **ipM, const struct IPerlMem **ipMS, const struct IPerlMem **ipMP, const struct IPerlEnv **ipE, const struct IPerlStdIO **ipStd, const struct IPerlLIO **ipLIO, const struct IPerlDir **ipD, const struct IPerlSock **ipS, const struct IPerlProc **ipP) + __attribute__nonnull__(1) + __attribute__nonnull__(2) + __attribute__nonnull__(3) + __attribute__nonnull__(4) + __attribute__nonnull__(5) + __attribute__nonnull__(6) + __attribute__nonnull__(7) + __attribute__nonnull__(8) + __attribute__nonnull__(9); # define PERL_ARGS_ASSERT_PERL_ALLOC_USING \ - assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); \ - assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) + PERL_ASSUME_NON_NULL(ipM); PERL_ASSUME_NON_NULL(ipMS); \ + PERL_ASSUME_NON_NULL(ipMP); PERL_ASSUME_NON_NULL(ipE); \ + PERL_ASSUME_NON_NULL(ipStd); PERL_ASSUME_NON_NULL(ipLIO); \ + PERL_ASSUME_NON_NULL(ipD); PERL_ASSUME_NON_NULL(ipS); \ + PERL_ASSUME_NON_NULL(ipP) # if defined(USE_ITHREADS) PERL_CALLCONV PerlInterpreter * -perl_clone_using(PerlInterpreter *proto_perl, UV flags, const struct IPerlMem **ipM, const struct IPerlMem **ipMS, const struct IPerlMem **ipMP, const struct IPerlEnv **ipE, const struct IPerlStdIO **ipStd, const struct IPerlLIO **ipLIO, const struct IPerlDir **ipD, const struct IPerlSock **ipS, const struct IPerlProc **ipP); +perl_clone_using(PerlInterpreter *proto_perl, UV flags, const struct IPerlMem **ipM, const struct IPerlMem **ipMS, const struct IPerlMem **ipMP, const struct IPerlEnv **ipE, const struct IPerlStdIO **ipStd, const struct IPerlLIO **ipLIO, const struct IPerlDir **ipD, const struct IPerlSock **ipS, const struct IPerlProc **ipP) + __attribute__nonnull__(1) + __attribute__nonnull__(3) + __attribute__nonnull__(4) + __attribute__nonnull__(5) + __attribute__nonnull__(6) + __attribute__nonnull__(7) + __attribute__nonnull__(8) + __attribute__nonnull__(9) + __attribute__nonnull__(10) + __attribute__nonnull__(11); # define PERL_ARGS_ASSERT_PERL_CLONE_USING \ - assert(proto_perl); assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); \ - assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) + PERL_ASSUME_NON_NULL(proto_perl); PERL_ASSUME_NON_NULL(ipM); \ + PERL_ASSUME_NON_NULL(ipMS); PERL_ASSUME_NON_NULL(ipMP); \ + PERL_ASSUME_NON_NULL(ipE); PERL_ASSUME_NON_NULL(ipStd); \ + PERL_ASSUME_NON_NULL(ipLIO); PERL_ASSUME_NON_NULL(ipD); \ + PERL_ASSUME_NON_NULL(ipS); PERL_ASSUME_NON_NULL(ipP) -# endif +# endif /* defined(USE_ITHREADS) */ #else /* if !defined(PERL_IMPLICIT_SYS) */ PERL_CALLCONV I32 Perl_my_pclose(pTHX_ PerlIO *ptr); @@ -6309,14 +6454,14 @@ Perl_my_pclose(pTHX_ PerlIO *ptr); PERL_CALLCONV PerlIO * Perl_my_popen(pTHX_ const char *cmd, const char *mode); # define PERL_ARGS_ASSERT_MY_POPEN \ - assert(cmd); assert(mode) + ASSUME(cmd); ASSUME(mode) #endif /* !defined(PERL_IMPLICIT_SYS) */ #if defined(PERL_IN_AV_C) STATIC MAGIC * S_get_aux_mg(pTHX_ AV *av); # define PERL_ARGS_ASSERT_GET_AUX_MG \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) #endif #if defined(PERL_IN_BUILTIN_C) || defined(PERL_IN_OP_C) @@ -6324,7 +6469,7 @@ PERL_CALLCONV void Perl_XS_builtin_indexed(pTHX_ CV *cv) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_XS_BUILTIN_INDEXED \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_finish_export_lexical(pTHX) @@ -6346,7 +6491,7 @@ Perl_prepare_export_lexical(pTHX) STATIC void S_class_cleanup_definition(pTHX_ HV *stash); # define PERL_ARGS_ASSERT_CLASS_CLEANUP_DEFINITION \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV) #endif #if defined(PERL_IN_CLASS_C) || defined(PERL_IN_GLOBALS_C) || \ @@ -6356,357 +6501,357 @@ Perl_ck_anoncode(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_ANONCODE \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_backtick(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_BACKTICK \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_bitop(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_BITOP \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_classname(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_CLASSNAME \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_cmp(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_CMP \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_concat(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_CONCAT \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_defined(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_DEFINED \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_delete(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_DELETE \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_each(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_EACH \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_eof(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_EOF \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_eval(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_EVAL \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_exec(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_EXEC \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_exists(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_EXISTS \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_ftst(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_FTST \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_fun(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_FUN \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_glob(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_GLOB \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_grep(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_GREP \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_helemexistsor(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_HELEMEXISTSOR \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_index(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_INDEX \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_isa(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_ISA \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_join(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_JOIN \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_length(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_LENGTH \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_lfun(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_LFUN \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_listiob(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_LISTIOB \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_match(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_MATCH \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_method(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_METHOD \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_null(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_NULL \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_open(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_OPEN \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_prototype(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_PROTOTYPE \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_readline(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_READLINE \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_refassign(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_REFASSIGN \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_repeat(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_REPEAT \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_require(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_REQUIRE \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_return(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_RETURN \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_rfun(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_RFUN \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_rvconst(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_RVCONST \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_sassign(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SASSIGN \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_scmp(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SCMP \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_select(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SELECT \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_shift(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SHIFT \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_smartmatch(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SMARTMATCH \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_sort(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SORT \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_spair(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SPAIR \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_split(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SPLIT \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_stringify(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_STRINGIFY \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_subr(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SUBR \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_substr(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SUBSTR \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_svconst(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_SVCONST \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_tell(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_TELL \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_trunc(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_TRUNC \ - assert(o) + ASSUME(o) PERL_CALLCONV OP * Perl_ck_trycatch(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_CK_TRYCATCH \ - assert(o) + ASSUME(o) #endif /* defined(PERL_IN_CLASS_C) || defined(PERL_IN_GLOBALS_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) */ @@ -6716,23 +6861,23 @@ Perl_ck_trycatch(pTHX_ OP *o) PERL_CALLCONV void Perl_class_add_ADJUST(pTHX_ HV *stash, CV *cv); # define PERL_ARGS_ASSERT_CLASS_ADD_ADJUST \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV); assert(cv); \ - assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV); ASSUME(cv); \ + ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_class_add_field(pTHX_ HV *stash, PADNAME *pn); # define PERL_ARGS_ASSERT_CLASS_ADD_FIELD \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV); assert(pn) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV); ASSUME(pn) PERL_CALLCONV void Perl_class_apply_attributes(pTHX_ HV *stash, OP *attrlist); # define PERL_ARGS_ASSERT_CLASS_APPLY_ATTRIBUTES \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void Perl_class_apply_field_attributes(pTHX_ PADNAME *pn, OP *attrlist); # define PERL_ARGS_ASSERT_CLASS_APPLY_FIELD_ATTRIBUTES \ - assert(pn) + ASSUME(pn) PERL_CALLCONV void Perl_class_prepare_initfield_parse(pTHX); @@ -6741,22 +6886,22 @@ Perl_class_prepare_initfield_parse(pTHX); PERL_CALLCONV void Perl_class_prepare_method_parse(pTHX_ CV *cv); # define PERL_ARGS_ASSERT_CLASS_PREPARE_METHOD_PARSE \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_CALLCONV void Perl_class_seal_stash(pTHX_ HV *stash); # define PERL_ARGS_ASSERT_CLASS_SEAL_STASH \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV void Perl_class_set_field_defop(pTHX_ PADNAME *pn, OPCODE defmode, OP *defop); # define PERL_ARGS_ASSERT_CLASS_SET_FIELD_DEFOP \ - assert(pn); assert(defop) + ASSUME(pn); ASSUME(defop) PERL_CALLCONV void Perl_class_setup_stash(pTHX_ HV *stash); # define PERL_ARGS_ASSERT_CLASS_SETUP_STASH \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV) PERL_CALLCONV OP * Perl_class_wrap_method_body(pTHX_ OP *o); @@ -6765,7 +6910,7 @@ Perl_class_wrap_method_body(pTHX_ OP *o); PERL_CALLCONV void Perl_croak_kw_unless_class(pTHX_ const char *kw); # define PERL_ARGS_ASSERT_CROAK_KW_UNLESS_CLASS \ - assert(kw) + ASSUME(kw) #endif /* defined(PERL_IN_CLASS_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_PAD_C) || defined(PERL_IN_PERLY_C) || @@ -6774,35 +6919,36 @@ Perl_croak_kw_unless_class(pTHX_ const char *kw); STATIC void S_deb_stack_n(pTHX_ SV **stack_base, SSize_t stack_min, SSize_t stack_max, SSize_t mark_min, SSize_t mark_max, SSize_t nonrc_base); # define PERL_ARGS_ASSERT_DEB_STACK_N \ - assert(stack_base) + ASSUME(stack_base) #endif #if defined(PERL_IN_DOIO_C) STATIC bool S_argvout_final(pTHX_ MAGIC *mg, IO *io, bool is_explicit); # define PERL_ARGS_ASSERT_ARGVOUT_FINAL \ - assert(mg); assert(io) + ASSUME(mg); ASSUME(io) STATIC void S_exec_failed(pTHX_ const char *cmd, int fd, int do_report); # define PERL_ARGS_ASSERT_EXEC_FAILED \ - assert(cmd) + ASSUME(cmd) STATIC bool -S_is_fork_open(const char *name); +S_is_fork_open(const char *name) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_IS_FORK_OPEN \ - assert(name) + PERL_ASSUME_NON_NULL(name) STATIC bool S_openn_cleanup(pTHX_ GV *gv, IO *io, PerlIO *fp, char *mode, const char *oname, PerlIO *saveifp, PerlIO *saveofp, int savefd, char savetype, int writing, bool was_fdopen, const char *type, Stat_t *statbufp); # define PERL_ARGS_ASSERT_OPENN_CLEANUP \ - assert(gv); assert(io); assert(mode); assert(oname) + ASSUME(gv); ASSUME(io); ASSUME(mode); ASSUME(oname) STATIC IO * S_openn_setup(pTHX_ GV *gv, char *mode, PerlIO **saveifp, PerlIO **saveofp, int *savefd, char *savetype); # define PERL_ARGS_ASSERT_OPENN_SETUP \ - assert(gv); assert(mode); assert(saveifp); assert(saveofp); \ - assert(savefd); assert(savetype) + ASSUME(gv); ASSUME(mode); ASSUME(saveifp); ASSUME(saveofp); \ + ASSUME(savefd); ASSUME(savetype) # if !defined(DOSISH) STATIC bool @@ -6817,31 +6963,31 @@ STATIC Size_t S_do_trans_complex(pTHX_ SV * const sv, const OPtrans_map * const tbl) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX \ - assert(sv); assert(tbl) + ASSUME(sv); ASSUME(tbl) STATIC Size_t S_do_trans_count(pTHX_ SV * const sv, const OPtrans_map * const tbl) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DO_TRANS_COUNT \ - assert(sv); assert(tbl) + ASSUME(sv); ASSUME(tbl) STATIC Size_t S_do_trans_count_invmap(pTHX_ SV * const sv, AV * const invmap) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DO_TRANS_COUNT_INVMAP \ - assert(sv); assert(invmap); assert(SvTYPE(invmap) == SVt_PVAV) + ASSUME(sv); ASSUME(invmap); ASSUME(SvTYPE(invmap) == SVt_PVAV) STATIC Size_t S_do_trans_invmap(pTHX_ SV * const sv, AV * const invmap) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DO_TRANS_INVMAP \ - assert(sv); assert(invmap); assert(SvTYPE(invmap) == SVt_PVAV) + ASSUME(sv); ASSUME(invmap); ASSUME(SvTYPE(invmap) == SVt_PVAV) STATIC Size_t S_do_trans_simple(pTHX_ SV * const sv, const OPtrans_map * const tbl) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE \ - assert(sv); assert(tbl) + ASSUME(sv); ASSUME(tbl) #endif /* defined(PERL_IN_DOOP_C) */ #if defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || \ @@ -6850,7 +6996,7 @@ S_do_trans_simple(pTHX_ SV * const sv, const OPtrans_map * const tbl) defined(PERL_IN_UTF8_C) # define PERL_ARGS_ASSERT__INVLIST_SEARCH \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) #endif /* defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_ANY) || @@ -6868,10 +7014,10 @@ S_do_trans_simple(pTHX_ SV * const sv, const OPtrans_map * const tbl) _invlist_intersection(pTHX_ SV * const a, SV * const b, SV **i); */ # define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND \ - assert(b); assert(i) + ASSUME(b); ASSUME(i) # define PERL_ARGS_ASSERT__INVLIST_INVERT \ - assert(invlist) + ASSUME(invlist) /* PERL_CALLCONV void _invlist_subtract(pTHX_ SV * const a, SV * const b, SV **result); */ @@ -6880,28 +7026,28 @@ _invlist_subtract(pTHX_ SV * const a, SV * const b, SV **result); */ _invlist_union(pTHX_ SV * const a, SV * const b, SV **output); */ # define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND \ - assert(b); assert(output) + ASSUME(b); ASSUME(output) # define PERL_ARGS_ASSERT__NEW_INVLIST # define PERL_ARGS_ASSERT__SETUP_CANNED_INVLIST \ - assert(other_elements_ptr) + ASSUME(other_elements_ptr) #endif /* defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_UTF8_C) */ #if defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_REGCOMP_C) || \ defined(PERL_IN_TOKE_C) # define PERL_ARGS_ASSERT_FORM_ALIEN_DIGIT_MSG \ - assert(first_bad); assert(send) + ASSUME(first_bad); ASSUME(send) # define PERL_ARGS_ASSERT_GROK_BSLASH_C \ - assert(result); assert(message) + ASSUME(result); ASSUME(message) # define PERL_ARGS_ASSERT_GROK_BSLASH_O \ - assert(s); assert(send); assert(uv); assert(message) + ASSUME(s); ASSUME(send); ASSUME(uv); ASSUME(message) # define PERL_ARGS_ASSERT_GROK_BSLASH_X \ - assert(s); assert(send); assert(uv); assert(message) + ASSUME(s); ASSUME(send); ASSUME(uv); ASSUME(message) #endif /* defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) */ @@ -6918,17 +7064,17 @@ S_deb_curcv(pTHX_ I32 ix); STATIC void S_debprof(pTHX_ const OP *o); # define PERL_ARGS_ASSERT_DEBPROF \ - assert(o) + ASSUME(o) STATIC SV * S_pm_description(pTHX_ const PMOP *pm); # define PERL_ARGS_ASSERT_PM_DESCRIPTION \ - assert(pm) + ASSUME(pm) STATIC char * S_pv_display_flags(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim, I32 pretty_flags); # define PERL_ARGS_ASSERT_PV_DISPLAY_FLAGS \ - assert(dsv); assert(pv) + ASSUME(dsv); ASSUME(pv) STATIC UV S_sequence_num(pTHX_ const OP *o); @@ -6941,67 +7087,67 @@ PERL_CALLCONV void Perl_hv_kill_backrefs(pTHX_ HV *hv) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_HV_KILL_BACKREFS \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) #endif #if defined(PERL_IN_DUMP_C) || defined(PERL_IN_OP_C) || \ defined(PERL_IN_REGCOMP_ANY) # define PERL_ARGS_ASSERT__INVLIST_DUMP \ - assert(file); assert(indent); assert(invlist) + ASSUME(file); ASSUME(indent); ASSUME(invlist) #endif #if defined(PERL_IN_GV_C) STATIC bool S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len, const U32 is_utf8, const I32 add, const svtype sv_type); # define PERL_ARGS_ASSERT_FIND_DEFAULT_STASH \ - assert(stash); assert(name) + ASSUME(stash); ASSUME(name) STATIC void S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type); # define PERL_ARGS_ASSERT_GV_INIT_SVTYPE \ - assert(gv) + ASSUME(gv) STATIC bool S_gv_is_in_main(pTHX_ const char *name, STRLEN len, const U32 is_utf8); # define PERL_ARGS_ASSERT_GV_IS_IN_MAIN \ - assert(name) + ASSUME(name) STATIC bool S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, const svtype sv_type); # define PERL_ARGS_ASSERT_GV_MAGICALIZE \ - assert(gv); assert(stash); assert(SvTYPE(stash) == SVt_PVHV); \ - assert(name) + ASSUME(gv); ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV); \ + ASSUME(name) STATIC void S_gv_magicalize_isa(pTHX_ GV *gv); # define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA \ - assert(gv) + ASSUME(gv) STATIC void S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type); # define PERL_ARGS_ASSERT_MAYBE_MULTIMAGIC_GV \ - assert(gv); assert(name) + ASSUME(gv); ASSUME(name) STATIC bool S_parse_gv_stash_name(pTHX_ HV **stash, GV **gv, const char **name, STRLEN *len, const char *nambeg, STRLEN full_len, const U32 is_utf8, const I32 add); # define PERL_ARGS_ASSERT_PARSE_GV_STASH_NAME \ - assert(stash); assert(gv); assert(name); assert(len); assert(nambeg) + ASSUME(stash); ASSUME(gv); ASSUME(name); ASSUME(len); ASSUME(nambeg) STATIC void S_require_tie_mod(pTHX_ GV *gv, const char varname, const char *name, STRLEN len, const U32 flags); # define PERL_ARGS_ASSERT_REQUIRE_TIE_MOD \ - assert(gv); assert(varname); assert(name) + ASSUME(gv); ASSUME(varname); ASSUME(name) # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE GV * S_gv_fetchmeth_internal(pTHX_ HV *stash, SV *meth, const char *name, STRLEN len, I32 level, U32 flags); # define PERL_ARGS_ASSERT_GV_FETCHMETH_INTERNAL \ - assert(!stash || SvTYPE(stash) == SVt_PVHV) + ASSUME(!stash || SvTYPE(stash) == SVt_PVHV) PERL_STATIC_INLINE HV * S_gv_stashpvn_internal(pTHX_ const char *name, U32 namelen, I32 flags); # define PERL_ARGS_ASSERT_GV_STASHPVN_INTERNAL \ - assert(name) + ASSUME(name) # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ #endif /* defined(PERL_IN_GV_C) */ @@ -7011,7 +7157,7 @@ PERL_CALLCONV void Perl_sv_add_backref(pTHX_ SV * const tsv, SV * const sv) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_SV_ADD_BACKREF \ - assert(tsv); assert(sv) + ASSUME(tsv); ASSUME(sv) #endif #if defined(PERL_IN_GV_C) || defined(PERL_IN_UNIVERSAL_C) @@ -7028,62 +7174,66 @@ Perl_gv_stashsvpvn_cached(pTHX_ SV *namesv, const char *name, U32 namelen, I32 f STATIC void S_clear_placeholders(pTHX_ HV *hv, U32 items); # define PERL_ARGS_ASSERT_CLEAR_PLACEHOLDERS \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) STATIC void S_hsplit(pTHX_ HV *hv, STRLEN const oldsize, STRLEN newsize); # define PERL_ARGS_ASSERT_HSPLIT \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) STATIC struct xpvhv_aux * S_hv_auxinit(pTHX_ HV *hv); # define PERL_ARGS_ASSERT_HV_AUXINIT \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) STATIC SV * S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash); # define PERL_ARGS_ASSERT_HV_DELETE_COMMON \ - assert(!hv || SvTYPE(hv) == SVt_PVHV) + ASSUME(!hv || SvTYPE(hv) == SVt_PVHV) STATIC SV * S_hv_free_ent_ret(pTHX_ HE *entry); # define PERL_ARGS_ASSERT_HV_FREE_ENT_RET \ - assert(entry) + ASSUME(entry) STATIC void S_hv_free_entries(pTHX_ HV *hv); # define PERL_ARGS_ASSERT_HV_FREE_ENTRIES \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) STATIC void -S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store); +S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store) + __attribute__nonnull__(1) + __attribute__nonnull__(2) + __attribute__nonnull__(3); # define PERL_ARGS_ASSERT_HV_MAGIC_CHECK \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(needs_copy); \ - assert(needs_store) + PERL_ASSUME_NON_NULL(hv); ASSUME(SvTYPE(hv) == SVt_PVHV); \ + PERL_ASSUME_NON_NULL(needs_copy); PERL_ASSUME_NON_NULL(needs_store) PERL_STATIC_NO_RET void S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg) __attribute__noreturn__; # define PERL_ARGS_ASSERT_HV_NOTALLOWED \ - assert(key); assert(msg) + ASSUME(key); ASSUME(msg) STATIC SV * S_refcounted_he_value(pTHX_ const struct refcounted_he *he); # define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE \ - assert(he) + ASSUME(he) STATIC HEK * S_save_hek_flags(const char *str, I32 len, U32 hash, int flags) + __attribute__nonnull__(1) __attribute__malloc__ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SAVE_HEK_FLAGS \ - assert(str) + PERL_ASSUME_NON_NULL(str) STATIC HEK * S_share_hek_flags(pTHX_ const char *str, STRLEN len, U32 hash, int flags) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SHARE_HEK_FLAGS \ - assert(str) + ASSUME(str) STATIC void S_unshare_hek_or_pvn(pTHX_ const HEK *hek, const char *str, I32 len, U32 hash); @@ -7102,7 +7252,7 @@ PERL_CALLCONV void Perl_sv_kill_backrefs(pTHX_ SV * const sv, AV * const av) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_SV_KILL_BACKREFS \ - assert(sv) + ASSUME(sv) #endif #if defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) @@ -7110,7 +7260,7 @@ PERL_CALLCONV SV * Perl_hfree_next_entry(pTHX_ HV *hv, STRLEN *indexp) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_HFREE_NEXT_ENTRY \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(indexp) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV); ASSUME(indexp) #endif #if defined(PERL_IN_LOCALE_C) @@ -7121,12 +7271,12 @@ S_get_locale_string_utf8ness_i(pTHX_ const char *string, const locale_utf8ness_t STATIC void S_ints_to_tm(pTHX_ struct tm *my_tm, const char *locale, int sec, int min, int hour, int mday, int mon, int year, int isdst); # define PERL_ARGS_ASSERT_INTS_TO_TM \ - assert(my_tm); assert(locale) + ASSUME(my_tm); ASSUME(locale) STATIC bool S_is_locale_utf8(pTHX_ const char *locale); # define PERL_ARGS_ASSERT_IS_LOCALE_UTF8 \ - assert(locale) + ASSUME(locale) STATIC HV * S_my_localeconv(pTHX_ const int item); @@ -7135,31 +7285,31 @@ S_my_localeconv(pTHX_ const int item); STATIC void S_populate_hash_from_C_localeconv(pTHX_ HV *hv, const char *locale, const U32 which_mask, const lconv_offset_t *strings[2], const lconv_offset_t *integers[2]); # define PERL_ARGS_ASSERT_POPULATE_HASH_FROM_C_LOCALECONV \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(locale); \ - assert(strings); assert(integers) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV); ASSUME(locale); \ + ASSUME(strings); ASSUME(integers) STATIC bool S_strftime8(pTHX_ const char *fmt, SV *sv, const char *locale, const struct tm *mytm, const utf8ness_t fmt_utf8ness, utf8ness_t *result_utf8ness, const bool called_externally); # define PERL_ARGS_ASSERT_STRFTIME8 \ - assert(fmt); assert(sv); assert(locale); assert(mytm); \ - assert(result_utf8ness) + ASSUME(fmt); ASSUME(sv); ASSUME(locale); ASSUME(mytm); \ + ASSUME(result_utf8ness) STATIC bool S_strftime_tm(pTHX_ const char *fmt, SV *sv, const char *locale, const struct tm *mytm) __attribute__format__(__strftime__,pTHX_1,0); # define PERL_ARGS_ASSERT_STRFTIME_TM \ - assert(fmt); assert(sv); assert(locale); assert(mytm) + ASSUME(fmt); ASSUME(sv); ASSUME(locale); ASSUME(mytm) STATIC SV * S_sv_strftime_common(pTHX_ SV *fmt, const char *locale, const struct tm *mytm); # define PERL_ARGS_ASSERT_SV_STRFTIME_COMMON \ - assert(fmt); assert(locale); assert(mytm) + ASSUME(fmt); ASSUME(locale); ASSUME(mytm) # if defined(HAS_MISSING_LANGINFO_ITEM_) || !defined(HAS_NL_LANGINFO) STATIC const char * S_emulate_langinfo(pTHX_ const PERL_INTMAX_T item, const char *locale, SV *sv, utf8ness_t *utf8ness); # define PERL_ARGS_ASSERT_EMULATE_LANGINFO \ - assert(locale); assert(sv) + ASSUME(locale); ASSUME(sv) # endif # if defined(USE_LOCALE) @@ -7170,7 +7320,7 @@ S_calculate_LC_ALL_string(pTHX_ const char **category_locales_list, const calc_L STATIC const char * S_external_call_langinfo(pTHX_ const nl_item item, SV *sv, utf8ness_t *utf8ness); # define PERL_ARGS_ASSERT_EXTERNAL_CALL_LANGINFO \ - assert(sv) + ASSUME(sv) STATIC locale_category_index S_get_category_index_helper(pTHX_ const int category, bool *success, const line_t caller_line) @@ -7184,7 +7334,7 @@ S_native_querylocale_i(pTHX_ const locale_category_index cat_index); STATIC void S_new_LC_ALL(pTHX_ const char *lc_all, bool force); # define PERL_ARGS_ASSERT_NEW_LC_ALL \ - assert(lc_all) + ASSUME(lc_all) STATIC void S_output_check_environment_warning(pTHX_ const char * const language, const char * const lc_all, const char * const lang); @@ -7193,7 +7343,7 @@ S_output_check_environment_warning(pTHX_ const char * const language, const char STATIC parse_LC_ALL_string_return S_parse_LC_ALL_string(pTHX_ const char *string, const char **output, const parse_LC_ALL_STRING_action, bool always_use_full_array, const bool panic_on_error, const line_t caller_line); # define PERL_ARGS_ASSERT_PARSE_LC_ALL_STRING \ - assert(string); assert(output) + ASSUME(string); ASSUME(output) STATIC void S_restore_toggled_locale_i(pTHX_ const locale_category_index cat_index, const char *original_locale, const line_t caller_line); @@ -7211,12 +7361,12 @@ PERL_STATIC_NO_RET void S_setlocale_failure_panic_via_i(pTHX_ const locale_category_index cat_index, const char *current, const char *failed, const line_t proxy_caller_line, const line_t immediate_caller_line, const char *higher_caller_file, const line_t higher_caller_line) __attribute__noreturn__; # define PERL_ARGS_ASSERT_SETLOCALE_FAILURE_PANIC_VIA_I \ - assert(failed); assert(higher_caller_file) + ASSUME(failed); ASSUME(higher_caller_file) STATIC const char * S_toggle_locale_i(pTHX_ const locale_category_index cat_index, const char *new_locale, const line_t caller_line); # define PERL_ARGS_ASSERT_TOGGLE_LOCALE_I \ - assert(new_locale) + ASSUME(new_locale) # if defined(DEBUGGING) STATIC char * @@ -7230,28 +7380,28 @@ S_my_setlocale_debug_string_i(pTHX_ const locale_category_index cat_index, const STATIC void S_populate_hash_from_localeconv(pTHX_ HV *hv, const char *locale, const U32 which_mask, const lconv_offset_t *strings[2], const lconv_offset_t *integers[2]); # define PERL_ARGS_ASSERT_POPULATE_HASH_FROM_LOCALECONV \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(locale); \ - assert(strings); assert(integers) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV); ASSUME(locale); \ + ASSUME(strings); ASSUME(integers) # endif # if defined(HAS_NL_LANGINFO) STATIC const char * S_langinfo_sv_i(pTHX_ const nl_item item, locale_category_index cat_index, const char *locale, SV *sv, utf8ness_t *utf8ness); # define PERL_ARGS_ASSERT_LANGINFO_SV_I \ - assert(locale); assert(sv) + ASSUME(locale); ASSUME(sv) # endif # if defined(LC_ALL) STATIC void S_give_perl_locale_control(pTHX_ const char *lc_all_string, const line_t caller_line); # define PERL_ARGS_ASSERT_GIVE_PERL_LOCALE_CONTROL \ - assert(lc_all_string) + ASSUME(lc_all_string) # else STATIC void S_give_perl_locale_control(pTHX_ const char **curlocales, const line_t caller_line); # define PERL_ARGS_ASSERT_GIVE_PERL_LOCALE_CONTROL \ - assert(curlocales) + ASSUME(curlocales) # endif # if !defined(PERL_NO_INLINE_FUNCTIONS) @@ -7265,33 +7415,34 @@ S_mortalized_pv_copy(pTHX_ const char * const pv) STATIC void S_new_collate(pTHX_ const char *newcoll, bool force); # define PERL_ARGS_ASSERT_NEW_COLLATE \ - assert(newcoll) + ASSUME(newcoll) # if defined(DEBUGGING) STATIC void S_print_collxfrm_input_and_return(pTHX_ const char *s, const char *e, const char *xbuf, const STRLEN xlen, const bool is_utf8); # define PERL_ARGS_ASSERT_PRINT_COLLXFRM_INPUT_AND_RETURN \ - assert(s); assert(e) + ASSUME(s); ASSUME(e) # endif # endif /* defined(USE_LOCALE_COLLATE) */ # if defined(USE_LOCALE_CTYPE) STATIC bool -S_is_codeset_name_UTF8(const char *name); +S_is_codeset_name_UTF8(const char *name) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_IS_CODESET_NAME_UTF8 \ - assert(name) + PERL_ASSUME_NON_NULL(name) STATIC void S_new_ctype(pTHX_ const char *newctype, bool force); # define PERL_ARGS_ASSERT_NEW_CTYPE \ - assert(newctype) + ASSUME(newctype) # endif /* defined(USE_LOCALE_CTYPE) */ # if defined(USE_LOCALE_NUMERIC) STATIC void S_new_numeric(pTHX_ const char *newnum, bool force); # define PERL_ARGS_ASSERT_NEW_NUMERIC \ - assert(newnum) + ASSUME(newnum) # endif # if defined(USE_PERL_SWITCH_LOCALE_CONTEXT) || defined(DEBUGGING) @@ -7304,7 +7455,7 @@ S_get_LC_ALL_display(pTHX); STATIC bool S_bool_setlocale_2008_i(pTHX_ const locale_category_index index, const char *new_locale, const line_t caller_line); # define PERL_ARGS_ASSERT_BOOL_SETLOCALE_2008_I \ - assert(new_locale) + ASSUME(new_locale) STATIC const char * S_querylocale_2008_i(pTHX_ const locale_category_index index, const line_t line); @@ -7318,7 +7469,7 @@ S_use_curlocale_scratch(pTHX); STATIC void S_update_PL_curlocales_i(pTHX_ const locale_category_index index, const char *new_locale, const line_t caller_line); # define PERL_ARGS_ASSERT_UPDATE_PL_CURLOCALES_I \ - assert(new_locale) + ASSUME(new_locale) # endif # elif defined(USE_LOCALE_THREADS) && \ @@ -7328,7 +7479,7 @@ S_update_PL_curlocales_i(pTHX_ const locale_category_index index, const char *ne STATIC bool S_less_dicey_bool_setlocale_r(pTHX_ const int cat, const char *locale); # define PERL_ARGS_ASSERT_LESS_DICEY_BOOL_SETLOCALE_R \ - assert(locale) + ASSUME(locale) STATIC const char * S_less_dicey_setlocale_r(pTHX_ const int category, const char *locale); @@ -7368,32 +7519,33 @@ S_find_locale_from_environment(pTHX_ const locale_category_index index); STATIC const char * S_get_displayable_string(pTHX_ const char * const s, const char * const e, const bool is_utf8); # define PERL_ARGS_ASSERT_GET_DISPLAYABLE_STRING \ - assert(s); assert(e) + ASSUME(s); ASSUME(e) # endif #endif /* defined(PERL_IN_LOCALE_C) */ #if defined(PERL_IN_MALLOC_C) STATIC int -S_adjust_size_and_find_bucket(size_t *nbytes_p); +S_adjust_size_and_find_bucket(size_t *nbytes_p) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_ADJUST_SIZE_AND_FIND_BUCKET \ - assert(nbytes_p) + PERL_ASSUME_NON_NULL(nbytes_p) #endif #if defined(PERL_IN_MG_C) STATIC void S_fixup_errno_string(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_FIXUP_ERRNO_STRING \ - assert(sv) + ASSUME(sv) STATIC SV * S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, int n, SV *val); # define PERL_ARGS_ASSERT_MAGIC_METHCALL1 \ - assert(sv); assert(mg); assert(meth) + ASSUME(sv); ASSUME(mg); ASSUME(meth) STATIC int S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth); # define PERL_ARGS_ASSERT_MAGIC_METHPACK \ - assert(sv); assert(mg); assert(meth) + ASSUME(sv); ASSUME(mg); ASSUME(meth) STATIC void S_restore_magic(pTHX_ void *p); @@ -7402,7 +7554,7 @@ S_restore_magic(pTHX_ void *p); STATIC void S_save_magic_flags(pTHX_ SSize_t mgs_ix, SV *sv, U32 flags); # define PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS \ - assert(sv) + ASSUME(sv) STATIC void S_unwind_handler_stack(pTHX_ void *p); @@ -7412,30 +7564,32 @@ S_unwind_handler_stack(pTHX_ void *p); #if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C) PERL_CALLCONV bool Perl_translate_substr_offsets(STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp) + __attribute__nonnull__(6) + __attribute__nonnull__(7) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_TRANSLATE_SUBSTR_OFFSETS \ - assert(posp); assert(lenp) + PERL_ASSUME_NON_NULL(posp); PERL_ASSUME_NON_NULL(lenp) -#endif +#endif /* defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C) */ #if defined(PERL_IN_MRO_C) STATIC void S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN len, HV * const exceptions, U32 hash, U32 flags); # define PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV \ - assert(isa); assert(SvTYPE(isa) == SVt_PVHV); assert(name); \ - assert(!exceptions || SvTYPE(exceptions) == SVt_PVHV) + ASSUME(isa); ASSUME(SvTYPE(isa) == SVt_PVHV); ASSUME(name); \ + ASSUME(!exceptions || SvTYPE(exceptions) == SVt_PVHV) STATIC void S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes, HV *stash, HV *oldstash, SV *namesv); # define PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME \ - assert(stashes); assert(SvTYPE(stashes) == SVt_PVHV); \ - assert(seen_stashes); assert(SvTYPE(seen_stashes) == SVt_PVHV); \ - assert(!stash || SvTYPE(stash) == SVt_PVHV); \ - assert(!oldstash || SvTYPE(oldstash) == SVt_PVHV); assert(namesv) + ASSUME(stashes); ASSUME(SvTYPE(stashes) == SVt_PVHV); \ + ASSUME(seen_stashes); ASSUME(SvTYPE(seen_stashes) == SVt_PVHV); \ + ASSUME(!stash || SvTYPE(stash) == SVt_PVHV); \ + ASSUME(!oldstash || SvTYPE(oldstash) == SVt_PVHV); ASSUME(namesv) STATIC AV * S_mro_get_linear_isa_dfs(pTHX_ HV *stash, U32 level); # define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV) #endif /* defined(PERL_IN_MRO_C) */ #if defined(PERL_IN_NUMERIC_C) @@ -7448,13 +7602,13 @@ S_output_non_portable(pTHX_ const U8 shift); STATIC void S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs); # define PERL_ARGS_ASSERT_APPLY_ATTRS \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV); assert(target) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV); ASSUME(target) STATIC void S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp); # define PERL_ARGS_ASSERT_APPLY_ATTRS_MY \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV); assert(target); \ - assert(imopsp) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV); ASSUME(target); \ + ASSUME(imopsp) STATIC I32 S_assignment_type(pTHX_ const OP *o) @@ -7464,38 +7618,38 @@ S_assignment_type(pTHX_ const OP *o) STATIC void S_bad_type_gv(pTHX_ I32 n, GV *gv, const OP *kid, const char *t); # define PERL_ARGS_ASSERT_BAD_TYPE_GV \ - assert(gv); assert(kid); assert(t) + ASSUME(gv); ASSUME(kid); ASSUME(t) STATIC void S_bad_type_pv(pTHX_ I32 n, const char *t, const OP *o, const OP *kid); # define PERL_ARGS_ASSERT_BAD_TYPE_PV \ - assert(t); assert(o); assert(kid) + ASSUME(t); ASSUME(o); ASSUME(kid) STATIC void S_clear_special_blocks(pTHX_ const char * const fullname, GV * const gv, CV * const cv); # define PERL_ARGS_ASSERT_CLEAR_SPECIAL_BLOCKS \ - assert(fullname); assert(gv); assert(cv); \ - assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(fullname); ASSUME(gv); ASSUME(cv); \ + ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) STATIC void S_cop_free(pTHX_ COP *cop); # define PERL_ARGS_ASSERT_COP_FREE \ - assert(cop) + ASSUME(cop) STATIC OP * S_dup_attrlist(pTHX_ OP *o); # define PERL_ARGS_ASSERT_DUP_ATTRLIST \ - assert(o) + ASSUME(o) STATIC void S_find_and_forget_pmops(pTHX_ OP *o); # define PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS \ - assert(o) + ASSUME(o) STATIC OP * S_fold_constants(pTHX_ OP * const o); # define PERL_ARGS_ASSERT_FOLD_CONSTANTS \ - assert(o) + ASSUME(o) STATIC OP * S_force_list(pTHX_ OP *arg, bool nullit); @@ -7504,7 +7658,7 @@ S_force_list(pTHX_ OP *arg, bool nullit); STATIC void S_forget_pmop(pTHX_ PMOP * const o); # define PERL_ARGS_ASSERT_FORGET_PMOP \ - assert(o) + ASSUME(o) STATIC void S_gen_constant_list(pTHX_ OP *o); @@ -7513,13 +7667,14 @@ S_gen_constant_list(pTHX_ OP *o); STATIC void S_inplace_aassign(pTHX_ OP *o); # define PERL_ARGS_ASSERT_INPLACE_AASSIGN \ - assert(o) + ASSUME(o) STATIC bool S_is_handle_constructor(const OP *o, I32 numargs) + __attribute__nonnull__(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR \ - assert(o) + PERL_ASSUME_NON_NULL(o) STATIC OP * S_listkids(pTHX_ OP *o); @@ -7528,7 +7683,7 @@ S_listkids(pTHX_ OP *o); STATIC bool S_looks_like_bool(pTHX_ const OP *o); # define PERL_ARGS_ASSERT_LOOKS_LIKE_BOOL \ - assert(o) + ASSUME(o) STATIC OP * S_modkids(pTHX_ OP *o, I32 type); @@ -7537,40 +7692,40 @@ S_modkids(pTHX_ OP *o, I32 type); STATIC void S_move_proto_attr(pTHX_ OP **proto, OP **attrs, const GV *name, bool curstash); # define PERL_ARGS_ASSERT_MOVE_PROTO_ATTR \ - assert(proto); assert(attrs); assert(name) + ASSUME(proto); ASSUME(attrs); ASSUME(name) STATIC OP * S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp); # define PERL_ARGS_ASSERT_MY_KID \ - assert(imopsp) + ASSUME(imopsp) STATIC OP * S_newGIVWHENOP(pTHX_ OP *cond, OP *block, I32 enter_opcode, I32 leave_opcode, PADOFFSET entertarg); # define PERL_ARGS_ASSERT_NEWGIVWHENOP \ - assert(block) + ASSUME(block) STATIC OP * S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NEW_LOGOP \ - assert(firstp); assert(otherp) + ASSUME(firstp); ASSUME(otherp) STATIC OP * S_no_fh_allowed(pTHX_ OP *o) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NO_FH_ALLOWED \ - assert(o) + ASSUME(o) STATIC OP * S_pmtrans(pTHX_ OP *o, OP *expr, OP *repl); # define PERL_ARGS_ASSERT_PMTRANS \ - assert(o); assert(expr); assert(repl) + ASSUME(o); ASSUME(expr); ASSUME(repl) STATIC bool S_process_special_blocks(pTHX_ I32 floor, const char * const fullname, GV * const gv, CV * const cv); # define PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS \ - assert(fullname); assert(gv); assert(cv); \ - assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(fullname); ASSUME(gv); ASSUME(cv); \ + ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) STATIC OP * S_ref_array_or_hash(pTHX_ OP *cond); @@ -7588,7 +7743,7 @@ S_scalar_mod_type(const OP *o, I32 type) STATIC OP * S_scalarboolean(pTHX_ OP *o); # define PERL_ARGS_ASSERT_SCALARBOOLEAN \ - assert(o) + ASSUME(o) STATIC OP * S_scalarkids(pTHX_ OP *o); @@ -7598,23 +7753,23 @@ STATIC OP * S_search_const(pTHX_ OP *o) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SEARCH_CONST \ - assert(o) + ASSUME(o) STATIC void S_simplify_sort(pTHX_ OP *o); # define PERL_ARGS_ASSERT_SIMPLIFY_SORT \ - assert(o) + ASSUME(o) STATIC OP * S_too_few_arguments_pv(pTHX_ OP *o, const char *name, U32 flags) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_PV \ - assert(o); assert(name) + ASSUME(o); ASSUME(name) STATIC OP * S_too_many_arguments_pv(pTHX_ OP *o, const char *name, U32 flags); # define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_PV \ - assert(o); assert(name) + ASSUME(o); ASSUME(name) STATIC OP * S_voidnonfinal(pTHX_ OP *o); @@ -7624,14 +7779,15 @@ S_voidnonfinal(pTHX_ OP *o); STATIC const char * S_get_displayable_tr_operand(pTHX_ const U8 *s, STRLEN len, bool is_utf8); # define PERL_ARGS_ASSERT_GET_DISPLAYABLE_TR_OPERAND \ - assert(s) + ASSUME(s) # endif # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE bool -S_is_standard_filehandle_name(const char *fhname); +S_is_standard_filehandle_name(const char *fhname) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_IS_STANDARD_FILEHANDLE_NAME \ - assert(fhname) + PERL_ASSUME_NON_NULL(fhname) PERL_STATIC_INLINE OP * S_newMETHOP_internal(pTHX_ I32 type, I32 flags, OP *dynamic_meth, SV * const_meth); @@ -7640,17 +7796,19 @@ S_newMETHOP_internal(pTHX_ I32 type, I32 flags, OP *dynamic_meth, SV * const_met PERL_STATIC_INLINE OP * S_op_integerize(pTHX_ OP *o); # define PERL_ARGS_ASSERT_OP_INTEGERIZE \ - assert(o) + ASSUME(o) PERL_STATIC_INLINE OP * S_op_std_init(pTHX_ OP *o); # define PERL_ARGS_ASSERT_OP_STD_INIT \ - assert(o) + ASSUME(o) PERL_STATIC_INLINE U16 -S_opslab_slot_offset(const OPSLAB *slab, const OPSLOT *slot); +S_opslab_slot_offset(const OPSLAB *slab, const OPSLOT *slot) + __attribute__nonnull__(1) + __attribute__nonnull__(2); # define PERL_ARGS_ASSERT_OPSLAB_SLOT_OFFSET \ - assert(slab); assert(slot) + PERL_ASSUME_NON_NULL(slab); PERL_ASSUME_NON_NULL(slot) PERL_STATIC_INLINE U16 S_size_to_psize(size_t size); @@ -7658,6 +7816,9 @@ S_size_to_psize(size_t size); # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ #endif /* defined(PERL_IN_OP_C) */ +#if defined(PERL_IN_OP_C) || defined(PERL_IN_PAD_C) + +#endif #if defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) PERL_CALLCONV void Perl_check_hash_fields_and_hekify(pTHX_ UNOP *rop, SVOP *key_op, int real) @@ -7668,25 +7829,26 @@ PERL_CALLCONV void Perl_no_bareword_allowed(pTHX_ OP *o) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_NO_BAREWORD_ALLOWED \ - assert(o) + ASSUME(o) PERL_CALLCONV void Perl_op_prune_chain_head(OP **op_p) + __attribute__nonnull__(1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OP_PRUNE_CHAIN_HEAD \ - assert(op_p) + PERL_ASSUME_NON_NULL(op_p) PERL_CALLCONV SV * Perl_op_varname(pTHX_ const OP *o) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OP_VARNAME \ - assert(o) + ASSUME(o) PERL_CALLCONV void Perl_warn_elem_scalar_context(pTHX_ const OP *o, SV *name, bool is_hash, bool is_slice) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_WARN_ELEM_SCALAR_CONTEXT \ - assert(o); assert(name) + ASSUME(o); ASSUME(name) #endif /* defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) */ #if defined(PERL_IN_OP_C) || defined(PERL_IN_REGCOMP_ANY) @@ -7697,7 +7859,7 @@ PERL_CALLCONV void Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_cv, SV * const *new_const_svp) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_REPORT_REDEFINED_CV \ - assert(name); assert(old_cv) + ASSUME(name); ASSUME(old_cv) PERL_CALLCONV SV * Perl_varname(pTHX_ const GV * const gv, const char gvtype, PADOFFSET targ, const SV * const keyname, SSize_t aindex, int subscript_type) @@ -7710,17 +7872,17 @@ Perl_varname(pTHX_ const GV * const gv, const char gvtype, PADOFFSET targ, const STATIC PADOFFSET S_pad_alloc_name(pTHX_ PADNAME *name, U32 flags, HV *typestash, HV *ourstash); # define PERL_ARGS_ASSERT_PAD_ALLOC_NAME \ - assert(name); assert(!ourstash || SvTYPE(ourstash) == SVt_PVHV) + ASSUME(name); ASSUME(!ourstash || SvTYPE(ourstash) == SVt_PVHV) STATIC void S_pad_check_dup(pTHX_ PADNAME *name, U32 flags, const HV *ourstash); # define PERL_ARGS_ASSERT_PAD_CHECK_DUP \ - assert(name) + ASSUME(name) STATIC PADOFFSET S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV *cv, U32 seq, int warn, SV **out_capture, PADNAME **out_name, int *out_flags); # define PERL_ARGS_ASSERT_PAD_FINDLEX \ - assert(namepv); assert(cv); assert(out_name); assert(out_flags) + ASSUME(namepv); ASSUME(cv); ASSUME(out_name); ASSUME(out_flags) STATIC void S_pad_reset(pTHX); @@ -7730,7 +7892,7 @@ S_pad_reset(pTHX); STATIC void S_cv_dump(pTHX_ const CV *cv, const char *title); # define PERL_ARGS_ASSERT_CV_DUMP \ - assert(cv); assert(title) + ASSUME(cv); ASSUME(title) # endif #endif /* defined(PERL_IN_PAD_C) */ @@ -7738,24 +7900,24 @@ S_cv_dump(pTHX_ const CV *cv, const char *title); STATIC void S_finalize_op(pTHX_ OP *o); # define PERL_ARGS_ASSERT_FINALIZE_OP \ - assert(o) + ASSUME(o) STATIC void S_optimize_op(pTHX_ OP *o); # define PERL_ARGS_ASSERT_OPTIMIZE_OP \ - assert(o) + ASSUME(o) STATIC OP * S_traverse_op_tree(pTHX_ OP *top, OP *o); # define PERL_ARGS_ASSERT_TRAVERSE_OP_TREE \ - assert(top); assert(o) + ASSUME(top); ASSUME(o) #endif /* defined(PERL_IN_PEEP_C) */ #if defined(PERL_IN_PERL_C) STATIC void S_find_beginning(pTHX_ SV *linestr_sv, PerlIO *rsfp); # define PERL_ARGS_ASSERT_FIND_BEGINNING \ - assert(linestr_sv); assert(rsfp) + ASSUME(linestr_sv); ASSUME(rsfp) STATIC void S_forbid_setid(pTHX_ const char flag, const bool suidscript); @@ -7764,12 +7926,12 @@ S_forbid_setid(pTHX_ const char flag, const bool suidscript); STATIC void S_incpush(pTHX_ const char * const dir, STRLEN len, U32 flags); # define PERL_ARGS_ASSERT_INCPUSH \ - assert(dir) + ASSUME(dir) STATIC void S_incpush_use_sep(pTHX_ const char *p, STRLEN len, U32 flags); # define PERL_ARGS_ASSERT_INCPUSH_USE_SEP \ - assert(p) + ASSUME(p) STATIC void S_init_ids(pTHX); @@ -7790,7 +7952,7 @@ S_init_perllib(pTHX); STATIC void S_init_postdump_symbols(pTHX_ int argc, char **argv, char **env); # define PERL_ARGS_ASSERT_INIT_POSTDUMP_SYMBOLS \ - assert(argv) + ASSUME(argv) STATIC void S_init_predump_symbols(pTHX); @@ -7799,7 +7961,7 @@ S_init_predump_symbols(pTHX); STATIC SV * S_mayberelocate(pTHX_ const char * const dir, STRLEN len, U32 flags); # define PERL_ARGS_ASSERT_MAYBERELOCATE \ - assert(dir) + ASSUME(dir) PERL_STATIC_NO_RET void S_minus_v(pTHX) @@ -7818,7 +7980,7 @@ S_nuke_stacks(pTHX); STATIC PerlIO * S_open_script(pTHX_ const char *scriptname, bool dosearch, bool *suidscript); # define PERL_ARGS_ASSERT_OPEN_SCRIPT \ - assert(scriptname); assert(suidscript) + ASSUME(scriptname); ASSUME(suidscript) STATIC void * S_parse_body(pTHX_ char **env, XSINIT_t xsinit); @@ -7838,31 +8000,31 @@ S_usage(pTHX) STATIC SV * S_incpush_if_exists(pTHX_ AV * const av, SV *dir, SV * const stem); # define PERL_ARGS_ASSERT_INCPUSH_IF_EXISTS \ - assert(av); assert(SvTYPE(av) == SVt_PVAV); assert(dir); assert(stem) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV); ASSUME(dir); ASSUME(stem) # endif # if !defined(SETUID_SCRIPTS_ARE_SECURE_NOW) STATIC void S_validate_suid(pTHX_ PerlIO *rsfp); # define PERL_ARGS_ASSERT_VALIDATE_SUID \ - assert(rsfp) + ASSUME(rsfp) # endif #endif /* defined(PERL_IN_PERL_C) */ #if defined(PERL_IN_PERL_C) || defined(PERL_IN_REGCOMP_ANY) || \ defined(PERL_IN_UTF8_C) # define PERL_ARGS_ASSERT__INVLISTEQ \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) # define PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY \ - assert(list) + ASSUME(list) #endif #if defined(PERL_IN_PP_C) STATIC size_t S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping); # define PERL_ARGS_ASSERT_DO_CHOMP \ - assert(retval); assert(sv) + ASSUME(retval); ASSUME(sv) STATIC OP * S_do_delete_local(pTHX); @@ -7872,7 +8034,7 @@ STATIC SV * S_refto(pTHX_ SV *sv) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_REFTO \ - assert(sv) + ASSUME(sv) #endif /* defined(PERL_IN_PP_C) */ #if defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C) @@ -7881,7 +8043,11 @@ PERL_CALLCONV GV * Perl_softref2xv(pTHX_ SV * const sv, const char * const what, const svtype type) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SOFTREF2XV \ - assert(sv); assert(what) + ASSUME(sv); ASSUME(what) + +#endif +#if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_ANY) || \ + defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C) #endif #if defined(PERL_IN_PP_C) || defined(PERL_IN_UTF8_C) @@ -7889,7 +8055,7 @@ PERL_CALLCONV UV Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_or_s) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT__TO_UPPER_TITLE_LATIN1 \ - assert(p); assert(lenp) + ASSUME(p); ASSUME(lenp) #endif #if defined(PERL_IN_PP_CTL_C) @@ -7897,18 +8063,18 @@ STATIC PerlIO * S_check_type_and_open(pTHX_ SV *name) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_CHECK_TYPE_AND_OPEN \ - assert(name) + ASSUME(name) STATIC void S_destroy_matcher(pTHX_ PMOP *matcher); # define PERL_ARGS_ASSERT_DESTROY_MATCHER \ - assert(matcher) + ASSUME(matcher) STATIC OP * S_do_smartmatch(pTHX_ HV *seen_this, HV *seen_other, const bool copied); # define PERL_ARGS_ASSERT_DO_SMARTMATCH \ - assert(!seen_this || SvTYPE(seen_this) == SVt_PVHV); \ - assert(!seen_other || SvTYPE(seen_other) == SVt_PVHV) + ASSUME(!seen_this || SvTYPE(seen_this) == SVt_PVHV); \ + ASSUME(!seen_other || SvTYPE(seen_other) == SVt_PVHV) STATIC OP * S_docatch(pTHX_ Perl_ppaddr_t firstpp) @@ -7918,19 +8084,19 @@ S_docatch(pTHX_ Perl_ppaddr_t firstpp) STATIC bool S_doeval_compile(pTHX_ U8 gimme, CV *outside, U32 seq, HV *hh); # define PERL_ARGS_ASSERT_DOEVAL_COMPILE \ - assert(!outside || SvTYPE(outside) == SVt_PVCV || SvTYPE(outside) == SVt_PVFM); \ - assert(!hh || SvTYPE(hh) == SVt_PVHV) + ASSUME(!outside || SvTYPE(outside) == SVt_PVCV || SvTYPE(outside) == SVt_PVFM); \ + ASSUME(!hh || SvTYPE(hh) == SVt_PVHV) STATIC OP * S_dofindlabel(pTHX_ OP *o, const char *label, STRLEN len, U32 flags, OP **opstack, OP **oplimit) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOFINDLABEL \ - assert(o); assert(label); assert(opstack); assert(oplimit) + ASSUME(o); ASSUME(label); ASSUME(opstack); ASSUME(oplimit) STATIC MAGIC * S_doparseform(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_DOPARSEFORM \ - assert(sv) + ASSUME(sv) STATIC I32 S_dopoptoeval(pTHX_ I32 startingblock) @@ -7946,7 +8112,7 @@ STATIC I32 S_dopoptolabel(pTHX_ const char *label, STRLEN len, U32 flags) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOPOPTOLABEL \ - assert(label) + ASSUME(label) STATIC I32 S_dopoptoloop(pTHX_ I32 startingblock) @@ -7957,7 +8123,7 @@ STATIC I32 S_dopoptosub_at(pTHX_ const PERL_CONTEXT *cxstk, I32 startingblock) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOPOPTOSUB_AT \ - assert(cxstk) + ASSUME(cxstk) STATIC I32 S_dopoptowhen(pTHX_ I32 startingblock) @@ -7968,13 +8134,13 @@ STATIC PMOP * S_make_matcher(pTHX_ REGEXP *re) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_MAKE_MATCHER \ - assert(re) + ASSUME(re) STATIC bool S_matcher_matches_sv(pTHX_ PMOP *matcher, SV *sv) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_MATCHER_MATCHES_SV \ - assert(matcher); assert(sv) + ASSUME(matcher); ASSUME(sv) STATIC bool S_num_overflow(NV value, I32 fldsize, I32 frcsize) @@ -7985,37 +8151,38 @@ STATIC I32 S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_RUN_USER_FILTER \ - assert(buf_sv) + ASSUME(buf_sv) STATIC void S_rxres_free(pTHX_ void **rsp); # define PERL_ARGS_ASSERT_RXRES_FREE \ - assert(rsp) + ASSUME(rsp) STATIC void S_rxres_restore(pTHX_ void **rsp, REGEXP *rx); # define PERL_ARGS_ASSERT_RXRES_RESTORE \ - assert(rsp); assert(rx) + ASSUME(rsp); ASSUME(rx) STATIC void S_save_lines(pTHX_ AV *array, SV *sv); # define PERL_ARGS_ASSERT_SAVE_LINES \ - assert(!array || SvTYPE(array) == SVt_PVAV); assert(sv) + ASSUME(!array || SvTYPE(array) == SVt_PVAV); ASSUME(sv) # if !defined(PERL_DISABLE_PMC) STATIC PerlIO * S_doopen_pm(pTHX_ SV *name) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOOPEN_PM \ - assert(name) + ASSUME(name) # endif # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE bool S_path_is_searchable(const char *name) + __attribute__nonnull__(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_PATH_IS_SEARCHABLE \ - assert(name) + PERL_ASSUME_NON_NULL(name) # endif #endif /* defined(PERL_IN_PP_CTL_C) */ @@ -8030,20 +8197,20 @@ Perl_invoke_exception_hook(pTHX_ SV *ex, bool warn) STATIC void S_do_oddball(pTHX_ SV **oddkey, SV **firstkey); # define PERL_ARGS_ASSERT_DO_ODDBALL \ - assert(oddkey); assert(firstkey) + ASSUME(oddkey); ASSUME(firstkey) # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE HV * S_opmethod_stash(pTHX_ SV *meth); # define PERL_ARGS_ASSERT_OPMETHOD_STASH \ - assert(meth) + ASSUME(meth) PERL_STATIC_FORCE_INLINE bool S_should_we_output_Debug_r(pTHX_ regexp *prog) __attribute__warn_unused_result__ __attribute__always_inline__; # define PERL_ARGS_ASSERT_SHOULD_WE_OUTPUT_DEBUG_R \ - assert(prog) + ASSUME(prog) # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ #endif /* defined(PERL_IN_PP_HOT_C) */ @@ -8051,166 +8218,172 @@ S_should_we_output_Debug_r(pTHX_ regexp *prog) STATIC int S_div128(pTHX_ SV *pnum, bool *done); # define PERL_ARGS_ASSERT_DIV128 \ - assert(pnum); assert(done) + ASSUME(pnum); ASSUME(done) STATIC char -S_first_symbol(const char *pat, const char *patend); +S_first_symbol(const char *pat, const char *patend) + __attribute__nonnull__(1) + __attribute__nonnull__(2); # define PERL_ARGS_ASSERT_FIRST_SYMBOL \ - assert(pat); assert(patend) + PERL_ASSUME_NON_NULL(pat); PERL_ASSUME_NON_NULL(patend) STATIC const char * S_get_num(pTHX_ const char *patptr, SSize_t *lenptr) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_GET_NUM \ - assert(patptr); assert(lenptr) + ASSUME(patptr); ASSUME(lenptr) STATIC const char * S_group_end(pTHX_ const char *patptr, const char *patend, char ender); # define PERL_ARGS_ASSERT_GROUP_END \ - assert(patptr); assert(patend) + ASSUME(patptr); ASSUME(patend) STATIC SV * S_is_an_int(pTHX_ const char *s, STRLEN l) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_AN_INT \ - assert(s) + ASSUME(s) STATIC SSize_t S_measure_struct(pTHX_ struct tempsym *symptr); # define PERL_ARGS_ASSERT_MEASURE_STRUCT \ - assert(symptr) + ASSUME(symptr) STATIC SV * S_mul128(pTHX_ SV *sv, U8 m); # define PERL_ARGS_ASSERT_MUL128 \ - assert(sv) + ASSUME(sv) STATIC char * S_my_bytes_to_utf8(const U8 *start, STRLEN len, char *dest, const bool needs_swap) + __attribute__nonnull__(1) + __attribute__nonnull__(3) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_MY_BYTES_TO_UTF8 \ - assert(start); assert(dest) + PERL_ASSUME_NON_NULL(start); PERL_ASSUME_NON_NULL(dest) STATIC bool -S_need_utf8(const char *pat, const char *patend); +S_need_utf8(const char *pat, const char *patend) + __attribute__nonnull__(1) + __attribute__nonnull__(2); # define PERL_ARGS_ASSERT_NEED_UTF8 \ - assert(pat); assert(patend) + PERL_ASSUME_NON_NULL(pat); PERL_ASSUME_NON_NULL(patend) STATIC bool S_next_symbol(pTHX_ struct tempsym *symptr); # define PERL_ARGS_ASSERT_NEXT_SYMBOL \ - assert(symptr) + ASSUME(symptr) STATIC SV ** S_pack_rec(pTHX_ SV *cat, struct tempsym *symptr, SV **beglist, SV **endlist); # define PERL_ARGS_ASSERT_PACK_REC \ - assert(cat); assert(symptr); assert(beglist); assert(endlist) + ASSUME(cat); ASSUME(symptr); ASSUME(beglist); ASSUME(endlist) STATIC char * S_sv_exp_grow(pTHX_ SV *sv, STRLEN needed) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SV_EXP_GROW \ - assert(sv) + ASSUME(sv) STATIC SSize_t S_unpack_rec(pTHX_ struct tempsym *symptr, const char *s, const char *strbeg, const char *strend, const char **new_s); # define PERL_ARGS_ASSERT_UNPACK_REC \ - assert(symptr); assert(s); assert(strbeg); assert(strend) + ASSUME(symptr); ASSUME(s); ASSUME(strbeg); ASSUME(strend) #endif /* defined(PERL_IN_PP_PACK_C) */ #if defined(PERL_IN_PP_SORT_C) STATIC I32 S_sortcv(pTHX_ SV * const a, SV * const b); # define PERL_ARGS_ASSERT_SORTCV \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) STATIC I32 S_sortcv_stacked(pTHX_ SV * const a, SV * const b); # define PERL_ARGS_ASSERT_SORTCV_STACKED \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) STATIC I32 S_sortcv_xsub(pTHX_ SV * const a, SV * const b); # define PERL_ARGS_ASSERT_SORTCV_XSUB \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE I32 S_amagic_cmp(pTHX_ SV * const str1, SV * const str2); # define PERL_ARGS_ASSERT_AMAGIC_CMP \ - assert(str1); assert(str2) + ASSUME(str1); ASSUME(str2) PERL_STATIC_INLINE I32 S_amagic_cmp_desc(pTHX_ SV * const str1, SV * const str2); # define PERL_ARGS_ASSERT_AMAGIC_CMP_DESC \ - assert(str1); assert(str2) + ASSUME(str1); ASSUME(str2) PERL_STATIC_INLINE I32 S_amagic_i_ncmp(pTHX_ SV * const a, SV * const b); # define PERL_ARGS_ASSERT_AMAGIC_I_NCMP \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) PERL_STATIC_INLINE I32 S_amagic_i_ncmp_desc(pTHX_ SV * const a, SV * const b); # define PERL_ARGS_ASSERT_AMAGIC_I_NCMP_DESC \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) PERL_STATIC_INLINE I32 S_amagic_ncmp(pTHX_ SV * const a, SV * const b); # define PERL_ARGS_ASSERT_AMAGIC_NCMP \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) PERL_STATIC_INLINE I32 S_amagic_ncmp_desc(pTHX_ SV * const a, SV * const b); # define PERL_ARGS_ASSERT_AMAGIC_NCMP_DESC \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) PERL_STATIC_INLINE I32 S_cmp_desc(pTHX_ SV * const str1, SV * const str2); # define PERL_ARGS_ASSERT_CMP_DESC \ - assert(str1); assert(str2) + ASSUME(str1); ASSUME(str2) PERL_STATIC_FORCE_INLINE void S_sortsv_flags_impl(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp, U32 flags) __attribute__always_inline__; # define PERL_ARGS_ASSERT_SORTSV_FLAGS_IMPL \ - assert(cmp) + ASSUME(cmp) PERL_STATIC_INLINE I32 S_sv_i_ncmp(pTHX_ SV * const a, SV * const b); # define PERL_ARGS_ASSERT_SV_I_NCMP \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) PERL_STATIC_INLINE I32 S_sv_i_ncmp_desc(pTHX_ SV * const a, SV * const b); # define PERL_ARGS_ASSERT_SV_I_NCMP_DESC \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) PERL_STATIC_INLINE I32 S_sv_ncmp(pTHX_ SV * const a, SV * const b); # define PERL_ARGS_ASSERT_SV_NCMP \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) PERL_STATIC_INLINE I32 S_sv_ncmp_desc(pTHX_ SV * const a, SV * const b); # define PERL_ARGS_ASSERT_SV_NCMP_DESC \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) # if defined(USE_LOCALE_COLLATE) PERL_STATIC_INLINE I32 S_amagic_cmp_locale(pTHX_ SV * const str1, SV * const str2); # define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \ - assert(str1); assert(str2) + ASSUME(str1); ASSUME(str2) PERL_STATIC_INLINE I32 S_amagic_cmp_locale_desc(pTHX_ SV * const str1, SV * const str2); # define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE_DESC \ - assert(str1); assert(str2) + ASSUME(str1); ASSUME(str2) PERL_STATIC_INLINE I32 S_cmp_locale_desc(pTHX_ SV * const str1, SV * const str2); # define PERL_ARGS_ASSERT_CMP_LOCALE_DESC \ - assert(str1); assert(str2) + ASSUME(str1); ASSUME(str2) # endif /* defined(USE_LOCALE_COLLATE) */ # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ @@ -8219,8 +8392,8 @@ S_cmp_locale_desc(pTHX_ SV * const str1, SV * const str2); STATIC OP * S_doform(pTHX_ CV *cv, GV *gv, OP *retop); # define PERL_ARGS_ASSERT_DOFORM \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ - assert(gv) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); \ + ASSUME(gv) STATIC SV * S_space_join_names_mortal(pTHX_ char * const *array); @@ -8229,56 +8402,56 @@ S_space_join_names_mortal(pTHX_ char * const *array); STATIC void S_warn_not_dirhandle(pTHX_ GV *gv); # define PERL_ARGS_ASSERT_WARN_NOT_DIRHANDLE \ - assert(gv) + ASSUME(gv) # if !defined(HAS_MKDIR) || !defined(HAS_RMDIR) STATIC int S_dooneliner(pTHX_ const char *cmd, const char *filename) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOONELINER \ - assert(cmd); assert(filename) + ASSUME(cmd); ASSUME(filename) # endif #endif /* defined(PERL_IN_PP_SYS_C) */ #if defined(PERL_IN_REGCOMP_ANY) # define PERL_ARGS_ASSERT_ADD_ABOVE_LATIN1_FOLDS \ - assert(pRExC_state); assert(invlist) + ASSUME(pRExC_state); ASSUME(invlist) # define PERL_ARGS_ASSERT_CONSTRUCT_AHOCORASICK_FROM_TRIE \ - assert(pRExC_state); assert(source) + ASSUME(pRExC_state); ASSUME(source) # define PERL_ARGS_ASSERT_GET_ANYOFHBBM_CONTENTS \ - assert(n) + ASSUME(n) # define PERL_ARGS_ASSERT_GET_ANYOFM_CONTENTS \ - assert(n) + ASSUME(n) # define PERL_ARGS_ASSERT_JOIN_EXACT \ - assert(pRExC_state); assert(scan); assert(min_subtract); \ - assert(unfolded_multi_char) + ASSUME(pRExC_state); ASSUME(scan); ASSUME(min_subtract); \ + ASSUME(unfolded_multi_char) # define PERL_ARGS_ASSERT_MAKE_TRIE \ - assert(pRExC_state); assert(startbranch); assert(first); assert(last); \ - assert(tail) + ASSUME(pRExC_state); ASSUME(startbranch); ASSUME(first); ASSUME(last); \ + ASSUME(tail) # define PERL_ARGS_ASSERT_POPULATE_ANYOF_BITMAP_FROM_INVLIST \ - assert(node); assert(invlist_ptr) + ASSUME(node); ASSUME(invlist_ptr) # define PERL_ARGS_ASSERT_REG_ADD_DATA \ - assert(pRExC_state); assert(s) + PERL_ASSUME_NON_NULL(pRExC_state); PERL_ASSUME_NON_NULL(s) # define PERL_ARGS_ASSERT_SCAN_COMMIT \ - assert(pRExC_state); assert(data); assert(minlenp) + ASSUME(pRExC_state); ASSUME(data); ASSUME(minlenp) # define PERL_ARGS_ASSERT_SET_ANYOF_ARG \ - assert(pRExC_state); assert(node) + ASSUME(pRExC_state); ASSUME(node) # define PERL_ARGS_ASSERT_SSC_INIT \ - assert(pRExC_state); assert(ssc) + ASSUME(pRExC_state); ASSUME(ssc) # define PERL_ARGS_ASSERT_STUDY_CHUNK \ - assert(pRExC_state); assert(scanp); assert(minlenp); assert(deltap); \ - assert(last) + ASSUME(pRExC_state); ASSUME(scanp); ASSUME(minlenp); ASSUME(deltap); \ + ASSUME(last) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV void @@ -8306,6 +8479,8 @@ Perl_populate_anyof_bitmap_from_invlist(pTHX_ regnode *node, SV **invlist_ptr) __attribute__visibility__("hidden"); PERL_CALLCONV U32 Perl_reg_add_data(RExC_state_t * const pRExC_state, const char * const s, const U32 n) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); PERL_CALLCONV void @@ -8331,30 +8506,30 @@ S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie, HV *widecharm # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # if defined(PERL_IN_REGCOMP_TRIE_C) && defined(DEBUGGING) # define PERL_ARGS_ASSERT_DUMP_TRIE \ - assert(trie); assert(!widecharmap || SvTYPE(widecharmap) == SVt_PVHV); \ - assert(revcharmap); assert(SvTYPE(revcharmap) == SVt_PVAV) + ASSUME(trie); ASSUME(!widecharmap || SvTYPE(widecharmap) == SVt_PVHV); \ + ASSUME(revcharmap); ASSUME(SvTYPE(revcharmap) == SVt_PVAV) # define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_LIST \ - assert(trie); assert(!widecharmap || SvTYPE(widecharmap) == SVt_PVHV); \ - assert(revcharmap); assert(SvTYPE(revcharmap) == SVt_PVAV) + ASSUME(trie); ASSUME(!widecharmap || SvTYPE(widecharmap) == SVt_PVHV); \ + ASSUME(revcharmap); ASSUME(SvTYPE(revcharmap) == SVt_PVAV) # define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_TABLE \ - assert(trie); assert(!widecharmap || SvTYPE(widecharmap) == SVt_PVHV); \ - assert(revcharmap); assert(SvTYPE(revcharmap) == SVt_PVAV) + ASSUME(trie); ASSUME(!widecharmap || SvTYPE(widecharmap) == SVt_PVHV); \ + ASSUME(revcharmap); ASSUME(SvTYPE(revcharmap) == SVt_PVAV) # endif /* defined(PERL_IN_REGCOMP_TRIE_C) && defined(DEBUGGING) */ # if !defined(PERL_NO_INLINE_FUNCTIONS) # define PERL_ARGS_ASSERT_INVLIST_CONTENTS \ - assert(invlist) + ASSUME(invlist) # define PERL_ARGS_ASSERT_INVLIST_HIGHEST_RANGE_START \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # define PERL_ARGS_ASSERT_INVLIST_LOWEST \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_STATIC_INLINE SV * @@ -8362,19 +8537,22 @@ S_invlist_contents(pTHX_ SV * const invlist, const bool traditional_style) __attribute__warn_unused_result__; PERL_STATIC_INLINE UV S_invlist_highest_range_start(SV * const invlist) + __attribute__nonnull__(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE bool S_invlist_is_iterating(const SV * const invlist) + __attribute__nonnull__(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE UV S_invlist_lowest(SV * const invlist) + __attribute__nonnull__(1) __attribute__warn_unused_result__; # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ #endif /* defined(PERL_IN_REGCOMP_ANY) */ #if defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_SV_C) # define PERL_ARGS_ASSERT_INVLIST_CLONE \ - assert(invlist) + ASSUME(invlist) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV SV * @@ -8383,140 +8561,140 @@ Perl_invlist_clone(pTHX_ SV * const invlist, SV *newlist); #endif #if defined(PERL_IN_REGCOMP_C) # define PERL_ARGS_ASSERT_ADD_MULTI_MATCH \ - assert(!multi_char_matches || SvTYPE(multi_char_matches) == SVt_PVAV); \ - assert(multi_string) + ASSUME(!multi_char_matches || SvTYPE(multi_char_matches) == SVt_PVAV); \ + ASSUME(multi_string) # define PERL_ARGS_ASSERT_CHANGE_ENGINE_SIZE \ - assert(pRExC_state) + ASSUME(pRExC_state) # define PERL_ARGS_ASSERT_COMPILE_WILDCARD \ - assert(subpattern) + ASSUME(subpattern) # define PERL_ARGS_ASSERT_COMPUTE_EXACTISH \ - assert(pRExC_state) + PERL_ASSUME_NON_NULL(pRExC_state) # define PERL_ARGS_ASSERT_EDIT_DISTANCE \ - assert(src); assert(tgt) + PERL_ASSUME_NON_NULL(src); PERL_ASSUME_NON_NULL(tgt) # define PERL_ARGS_ASSERT_EXECUTE_WILDCARD \ - assert(prog); assert(stringarg); assert(strend); assert(strbeg); \ - assert(screamer) + ASSUME(prog); ASSUME(stringarg); ASSUME(strend); ASSUME(strbeg); \ + ASSUME(screamer) # define PERL_ARGS_ASSERT_GET_QUANTIFIER_VALUE \ - assert(pRExC_state); assert(start); assert(end) + ASSUME(pRExC_state); ASSUME(start); ASSUME(end) # define PERL_ARGS_ASSERT_GROK_BSLASH_N \ - assert(pRExC_state); assert(flagp) + ASSUME(pRExC_state); ASSUME(flagp) # define PERL_ARGS_ASSERT_HANDLE_NAMED_BACKREF \ - assert(pRExC_state); assert(flagp); assert(backref_parse_start) + ASSUME(pRExC_state); ASSUME(flagp); ASSUME(backref_parse_start) # define PERL_ARGS_ASSERT_HANDLE_NAMES_WILDCARD \ - assert(wname); assert(prop_definition); assert(strings) + ASSUME(wname); ASSUME(prop_definition); ASSUME(strings) # define PERL_ARGS_ASSERT_HANDLE_POSSIBLE_POSIX \ - assert(pRExC_state); assert(s) + ASSUME(pRExC_state); ASSUME(s) # define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS \ - assert(pRExC_state); assert(flagp) + ASSUME(pRExC_state); ASSUME(flagp) # define PERL_ARGS_ASSERT_HANDLE_USER_DEFINED_PROPERTY \ - assert(name); assert(contents); assert(user_defined_ptr); assert(msg) + ASSUME(name); ASSUME(contents); ASSUME(user_defined_ptr); ASSUME(msg) # define PERL_ARGS_ASSERT_IS_SSC_WORTH_IT \ - assert(pRExC_state); assert(ssc) + PERL_ASSUME_NON_NULL(pRExC_state); PERL_ASSUME_NON_NULL(ssc) # define PERL_ARGS_ASSERT_NEXTCHAR \ - assert(pRExC_state) + ASSUME(pRExC_state) # define PERL_ARGS_ASSERT_OPTIMIZE_REGCLASS \ - assert(pRExC_state); assert(anyof_flags); assert(invert); assert(ret); \ - assert(flagp) + ASSUME(pRExC_state); ASSUME(anyof_flags); ASSUME(invert); ASSUME(ret); \ + ASSUME(flagp) # define PERL_ARGS_ASSERT_OUTPUT_POSIX_WARNINGS \ - assert(pRExC_state); assert(posix_warnings); \ - assert(SvTYPE(posix_warnings) == SVt_PVAV) + ASSUME(pRExC_state); ASSUME(posix_warnings); \ + ASSUME(SvTYPE(posix_warnings) == SVt_PVAV) # define PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS \ - assert(pRExC_state) + ASSUME(pRExC_state) # define PERL_ARGS_ASSERT_PARSE_UNIPROP_STRING \ - assert(name); assert(user_defined_ptr); assert(msg) + ASSUME(name); ASSUME(user_defined_ptr); ASSUME(msg) PERL_STATIC_NO_RET void S_re_croak(pTHX_ bool utf8, const char *pat, ...) __attribute__noreturn__ __attribute__format__(__printf__,pTHX_2,pTHX_3); # define PERL_ARGS_ASSERT_RE_CROAK \ - assert(pat) + ASSUME(pat) # define PERL_ARGS_ASSERT_REG \ - assert(pRExC_state); assert(flagp) + ASSUME(pRExC_state); ASSUME(flagp) # define PERL_ARGS_ASSERT_REG1NODE \ - assert(pRExC_state) + ASSUME(pRExC_state) # define PERL_ARGS_ASSERT_REG2NODE \ - assert(pRExC_state) + ASSUME(pRExC_state) # define PERL_ARGS_ASSERT_REG_LA_NOTHING \ - assert(pRExC_state); assert(type) + ASSUME(pRExC_state); ASSUME(type) # define PERL_ARGS_ASSERT_REG_LA_OPFAIL \ - assert(pRExC_state); assert(type) + ASSUME(pRExC_state); ASSUME(type) # define PERL_ARGS_ASSERT_REG_NODE \ - assert(pRExC_state) + ASSUME(pRExC_state) # define PERL_ARGS_ASSERT_REG_SCAN_NAME \ - assert(pRExC_state) + ASSUME(pRExC_state) # define PERL_ARGS_ASSERT_REGATOM \ - assert(pRExC_state); assert(flagp) + ASSUME(pRExC_state); ASSUME(flagp) # define PERL_ARGS_ASSERT_REGBRANCH \ - assert(pRExC_state); assert(flagp) + ASSUME(pRExC_state); ASSUME(flagp) # define PERL_ARGS_ASSERT_REGCLASS \ - assert(pRExC_state); assert(flagp) + ASSUME(pRExC_state); ASSUME(flagp) # define PERL_ARGS_ASSERT_REGEX_SET_PRECEDENCE # define PERL_ARGS_ASSERT_REGINSERT \ - assert(pRExC_state) + ASSUME(pRExC_state) # define PERL_ARGS_ASSERT_REGNODE_GUTS \ - assert(pRExC_state) + ASSUME(pRExC_state) # define PERL_ARGS_ASSERT_REGPIECE \ - assert(pRExC_state); assert(flagp) + ASSUME(pRExC_state); ASSUME(flagp) # define PERL_ARGS_ASSERT_REGPNODE \ - assert(pRExC_state); assert(arg) + ASSUME(pRExC_state); ASSUME(arg) # define PERL_ARGS_ASSERT_REGTAIL \ - assert(pRExC_state); assert(p); assert(val) + ASSUME(pRExC_state); ASSUME(p); ASSUME(val) # define PERL_ARGS_ASSERT_SET_REGEX_PV \ - assert(pRExC_state); assert(Rx) + ASSUME(pRExC_state); ASSUME(Rx) # define PERL_ARGS_ASSERT_SKIP_TO_BE_IGNORED_TEXT \ - assert(pRExC_state); assert(p) + ASSUME(pRExC_state); ASSUME(p) # define PERL_ARGS_ASSERT_SSC_FINALIZE \ - assert(pRExC_state); assert(ssc) + ASSUME(pRExC_state); ASSUME(ssc) # if defined(DEBUGGING) # define PERL_ARGS_ASSERT_REGNODE_GUTS_DEBUG \ - assert(pRExC_state) + ASSUME(pRExC_state) # define PERL_ARGS_ASSERT_REGTAIL_STUDY \ - assert(pRExC_state); assert(p); assert(val) + ASSUME(pRExC_state); ASSUME(p); ASSUME(val) # if defined(ENABLE_REGEX_SETS_DEBUGGING) # define PERL_ARGS_ASSERT_DUMP_REGEX_SETS_STRUCTURES \ - assert(pRExC_state); assert(stack); assert(SvTYPE(stack) == SVt_PVAV); \ - assert(fence_stack); assert(SvTYPE(fence_stack) == SVt_PVAV) + ASSUME(pRExC_state); ASSUME(stack); ASSUME(SvTYPE(stack) == SVt_PVAV); \ + ASSUME(fence_stack); ASSUME(SvTYPE(fence_stack) == SVt_PVAV) # endif # endif /* defined(DEBUGGING) */ @@ -8529,9 +8707,12 @@ STATIC REGEXP * S_compile_wildcard(pTHX_ const char *subpattern, const STRLEN len, const bool ignore_case) __attribute__warn_unused_result__; STATIC U8 -S_compute_EXACTish(RExC_state_t *pRExC_state); +S_compute_EXACTish(RExC_state_t *pRExC_state) + __attribute__nonnull__(1); STATIC int S_edit_distance(const UV *src, const UV *tgt, const STRLEN x, const STRLEN y, const SSize_t maxDistance) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__; STATIC I32 S_execute_wildcard(pTHX_ REGEXP * const prog, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *screamer, U32 nosave); @@ -8550,7 +8731,9 @@ S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV **return_invlist, I32 *f STATIC SV * S_handle_user_defined_property(pTHX_ const char *name, const STRLEN name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, SV *contents, bool *user_defined_ptr, SV *msg, const STRLEN level); STATIC bool -S_is_ssc_worth_it(const RExC_state_t *pRExC_state, const regnode_ssc *ssc); +S_is_ssc_worth_it(const RExC_state_t *pRExC_state, const regnode_ssc *ssc) + __attribute__nonnull__(1) + __attribute__nonnull__(2); STATIC void S_nextchar(pTHX_ RExC_state_t *pRExC_state); STATIC U8 @@ -8615,25 +8798,29 @@ S_dump_regex_sets_structures(pTHX_ RExC_state_t *pRExC_state, AV *stack, const I # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # if !defined(PERL_NO_INLINE_FUNCTIONS) # define PERL_ARGS_ASSERT_FIND_FIRST_DIFFERING_BYTE_POS \ - assert(s1); assert(s2) + PERL_ASSUME_NON_NULL(s1); PERL_ASSUME_NON_NULL(s2) # define PERL_ARGS_ASSERT_REG_SKIPCOMMENT \ - assert(pRExC_state); assert(p) + PERL_ASSUME_NON_NULL(pRExC_state); PERL_ASSUME_NON_NULL(p) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_STATIC_INLINE Size_t -S_find_first_differing_byte_pos(const U8 *s1, const U8 *s2, const Size_t max); +S_find_first_differing_byte_pos(const U8 *s1, const U8 *s2, const Size_t max) + __attribute__nonnull__(1) + __attribute__nonnull__(2); PERL_STATIC_INLINE char * -S_reg_skipcomment(RExC_state_t *pRExC_state, char *p); +S_reg_skipcomment(RExC_state_t *pRExC_state, char *p) + __attribute__nonnull__(1) + __attribute__nonnull__(2); # endif # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ #endif /* defined(PERL_IN_REGCOMP_C) */ #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGCOMP_INVLIST_C) # define PERL_ARGS_ASSERT_POPULATE_BITMAP_FROM_INVLIST \ - assert(invlist); assert(bitmap) + ASSUME(invlist); ASSUME(bitmap) # define PERL_ARGS_ASSERT_POPULATE_INVLIST_FROM_BITMAP \ - assert(bitmap); assert(invlist) + ASSUME(bitmap); ASSUME(invlist) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV void @@ -8647,40 +8834,42 @@ Perl_populate_invlist_from_bitmap(pTHX_ const U8 *bitmap, const Size_t bitmap_le #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || \ defined(PERL_IN_TOKE_C) # define PERL_ARGS_ASSERT_IS_GRAPHEME \ - assert(strbeg); assert(s); assert(strend) + ASSUME(strbeg); ASSUME(s); ASSUME(strend) #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || \ defined(PERL_IN_UTF8_C) # define PERL_ARGS_ASSERT__TO_FOLD_LATIN1 \ - assert(p); assert(lenp) + PERL_ASSUME_NON_NULL(p); PERL_ASSUME_NON_NULL(lenp) #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) # define PERL_ARGS_ASSERT_REGCURLY \ - assert(s); assert(e) + PERL_ASSUME_NON_NULL(s); PERL_ASSUME_NON_NULL(e) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV bool Perl_regcurly(const char *s, const char *e, const char *result[5]) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__; # endif #endif /* defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) */ #if defined(PERL_IN_REGCOMP_DEBUG_C) && defined(DEBUGGING) # define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS \ - assert(sv) + ASSUME(sv) # define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS_COMMON \ - assert(invlist) + ASSUME(invlist) # define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS_INVLIST \ - assert(sv); assert(invlist) + ASSUME(sv); ASSUME(invlist) # define PERL_ARGS_ASSERT_PUT_CODE_POINT \ - assert(sv) + ASSUME(sv) # define PERL_ARGS_ASSERT_PUT_RANGE \ - assert(sv) + ASSUME(sv) # define PERL_ARGS_ASSERT_REGDUMP_EXTFLAGS @@ -8689,15 +8878,15 @@ Perl_regcurly(const char *s, const char *e, const char *result[5]) #endif /* defined(PERL_IN_REGCOMP_DEBUG_C) && defined(DEBUGGING) */ #if defined(PERL_IN_REGCOMP_INVLIST_C) && !defined(PERL_EXT_RE_BUILD) # define PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST \ - assert(invlist) + ASSUME(invlist) STATIC void S_initialize_invlist_guts(pTHX_ SV *invlist, const Size_t initial_size); # define PERL_ARGS_ASSERT_INITIALIZE_INVLIST_GUTS \ - assert(invlist) + ASSUME(invlist) # define PERL_ARGS_ASSERT_INVLIST_REPLACE_LIST_DESTROYS_SRC \ - assert(dest); assert(src) + ASSUME(dest); ASSUME(src) # if defined(PERL_CORE) || defined(PERL_EXT) STATIC void @@ -8707,90 +8896,96 @@ S_invlist_replace_list_destroys_src(pTHX_ SV *dest, SV *src); # endif # if !defined(PERL_NO_INLINE_FUNCTIONS) # define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # define PERL_ARGS_ASSERT_INVLIST_CLEAR \ - assert(invlist) + ASSUME(invlist) # define PERL_ARGS_ASSERT_INVLIST_MAX \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # define PERL_ARGS_ASSERT_INVLIST_TRIM \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_STATIC_INLINE UV * S__invlist_array_init(SV * const invlist, const bool will_have_0) + __attribute__nonnull__(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE IV * S_get_invlist_previous_index_addr(SV *invlist) + __attribute__nonnull__(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE void S_invlist_clear(pTHX_ SV *invlist); PERL_STATIC_INLINE UV S_invlist_max(const SV * const invlist) + __attribute__nonnull__(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE IV S_invlist_previous_index(SV * const invlist) + __attribute__nonnull__(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE void -S_invlist_set_previous_index(SV * const invlist, const IV index); +S_invlist_set_previous_index(SV * const invlist, const IV index) + __attribute__nonnull__(1); PERL_STATIC_INLINE void -S_invlist_trim(SV *invlist); +S_invlist_trim(SV *invlist) + __attribute__nonnull__(1); # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ #endif /* defined(PERL_IN_REGCOMP_INVLIST_C) && !defined(PERL_EXT_RE_BUILD) */ #if defined(PERL_IN_REGCOMP_STUDY_C) # define PERL_ARGS_ASSERT_GET_ANYOF_CP_LIST_FOR_SSC \ - assert(pRExC_state); assert(node) + ASSUME(pRExC_state); ASSUME(node) # define PERL_ARGS_ASSERT_MAKE_EXACTF_INVLIST \ - assert(pRExC_state); assert(node) + ASSUME(pRExC_state); ASSUME(node) # define PERL_ARGS_ASSERT_RCK_ELIDE_NOTHING \ - assert(node) + ASSUME(node) # define PERL_ARGS_ASSERT_SSC_ADD_RANGE \ - assert(ssc) + ASSUME(ssc) # define PERL_ARGS_ASSERT_SSC_AND \ - assert(pRExC_state); assert(ssc); assert(and_with) + ASSUME(pRExC_state); ASSUME(ssc); ASSUME(and_with) # define PERL_ARGS_ASSERT_SSC_ANYTHING \ - assert(ssc) + ASSUME(ssc) # define PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE \ - assert(ssc) + PERL_ASSUME_NON_NULL(ssc) # define PERL_ARGS_ASSERT_SSC_CP_AND \ - assert(ssc) + ASSUME(ssc) # define PERL_ARGS_ASSERT_SSC_INTERSECTION \ - assert(ssc); assert(invlist) + ASSUME(ssc); ASSUME(invlist) # define PERL_ARGS_ASSERT_SSC_IS_ANYTHING \ - assert(ssc) + PERL_ASSUME_NON_NULL(ssc) # define PERL_ARGS_ASSERT_SSC_IS_CP_POSIXL_INIT \ - assert(pRExC_state); assert(ssc) + PERL_ASSUME_NON_NULL(pRExC_state); PERL_ASSUME_NON_NULL(ssc) # define PERL_ARGS_ASSERT_SSC_OR \ - assert(pRExC_state); assert(ssc); assert(or_with) + ASSUME(pRExC_state); ASSUME(ssc); ASSUME(or_with) # define PERL_ARGS_ASSERT_SSC_UNION \ - assert(ssc); assert(invlist) + ASSUME(ssc); ASSUME(invlist) # define PERL_ARGS_ASSERT_UNWIND_SCAN_FRAMES \ - assert(p) + ASSUME(p) # if defined(PERL_CORE) || defined(PERL_EXT) STATIC SV * @@ -8807,16 +9002,20 @@ S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode STATIC void S_ssc_anything(pTHX_ regnode_ssc *ssc); STATIC void -S_ssc_clear_locale(regnode_ssc *ssc); +S_ssc_clear_locale(regnode_ssc *ssc) + __attribute__nonnull__(1); STATIC void S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp); STATIC void S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV * const invlist, const bool invert_2nd); STATIC int S_ssc_is_anything(const regnode_ssc *ssc) + __attribute__nonnull__(1) __attribute__warn_unused_result__; STATIC int S_ssc_is_cp_posixl_init(const RExC_state_t *pRExC_state, const regnode_ssc *ssc) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__; STATIC void S_ssc_or(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *or_with); @@ -8828,102 +9027,102 @@ S_unwind_scan_frames(pTHX_ void *p); #endif /* defined(PERL_IN_REGCOMP_STUDY_C) */ #if defined(PERL_IN_REGEXEC_C) # define PERL_ARGS_ASSERT_ADVANCE_ONE_LB \ - assert(curpos); assert(strend) + ASSUME(curpos); ASSUME(strend) # define PERL_ARGS_ASSERT_ADVANCE_ONE_SB \ - assert(curpos); assert(strend) + ASSUME(curpos); ASSUME(strend) # define PERL_ARGS_ASSERT_ADVANCE_ONE_WB_ \ - assert(curpos); assert(strend) + ASSUME(curpos); ASSUME(strend) # define PERL_ARGS_ASSERT_BACKUP_ONE_GCB \ - assert(strbeg); assert(curpos) + ASSUME(strbeg); ASSUME(curpos) # define PERL_ARGS_ASSERT_BACKUP_ONE_LB_ \ - assert(strbeg); assert(curpos) + ASSUME(strbeg); ASSUME(curpos) # define PERL_ARGS_ASSERT_BACKUP_ONE_SB \ - assert(strbeg); assert(curpos) + ASSUME(strbeg); ASSUME(curpos) # define PERL_ARGS_ASSERT_BACKUP_ONE_WB_BUT_OVER_EXTEND_FO \ - assert(previous); assert(strbeg); assert(curpos) + ASSUME(previous); ASSUME(strbeg); ASSUME(curpos) # define PERL_ARGS_ASSERT_FIND_BYCLASS \ - assert(prog); assert(c); assert(s); assert(strend) + ASSUME(prog); ASSUME(c); ASSUME(s); ASSUME(strend) # define PERL_ARGS_ASSERT_FIND_NEXT_MASKED \ - assert(s); assert(send) + PERL_ASSUME_NON_NULL(s); PERL_ASSUME_NON_NULL(send) # define PERL_ARGS_ASSERT_FIND_SPAN_END \ - assert(s); assert(send) + PERL_ASSUME_NON_NULL(s); PERL_ASSUME_NON_NULL(send) # define PERL_ARGS_ASSERT_FIND_SPAN_END_MASK \ - assert(s); assert(send) + PERL_ASSUME_NON_NULL(s); PERL_ASSUME_NON_NULL(send) # define PERL_ARGS_ASSERT_ISFOO_LC # define PERL_ARGS_ASSERT_ISFOO_UTF8_LC \ - assert(character); assert(e) + ASSUME(character); ASSUME(e) # define PERL_ARGS_ASSERT_ISGCB \ - assert(strbeg); assert(curpos) + ASSUME(strbeg); ASSUME(curpos) # define PERL_ARGS_ASSERT_ISLB \ - assert(strbeg); assert(curpos); assert(strend) + ASSUME(strbeg); ASSUME(curpos); ASSUME(strend) # define PERL_ARGS_ASSERT_ISSB \ - assert(strbeg); assert(curpos); assert(strend) + ASSUME(strbeg); ASSUME(curpos); ASSUME(strend) # define PERL_ARGS_ASSERT_ISWB \ - assert(strbeg); assert(curpos); assert(strend) + ASSUME(strbeg); ASSUME(curpos); ASSUME(strend) # define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED \ - assert(rex); assert(scan) + PERL_ASSUME_NON_NULL(rex); PERL_ASSUME_NON_NULL(scan) # define PERL_ARGS_ASSERT_REGCP_RESTORE \ - assert(rex); assert(maxopenparen_p) + ASSUME(rex); ASSUME(maxopenparen_p) # define PERL_ARGS_ASSERT_REGCPPOP \ - assert(rex); assert(maxopenparen_p) + ASSUME(rex); ASSUME(maxopenparen_p) # define PERL_ARGS_ASSERT_REGCPPUSH \ - assert(rex) + ASSUME(rex) # define PERL_ARGS_ASSERT_REGHOP3 \ - assert(s); assert(lim) + PERL_ASSUME_NON_NULL(s); PERL_ASSUME_NON_NULL(lim) # define PERL_ARGS_ASSERT_REGHOPMAYBE3 \ - assert(s); assert(lim) + PERL_ASSUME_NON_NULL(s); PERL_ASSUME_NON_NULL(lim) # define PERL_ARGS_ASSERT_REGINCLASS \ - assert(n); assert(p); assert(p_end) + ASSUME(n); ASSUME(p); ASSUME(p_end) # define PERL_ARGS_ASSERT_REGMATCH \ - assert(reginfo); assert(startpos); assert(prog) + ASSUME(reginfo); ASSUME(startpos); ASSUME(prog) # define PERL_ARGS_ASSERT_REGREPEAT \ - assert(prog); assert(startposp); assert(p); assert(loceol); \ - assert(reginfo); assert(max) + ASSUME(prog); ASSUME(startposp); ASSUME(p); ASSUME(loceol); \ + ASSUME(reginfo); ASSUME(max) # define PERL_ARGS_ASSERT_REGTRY \ - assert(reginfo); assert(startposp) + ASSUME(reginfo); ASSUME(startposp) # define PERL_ARGS_ASSERT_TO_BYTE_SUBSTR \ - assert(prog) + ASSUME(prog) # define PERL_ARGS_ASSERT_TO_UTF8_SUBSTR \ - assert(prog) + ASSUME(prog) # if defined(DEBUGGING) # define PERL_ARGS_ASSERT_DEBUG_START_MATCH \ - assert(prog); assert(start); assert(end); assert(blurb) + ASSUME(prog); ASSUME(start); ASSUME(end); ASSUME(blurb) # define PERL_ARGS_ASSERT_DUMP_EXEC_POS \ - assert(locinput); assert(scan); assert(loc_regeol); assert(loc_bostr); \ - assert(loc_reg_starttry) + ASSUME(locinput); ASSUME(scan); ASSUME(loc_regeol); ASSUME(loc_bostr); \ + ASSUME(loc_reg_starttry) # define PERL_ARGS_ASSERT_RE_EXEC_INDENTF \ - assert(fmt) + ASSUME(fmt) # endif /* defined(DEBUGGING) */ # if defined(PERL_CORE) || defined(PERL_EXT) @@ -8953,12 +9152,18 @@ S_find_byclass(pTHX_ regexp *prog, const regnode *c, char *s, const char *strend __attribute__warn_unused_result__; STATIC U8 * S_find_next_masked(U8 *s, const U8 *send, const U8 byte, const U8 mask) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__; STATIC U8 * S_find_span_end(U8 *s, const U8 *send, const U8 span_byte) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__; STATIC U8 * S_find_span_end_mask(U8 *s, const U8 *send, const U8 span_byte, const U8 mask) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__; STATIC bool S_isFOO_lc(pTHX_ const U8 classnum, const U8 character) @@ -8980,6 +9185,8 @@ S_isWB(pTHX_ WB_enum previous, WB_enum before, WB_enum after, const U8 * const s __attribute__warn_unused_result__; STATIC I32 S_reg_check_named_buff_matched(const regexp *rex, const regnode *scan) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__; STATIC void S_regcp_restore(pTHX_ regexp *rex, I32 ix, U32 *maxopenparen_p comma_pDEPTH); @@ -8989,9 +9196,13 @@ STATIC CHECKPOINT S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen comma_pDEPTH); STATIC U8 * S_reghop3(U8 *s, SSize_t off, const U8 *lim) + __attribute__nonnull__(1) + __attribute__nonnull__(3) __attribute__warn_unused_result__; STATIC U8 * S_reghopmaybe3(U8 *s, SSize_t off, const U8 * const lim) + __attribute__nonnull__(1) + __attribute__nonnull__(3) __attribute__warn_unused_result__; STATIC bool S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8 * const p, const U8 * const p_end, bool const utf8_target) @@ -9021,13 +9232,13 @@ Perl_re_exec_indentf(pTHX_ const char *fmt, U32 depth, ...) # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # if !defined(PERL_NO_INLINE_FUNCTIONS) # define PERL_ARGS_ASSERT_CAPTURE_CLEAR \ - assert(rex); assert(str) + ASSUME(rex); ASSUME(str) # define PERL_ARGS_ASSERT_FOLDEQ_LATIN1_S2_FOLDED \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) # define PERL_ARGS_ASSERT_UNWIND_PAREN \ - assert(rex) + ASSUME(rex) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_STATIC_INLINE void @@ -9043,25 +9254,25 @@ S_unwind_paren(pTHX_ regexp *rex, U32 lp, U32 lcp comma_pDEPTH); # if defined(DEBUGGING) # define PERL_ARGS_ASSERT_DEBUG_PEEP \ - assert(str); assert(pRExC_state) + ASSUME(str); ASSUME(pRExC_state) # define PERL_ARGS_ASSERT_DEBUG_SHOW_STUDY_FLAGS \ - assert(open_str); assert(close_str) + ASSUME(open_str); ASSUME(close_str) # define PERL_ARGS_ASSERT_DEBUG_STUDYDATA \ - assert(where) + ASSUME(where) # define PERL_ARGS_ASSERT_DUMPUNTIL \ - assert(r); assert(start); assert(node); assert(sv) + ASSUME(r); ASSUME(start); ASSUME(node); ASSUME(sv) # define PERL_ARGS_ASSERT_RE_INDENTF \ - assert(fmt) + ASSUME(fmt) # define PERL_ARGS_ASSERT_RE_PRINTF \ - assert(fmt) + ASSUME(fmt) # define PERL_ARGS_ASSERT_REGPROP \ - assert(sv); assert(o) + ASSUME(sv); ASSUME(o) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV void @@ -9090,7 +9301,7 @@ Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_ # endif /* defined(DEBUGGING) */ # if defined(PERL_EXT_RE_BUILD) # define PERL_ARGS_ASSERT_GET_RE_GCLASS_AUX_DATA \ - assert(node) + ASSUME(node) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV SV * @@ -9099,7 +9310,7 @@ Perl_get_re_gclass_aux_data(pTHX_ const regexp *prog, const struct regnode *node # endif # else /* if !defined(PERL_EXT_RE_BUILD) */ # define PERL_ARGS_ASSERT_GET_REGCLASS_AUX_DATA \ - assert(node) + ASSUME(node) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV SV * @@ -9133,66 +9344,68 @@ S_save_pushptri32ptr(pTHX_ void * const ptr1, const I32 i, void * const ptr2, co STATIC SV * S_save_scalar_at(pTHX_ SV **sptr, const U32 flags); # define PERL_ARGS_ASSERT_SAVE_SCALAR_AT \ - assert(sptr) + ASSUME(sptr) #endif /* defined(PERL_IN_SCOPE_C) */ #if defined(PERL_IN_SV_C) STATIC char * -S_F0convert(NV nv, char * const endbuf, STRLEN * const len); +S_F0convert(NV nv, char * const endbuf, STRLEN * const len) + __attribute__nonnull__(2) + __attribute__nonnull__(3); # define PERL_ARGS_ASSERT_F0CONVERT \ - assert(endbuf); assert(len) + PERL_ASSUME_NON_NULL(endbuf); PERL_ASSUME_NON_NULL(len) STATIC void S_anonymise_cv_maybe(pTHX_ GV *gv, CV *cv); # define PERL_ARGS_ASSERT_ANONYMISE_CV_MAYBE \ - assert(gv); assert(cv); \ - assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(gv); ASSUME(cv); \ + ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) STATIC void S_assert_uft8_cache_coherent(pTHX_ const char * const func, STRLEN from_cache, STRLEN real, SV * const sv); # define PERL_ARGS_ASSERT_ASSERT_UFT8_CACHE_COHERENT \ - assert(func); assert(sv) + ASSUME(func); ASSUME(sv) STATIC void S_croak_sv_setsv_flags(pTHX_ SV * const dsv, SV * const ssv); # define PERL_ARGS_ASSERT_CROAK_SV_SETSV_FLAGS \ - assert(dsv); assert(ssv) + ASSUME(dsv); ASSUME(ssv) STATIC bool S_curse(pTHX_ SV * const sv, const bool check_refcnt); # define PERL_ARGS_ASSERT_CURSE \ - assert(sv) + ASSUME(sv) STATIC STRLEN S_expect_number(pTHX_ const char ** const pattern) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_EXPECT_NUMBER \ - assert(pattern) + ASSUME(pattern) STATIC SSize_t S_find_array_subscript(pTHX_ const AV * const av, const SV * const val); # define PERL_ARGS_ASSERT_FIND_ARRAY_SUBSCRIPT \ - assert(val) + ASSUME(val) STATIC SV * S_find_hash_subscript(pTHX_ const HV * const hv, const SV * const val); # define PERL_ARGS_ASSERT_FIND_HASH_SUBSCRIPT \ - assert(val) + ASSUME(val) STATIC SV * S_find_uninit_var(pTHX_ const OP * const obase, const SV * const uninit_sv, bool match, const char **desc_p); # define PERL_ARGS_ASSERT_FIND_UNINIT_VAR \ - assert(desc_p) + ASSUME(desc_p) STATIC bool S_glob_2number(pTHX_ GV * const gv); # define PERL_ARGS_ASSERT_GLOB_2NUMBER \ - assert(gv) + ASSUME(gv) STATIC void S_glob_assign_glob(pTHX_ SV * const dsv, SV * const ssv, const int dtype); # define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB \ - assert(dsv); assert(ssv) + ASSUME(dsv); ASSUME(ssv) PERL_CALLCONV SV * Perl_more_sv(pTHX); @@ -9201,75 +9414,84 @@ Perl_more_sv(pTHX); STATIC void S_not_a_number(pTHX_ SV * const sv); # define PERL_ARGS_ASSERT_NOT_A_NUMBER \ - assert(sv) + ASSUME(sv) STATIC void S_not_incrementable(pTHX_ SV * const sv); # define PERL_ARGS_ASSERT_NOT_INCREMENTABLE \ - assert(sv) + ASSUME(sv) STATIC PTR_TBL_ENT_t * S_ptr_table_find(PTR_TBL_t * const tbl, const void * const sv) + __attribute__nonnull__(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_PTR_TABLE_FIND \ - assert(tbl) + PERL_ASSUME_NON_NULL(tbl) STATIC bool S_sv_2iuv_common(pTHX_ SV * const sv); # define PERL_ARGS_ASSERT_SV_2IUV_COMMON \ - assert(sv) + ASSUME(sv) STATIC void S_sv_add_arena(pTHX_ char * const ptr, const U32 size, const U32 flags); # define PERL_ARGS_ASSERT_SV_ADD_ARENA \ - assert(ptr) + ASSUME(ptr) STATIC const char * S_sv_display(pTHX_ SV * const sv, char *tmpbuf, STRLEN tmpbuf_size); # define PERL_ARGS_ASSERT_SV_DISPLAY \ - assert(sv); assert(tmpbuf) + ASSUME(sv); ASSUME(tmpbuf) STATIC STRLEN S_sv_pos_b2u_midway(pTHX_ const U8 * const s, const U8 * const target, const U8 *end, STRLEN endu); # define PERL_ARGS_ASSERT_SV_POS_B2U_MIDWAY \ - assert(s); assert(target); assert(end) + ASSUME(s); ASSUME(target); ASSUME(end) STATIC STRLEN S_sv_pos_u2b_cached(pTHX_ SV * const sv, MAGIC ** const mgp, const U8 * const start, const U8 * const send, STRLEN uoffset, STRLEN uoffset0, STRLEN boffset0); # define PERL_ARGS_ASSERT_SV_POS_U2B_CACHED \ - assert(sv); assert(mgp); assert(start); assert(send) + ASSUME(sv); ASSUME(mgp); ASSUME(start); ASSUME(send) STATIC STRLEN -S_sv_pos_u2b_forwards(const U8 * const start, const U8 * const send, STRLEN * const uoffset, bool * const at_end, bool *canonical_position); +S_sv_pos_u2b_forwards(const U8 * const start, const U8 * const send, STRLEN * const uoffset, bool * const at_end, bool *canonical_position) + __attribute__nonnull__(1) + __attribute__nonnull__(2) + __attribute__nonnull__(3) + __attribute__nonnull__(4) + __attribute__nonnull__(5); # define PERL_ARGS_ASSERT_SV_POS_U2B_FORWARDS \ - assert(start); assert(send); assert(uoffset); assert(at_end); \ - assert(canonical_position) + PERL_ASSUME_NON_NULL(start); PERL_ASSUME_NON_NULL(send); \ + PERL_ASSUME_NON_NULL(uoffset); PERL_ASSUME_NON_NULL(at_end); \ + PERL_ASSUME_NON_NULL(canonical_position) STATIC STRLEN -S_sv_pos_u2b_midway(const U8 * const start, const U8 *send, STRLEN uoffset, const STRLEN uend); +S_sv_pos_u2b_midway(const U8 * const start, const U8 *send, STRLEN uoffset, const STRLEN uend) + __attribute__nonnull__(1) + __attribute__nonnull__(2); # define PERL_ARGS_ASSERT_SV_POS_U2B_MIDWAY \ - assert(start); assert(send) + PERL_ASSUME_NON_NULL(start); PERL_ASSUME_NON_NULL(send) STATIC void S_utf8_mg_len_cache_update(pTHX_ SV * const sv, MAGIC ** const mgp, const STRLEN ulen); # define PERL_ARGS_ASSERT_UTF8_MG_LEN_CACHE_UPDATE \ - assert(sv); assert(mgp) + ASSUME(sv); ASSUME(mgp) STATIC void S_utf8_mg_pos_cache_update(pTHX_ SV * const sv, MAGIC ** const mgp, const STRLEN byte, const STRLEN utf8, const STRLEN blen); # define PERL_ARGS_ASSERT_UTF8_MG_POS_CACHE_UPDATE \ - assert(sv); assert(mgp) + ASSUME(sv); ASSUME(mgp) STATIC SSize_t S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask); # define PERL_ARGS_ASSERT_VISIT \ - assert(f) + ASSUME(f) # if defined(DEBUGGING) STATIC void S_del_sv(pTHX_ SV *p); # define PERL_ARGS_ASSERT_DEL_SV \ - assert(p) + ASSUME(p) PERL_CALLCONV void Perl_sv_mark_arenas(pTHX) @@ -9287,13 +9509,13 @@ Perl_sv_sweep_arenas(pTHX) STATIC int S_sv_2iuv_non_preserve(pTHX_ SV * const sv, I32 numtype); # define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ - assert(sv) + ASSUME(sv) # else STATIC int S_sv_2iuv_non_preserve(pTHX_ SV * const sv); # define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ - assert(sv) + ASSUME(sv) # endif # endif /* !defined(NV_PRESERVES_UV) */ @@ -9301,14 +9523,14 @@ S_sv_2iuv_non_preserve(pTHX_ SV * const sv); STATIC void S_sv_buf_to_rw(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_SV_BUF_TO_RW \ - assert(sv) + ASSUME(sv) # endif # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE void S_sv_unglob(pTHX_ SV * const sv, U32 flags); # define PERL_ARGS_ASSERT_SV_UNGLOB \ - assert(sv) + ASSUME(sv) # endif # if defined(USE_ITHREADS) @@ -9316,22 +9538,22 @@ STATIC SV * S_sv_dup_common(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SV_DUP_COMMON \ - assert(ssv); assert(param) + ASSUME(ssv); ASSUME(param) STATIC void S_sv_dup_hvaux(pTHX_ const SV * const ssv, SV *dsv, CLONE_PARAMS * const param); # define PERL_ARGS_ASSERT_SV_DUP_HVAUX \ - assert(ssv); assert(dsv); assert(param) + ASSUME(ssv); ASSUME(dsv); ASSUME(param) STATIC SV ** S_sv_dup_inc_multiple(pTHX_ SV * const *source, SV **dest, SSize_t items, CLONE_PARAMS * const param); # define PERL_ARGS_ASSERT_SV_DUP_INC_MULTIPLE \ - assert(source); assert(dest); assert(param) + ASSUME(source); ASSUME(dest); ASSUME(param) STATIC void S_unreferenced_to_tmp_stack(pTHX_ AV * const unreferenced); # define PERL_ARGS_ASSERT_UNREFERENCED_TO_TMP_STACK \ - assert(unreferenced); assert(SvTYPE(unreferenced) == SVt_PVAV) + ASSUME(unreferenced); ASSUME(SvTYPE(unreferenced) == SVt_PVAV) # endif /* defined(USE_ITHREADS) */ #endif /* defined(PERL_IN_SV_C) */ @@ -9347,24 +9569,24 @@ S_check_uni(pTHX); STATIC void S_checkcomma(pTHX_ const char *s, const char *name, const char *what); # define PERL_ARGS_ASSERT_CHECKCOMMA \ - assert(s); assert(name); assert(what) + ASSUME(s); ASSUME(name); ASSUME(what) STATIC char * S_filter_gets(pTHX_ SV *sv, STRLEN append) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_FILTER_GETS \ - assert(sv) + ASSUME(sv) STATIC HV * S_find_in_my_stash(pTHX_ const char *pkgname, STRLEN len) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_FIND_IN_MY_STASH \ - assert(pkgname) + ASSUME(pkgname) STATIC void S_force_ident(pTHX_ const char *s, int kind); # define PERL_ARGS_ASSERT_FORCE_IDENT \ - assert(s) + ASSUME(s) STATIC void S_force_ident_maybe_lex(pTHX_ char pit); @@ -9377,43 +9599,43 @@ S_force_next(pTHX_ I32 type); STATIC char * S_force_strict_version(pTHX_ char *s); # define PERL_ARGS_ASSERT_FORCE_STRICT_VERSION \ - assert(s) + ASSUME(s) STATIC char * S_force_version(pTHX_ char *s, int guessing); # define PERL_ARGS_ASSERT_FORCE_VERSION \ - assert(s) + ASSUME(s) STATIC char * S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack); # define PERL_ARGS_ASSERT_FORCE_WORD \ - assert(start) + ASSUME(start) STATIC SV * S_get_and_check_backslash_N_name_wrapper(pTHX_ const char *s, const char * const e) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME_WRAPPER \ - assert(s); assert(e) + ASSUME(s); ASSUME(e) STATIC void S_incline(pTHX_ const char *s, const char *end); # define PERL_ARGS_ASSERT_INCLINE \ - assert(s); assert(end) + ASSUME(s); ASSUME(end) STATIC int S_intuit_method(pTHX_ char *s, SV *ioname, CV *cv); # define PERL_ARGS_ASSERT_INTUIT_METHOD \ - assert(s) + ASSUME(s) STATIC int S_intuit_more(pTHX_ char *s, char *e); # define PERL_ARGS_ASSERT_INTUIT_MORE \ - assert(s); assert(e) + ASSUME(s); ASSUME(e) STATIC I32 S_lop(pTHX_ enum yytokentype t, I32 f, U8 x, char *s); # define PERL_ARGS_ASSERT_LOP \ - assert(s) + ASSUME(s) PERL_STATIC_NO_RET void S_missingterm(pTHX_ char *s, STRLEN len) @@ -9423,12 +9645,12 @@ S_missingterm(pTHX_ char *s, STRLEN len) STATIC SV * S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, STRLEN keylen, SV *sv, SV *pv, const char *type, STRLEN typelen, const char **error_msg); # define PERL_ARGS_ASSERT_NEW_CONSTANT \ - assert(key); assert(sv) + ASSUME(key); ASSUME(sv) STATIC void S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_package, bool is_utf8, bool check_dollar); # define PERL_ARGS_ASSERT_PARSE_IDENT \ - assert(s); assert(d); assert(e) + ASSUME(s); ASSUME(d); ASSUME(e) STATIC int S_pending_ident(pTHX); @@ -9438,48 +9660,48 @@ STATIC char * S_scan_const(pTHX_ char *start) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_CONST \ - assert(start) + ASSUME(start) STATIC char * S_scan_formline(pTHX_ char *s) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_FORMLINE \ - assert(s) + ASSUME(s) STATIC char * S_scan_heredoc(pTHX_ char *s) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_HEREDOC \ - assert(s) + ASSUME(s) STATIC char * S_scan_ident(pTHX_ char *s, char *dest, STRLEN destlen, I32 ck_uni); # define PERL_ARGS_ASSERT_SCAN_IDENT \ - assert(s); assert(dest) + ASSUME(s); ASSUME(dest) STATIC char * S_scan_inputsymbol(pTHX_ char *start) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_INPUTSYMBOL \ - assert(start) + ASSUME(start) STATIC char * S_scan_pat(pTHX_ char *start, I32 type) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_PAT \ - assert(start) + ASSUME(start) STATIC char * S_scan_subst(pTHX_ char *start) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_SUBST \ - assert(start) + ASSUME(start) STATIC char * S_scan_trans(pTHX_ char *start) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SCAN_TRANS \ - assert(start) + ASSUME(start) STATIC I32 S_sublex_done(pTHX) @@ -9500,18 +9722,18 @@ STATIC char * S_swallow_bom(pTHX_ U8 *s) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SWALLOW_BOM \ - assert(s) + ASSUME(s) STATIC char * S_tokenize_use(pTHX_ int is_use, char *s) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_TOKENIZE_USE \ - assert(s) + ASSUME(s) STATIC SV * S_tokeq(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_TOKEQ \ - assert(sv) + ASSUME(sv) STATIC void S_update_debugger_info(pTHX_ SV *orig_sv, const char * const buf, STRLEN len); @@ -9520,41 +9742,41 @@ S_update_debugger_info(pTHX_ SV *orig_sv, const char * const buf, STRLEN len); STATIC void S_warn_expect_operator(pTHX_ const char * const what, char *s, I32 pop_oldbufptr); # define PERL_ARGS_ASSERT_WARN_EXPECT_OPERATOR \ - assert(what) + ASSUME(what) STATIC void S_yyerror_non_ascii_message(pTHX_ const U8 * const s); # define PERL_ARGS_ASSERT_YYERROR_NON_ASCII_MESSAGE \ - assert(s) + ASSUME(s) STATIC int S_yywarn(pTHX_ const char * const s, U32 flags); # define PERL_ARGS_ASSERT_YYWARN \ - assert(s) + ASSUME(s) # if defined(DEBUGGING) STATIC void S_printbuf(pTHX_ const char * const fmt, const char * const s) __attribute__format__(__printf__,pTHX_1,0); # define PERL_ARGS_ASSERT_PRINTBUF \ - assert(fmt); assert(s) + ASSUME(fmt); ASSUME(s) STATIC int S_tokereport(pTHX_ I32 rv, const YYSTYPE *lvalp); # define PERL_ARGS_ASSERT_TOKEREPORT \ - assert(lvalp) + ASSUME(lvalp) # endif /* defined(DEBUGGING) */ # if !defined(PERL_NO_UTF16_FILTER) STATIC U8 * S_add_utf16_textfilter(pTHX_ U8 * const s, bool reversed); # define PERL_ARGS_ASSERT_ADD_UTF16_TEXTFILTER \ - assert(s) + ASSUME(s) STATIC I32 S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen); # define PERL_ARGS_ASSERT_UTF16_TEXTFILTER \ - assert(sv) + ASSUME(sv) # endif /* !defined(PERL_NO_UTF16_FILTER) */ #endif /* defined(PERL_IN_TOKE_C) */ @@ -9562,37 +9784,37 @@ S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen); STATIC bool S_isa_lookup(pTHX_ HV *stash, SV *namesv, const char *name, STRLEN len, U32 flags); # define PERL_ARGS_ASSERT_ISA_LOOKUP \ - assert(stash); assert(SvTYPE(stash) == SVt_PVHV); assert(namesv || name) + ASSUME(stash); ASSUME(SvTYPE(stash) == SVt_PVHV); assert(namesv || name) STATIC bool S_sv_derived_from_svpvn(pTHX_ SV *sv, SV *namesv, const char *name, const STRLEN len, U32 flags); # define PERL_ARGS_ASSERT_SV_DERIVED_FROM_SVPVN \ - assert(sv); assert(namesv || name) + ASSUME(sv); assert(namesv || name) #endif /* defined(PERL_IN_UNIVERSAL_C) */ #if defined(PERL_IN_UTF8_C) STATIC UV S__to_utf8_case(pTHX_ const UV original, const U8 *p, U8 *ustrp, STRLEN *lenp, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal); # define PERL_ARGS_ASSERT__TO_UTF8_CASE \ - assert(ustrp); assert(lenp); assert(invlist); assert(invmap); \ - assert(normal) + ASSUME(ustrp); ASSUME(lenp); ASSUME(invlist); ASSUME(invmap); \ + ASSUME(normal) STATIC UV S_check_locale_boundary_crossing(pTHX_ const U8 * const p, const UV result, U8 * const ustrp, STRLEN *lenp) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \ - assert(p); assert(ustrp); assert(lenp) + ASSUME(p); ASSUME(ustrp); ASSUME(lenp) STATIC HV * S_new_msg_hv(pTHX_ const char * const message, U32 categories, U32 flag) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NEW_MSG_HV \ - assert(message) + ASSUME(message) STATIC UV S_to_case_cp_list(pTHX_ const UV original, const U32 ** const remaining_list, Size_t *remaining_count, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal); # define PERL_ARGS_ASSERT_TO_CASE_CP_LIST \ - assert(invlist); assert(invmap); assert(normal) + ASSUME(invlist); ASSUME(invmap); ASSUME(normal) STATIC U8 S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp, const char dummy) @@ -9602,49 +9824,53 @@ S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp, const char dummy) STATIC UV S_turkic_fc(pTHX_ const U8 * const p, const U8 * const e, U8 *ustrp, STRLEN *lenp); # define PERL_ARGS_ASSERT_TURKIC_FC \ - assert(p); assert(e); assert(ustrp); assert(lenp) + ASSUME(p); ASSUME(e); ASSUME(ustrp); ASSUME(lenp) STATIC UV S_turkic_lc(pTHX_ const U8 * const p0, const U8 * const e, U8 *ustrp, STRLEN *lenp); # define PERL_ARGS_ASSERT_TURKIC_LC \ - assert(p0); assert(e); assert(ustrp); assert(lenp) + ASSUME(p0); ASSUME(e); ASSUME(ustrp); ASSUME(lenp) STATIC UV S_turkic_uc(pTHX_ const U8 * const p, const U8 * const e, U8 *ustrp, STRLEN *lenp); # define PERL_ARGS_ASSERT_TURKIC_UC \ - assert(p); assert(e); assert(ustrp); assert(lenp) + ASSUME(p); ASSUME(e); ASSUME(ustrp); ASSUME(lenp) STATIC char * S_unexpected_non_continuation_text(pTHX_ const U8 * const s, STRLEN print_len, const STRLEN non_cont_byte_pos, const STRLEN expect_len) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_UNEXPECTED_NON_CONTINUATION_TEXT \ - assert(s) + ASSUME(s) # if 0 STATIC void S_warn_on_first_deprecated_use(pTHX_ U32 category, const char * const name, const char * const alternative, const bool use_locale, const char * const file, const unsigned line); # define PERL_ARGS_ASSERT_WARN_ON_FIRST_DEPRECATED_USE \ - assert(name); assert(alternative); assert(file) + ASSUME(name); ASSUME(alternative); ASSUME(file) # endif # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE int S_does_utf8_overflow(const U8 * const s, const U8 *e) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DOES_UTF8_OVERFLOW \ - assert(s); assert(e) + PERL_ASSUME_NON_NULL(s); PERL_ASSUME_NON_NULL(e) PERL_STATIC_INLINE int S_isFF_overlong(const U8 * const s, const STRLEN len) + __attribute__nonnull__(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_ISFF_OVERLONG \ - assert(s) + PERL_ASSUME_NON_NULL(s) PERL_STATIC_INLINE int S_is_utf8_overlong(const U8 * const s, const STRLEN len) + __attribute__nonnull__(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_UTF8_OVERLONG \ - assert(s) + PERL_ASSUME_NON_NULL(s) # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ #endif /* defined(PERL_IN_UTF8_C) */ @@ -9660,20 +9886,24 @@ S_mess_alloc(pTHX); STATIC SV * S_with_queued_errors(pTHX_ SV *ex); # define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS \ - assert(ex) + ASSUME(ex) STATIC void S_xs_version_bootcheck(pTHX_ SSize_t items, SSize_t ax, const char *xs_p, STRLEN xs_len); # define PERL_ARGS_ASSERT_XS_VERSION_BOOTCHECK \ - assert(xs_p) + ASSUME(xs_p) # if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL) STATIC void -S_mem_log_common(enum mem_log_type mlt, const UV n, const UV typesize, const char *type_name, const SV *sv, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); +S_mem_log_common(enum mem_log_type mlt, const UV n, const UV typesize, const char *type_name, const SV *sv, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname) + __attribute__nonnull__(4) + __attribute__nonnull__(8) + __attribute__nonnull__(10); # define PERL_ARGS_ASSERT_MEM_LOG_COMMON \ - assert(type_name); assert(filename); assert(funcname) + PERL_ASSUME_NON_NULL(type_name); PERL_ASSUME_NON_NULL(filename); \ + PERL_ASSUME_NON_NULL(funcname) -# endif +# endif /* defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL) */ # if !defined(PERL_NO_INLINE_FUNCTIONS) PERL_STATIC_INLINE U32 S_ptr_hash(PTRV u); @@ -9689,29 +9919,47 @@ S_pidgone(pTHX_ Pid_t pid, int status); #endif /* defined(PERL_IN_UTIL_C) */ #if defined(PERL_MEM_LOG) PERL_CALLCONV Malloc_t -Perl_mem_log_alloc(const UV nconst, UV typesize, const char *type_name, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); +Perl_mem_log_alloc(const UV nconst, UV typesize, const char *type_name, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname) + __attribute__nonnull__(3) + __attribute__nonnull__(5) + __attribute__nonnull__(7); # define PERL_ARGS_ASSERT_MEM_LOG_ALLOC \ - assert(type_name); assert(filename); assert(funcname) + PERL_ASSUME_NON_NULL(type_name); PERL_ASSUME_NON_NULL(filename); \ + PERL_ASSUME_NON_NULL(funcname) PERL_CALLCONV void -Perl_mem_log_del_sv(const SV *sv, const char *filename, int linenumber, const char *funcname); +Perl_mem_log_del_sv(const SV *sv, const char *filename, int linenumber, const char *funcname) + __attribute__nonnull__(1) + __attribute__nonnull__(2) + __attribute__nonnull__(4); # define PERL_ARGS_ASSERT_MEM_LOG_DEL_SV \ - assert(sv); assert(filename); assert(funcname) + PERL_ASSUME_NON_NULL(sv); PERL_ASSUME_NON_NULL(filename); \ + PERL_ASSUME_NON_NULL(funcname) PERL_CALLCONV Malloc_t -Perl_mem_log_free(Malloc_t oldalloc, const char *filename, const int linenumber, const char *funcname); +Perl_mem_log_free(Malloc_t oldalloc, const char *filename, const int linenumber, const char *funcname) + __attribute__nonnull__(2) + __attribute__nonnull__(4); # define PERL_ARGS_ASSERT_MEM_LOG_FREE \ - assert(filename); assert(funcname) + PERL_ASSUME_NON_NULL(filename); PERL_ASSUME_NON_NULL(funcname) PERL_CALLCONV void -Perl_mem_log_new_sv(const SV *sv, const char *filename, int linenumber, const char *funcname); +Perl_mem_log_new_sv(const SV *sv, const char *filename, int linenumber, const char *funcname) + __attribute__nonnull__(1) + __attribute__nonnull__(2) + __attribute__nonnull__(4); # define PERL_ARGS_ASSERT_MEM_LOG_NEW_SV \ - assert(sv); assert(filename); assert(funcname) + PERL_ASSUME_NON_NULL(sv); PERL_ASSUME_NON_NULL(filename); \ + PERL_ASSUME_NON_NULL(funcname) PERL_CALLCONV Malloc_t -Perl_mem_log_realloc(const UV n, const UV typesize, const char *type_name, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); +Perl_mem_log_realloc(const UV n, const UV typesize, const char *type_name, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname) + __attribute__nonnull__(3) + __attribute__nonnull__(6) + __attribute__nonnull__(8); # define PERL_ARGS_ASSERT_MEM_LOG_REALLOC \ - assert(type_name); assert(filename); assert(funcname) + PERL_ASSUME_NON_NULL(type_name); PERL_ASSUME_NON_NULL(filename); \ + PERL_ASSUME_NON_NULL(funcname) #endif /* defined(PERL_MEM_LOG) */ #if !defined(PERL_NO_INLINE_FUNCTIONS) @@ -9719,67 +9967,71 @@ PERL_STATIC_INLINE SSize_t Perl_AvFILL_(pTHX_ AV *av) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_AVFILL_ \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_STATIC_INLINE I32 * -Perl_CvDEPTH(const CV * const sv); +Perl_CvDEPTH(const CV * const sv) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_CVDEPTH \ - assert(sv) + PERL_ASSUME_NON_NULL(sv) PERL_STATIC_INLINE GV * Perl_CvGV(pTHX_ CV *sv); # define PERL_ARGS_ASSERT_CVGV \ - assert(sv); assert(SvTYPE(sv) == SVt_PVCV || SvTYPE(sv) == SVt_PVFM) + ASSUME(sv); ASSUME(SvTYPE(sv) == SVt_PVCV || SvTYPE(sv) == SVt_PVFM) PERL_STATIC_INLINE Stack_off_t Perl_POPMARK(pTHX); # define PERL_ARGS_ASSERT_POPMARK PERL_STATIC_INLINE struct regexp * -Perl_ReANY(const REGEXP * const re); +Perl_ReANY(const REGEXP * const re) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_REANY \ - assert(re) + PERL_ASSUME_NON_NULL(re) PERL_STATIC_INLINE void -Perl_SvAMAGIC_off(SV *sv); +Perl_SvAMAGIC_off(SV *sv) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_SVAMAGIC_OFF \ - assert(sv) + PERL_ASSUME_NON_NULL(sv) PERL_STATIC_INLINE void -Perl_SvAMAGIC_on(SV *sv); +Perl_SvAMAGIC_on(SV *sv) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_SVAMAGIC_ON \ - assert(sv) + PERL_ASSUME_NON_NULL(sv) PERL_STATIC_INLINE void Perl_SvGETMAGIC(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_SVGETMAGIC \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE IV Perl_SvIV(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_SVIV \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE IV Perl_SvIV_nomg(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_SVIV_NOMG \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE NV Perl_SvNV(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_SVNV \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE NV Perl_SvNV_nomg(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_SVNV_NOMG \ - assert(sv) + ASSUME(sv) PERL_STATIC_FORCE_INLINE bool Perl_SvPVXtrue(pTHX_ SV *sv) __attribute__always_inline__; # define PERL_ARGS_ASSERT_SVPVXTRUE \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE void Perl_SvREFCNT_dec(pTHX_ SV *sv); @@ -9788,7 +10040,7 @@ Perl_SvREFCNT_dec(pTHX_ SV *sv); PERL_STATIC_INLINE void Perl_SvREFCNT_dec_NN(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_SVREFCNT_DEC_NN \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE SV * Perl_SvREFCNT_dec_ret_NULL(pTHX_ SV *sv); @@ -9799,9 +10051,10 @@ Perl_SvREFCNT_inc(SV *sv); # define PERL_ARGS_ASSERT_SVREFCNT_INC PERL_STATIC_INLINE SV * -Perl_SvREFCNT_inc_NN(SV *sv); +Perl_SvREFCNT_inc_NN(SV *sv) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_SVREFCNT_INC_NN \ - assert(sv) + PERL_ASSUME_NON_NULL(sv) PERL_STATIC_INLINE void Perl_SvREFCNT_inc_void(SV *sv); @@ -9814,12 +10067,12 @@ Perl_SvTRUE(pTHX_ SV *sv); PERL_STATIC_INLINE bool Perl_SvTRUE_NN(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_SVTRUE_NN \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE bool Perl_SvTRUE_common(pTHX_ SV *sv, const bool sv_2bool_is_fallback); # define PERL_ARGS_ASSERT_SVTRUE_COMMON \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE bool Perl_SvTRUE_nomg(pTHX_ SV *sv); @@ -9828,31 +10081,31 @@ Perl_SvTRUE_nomg(pTHX_ SV *sv); PERL_STATIC_INLINE UV Perl_SvUV(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_SVUV \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE UV Perl_SvUV_nomg(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_SVUV_NOMG \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE Stack_off_t Perl_TOPMARK(pTHX); # define PERL_ARGS_ASSERT_TOPMARK # define PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE \ - assert(dest) + PERL_ASSUME_NON_NULL(dest) PERL_STATIC_INLINE Size_t Perl_av_count(pTHX_ AV *av) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_AV_COUNT \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_STATIC_INLINE SV ** Perl_av_fetch_simple(pTHX_ AV *av, SSize_t key, I32 lval) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_AV_FETCH_SIMPLE \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_STATIC_INLINE AV * Perl_av_new_alloc(pTHX_ SSize_t size, bool zeroflag) @@ -9863,47 +10116,47 @@ Perl_av_new_alloc(pTHX_ SSize_t size, bool zeroflag) PERL_STATIC_INLINE void Perl_av_push_simple(pTHX_ AV *av, SV *val); # define PERL_ARGS_ASSERT_AV_PUSH_SIMPLE \ - assert(av); assert(SvTYPE(av) == SVt_PVAV); assert(val) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV); ASSUME(val) PERL_STATIC_INLINE void Perl_av_remove_offset(pTHX_ AV *av); # define PERL_ARGS_ASSERT_AV_REMOVE_OFFSET \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_STATIC_INLINE SV ** Perl_av_store_simple(pTHX_ AV *av, SSize_t key, SV *val); # define PERL_ARGS_ASSERT_AV_STORE_SIMPLE \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_STATIC_INLINE U8 * Perl_bytes_to_utf8(pTHX_ const U8 *s, STRLEN *lenp); # define PERL_ARGS_ASSERT_BYTES_TO_UTF8 \ - assert(s); assert(lenp) + ASSUME(s); ASSUME(lenp) PERL_STATIC_INLINE U8 * Perl_bytes_to_utf8_temp_pv(pTHX_ const U8 *s, STRLEN *lenp); # define PERL_ARGS_ASSERT_BYTES_TO_UTF8_TEMP_PV \ - assert(s); assert(lenp) + ASSUME(s); ASSUME(lenp) PERL_STATIC_INLINE void Perl_clear_defarray_simple(pTHX_ AV *av); # define PERL_ARGS_ASSERT_CLEAR_DEFARRAY_SIMPLE \ - assert(av); assert(SvTYPE(av) == SVt_PVAV) + ASSUME(av); ASSUME(SvTYPE(av) == SVt_PVAV) PERL_STATIC_INLINE I32 Perl_foldEQ(pTHX_ const char *a, const char *b, I32 len); # define PERL_ARGS_ASSERT_FOLDEQ \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) PERL_STATIC_INLINE I32 Perl_foldEQ_latin1(pTHX_ const char *a, const char *b, I32 len); # define PERL_ARGS_ASSERT_FOLDEQ_LATIN1 \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) PERL_STATIC_INLINE I32 Perl_foldEQ_locale(pTHX_ const char *a, const char *b, I32 len); # define PERL_ARGS_ASSERT_FOLDEQ_LOCALE \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) PERL_STATIC_INLINE MGVTBL * Perl_get_vtbl(pTHX_ int vtbl_id) @@ -9912,76 +10165,93 @@ Perl_get_vtbl(pTHX_ int vtbl_id) PERL_STATIC_INLINE Size_t Perl_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_ISC9_STRICT_UTF8_CHAR \ - assert(s0); assert(e) + PERL_ASSUME_NON_NULL(s0); PERL_ASSUME_NON_NULL(e) PERL_STATIC_INLINE Size_t Perl_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_ISSTRICT_UTF8_CHAR \ - assert(s0); assert(e) + PERL_ASSUME_NON_NULL(s0); PERL_ASSUME_NON_NULL(e) PERL_STATIC_INLINE Size_t Perl_isUTF8_CHAR(const U8 * const s0, const U8 * const e) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_ISUTF8_CHAR \ - assert(s0); assert(e) + PERL_ASSUME_NON_NULL(s0); PERL_ASSUME_NON_NULL(e) PERL_STATIC_INLINE Size_t Perl_isUTF8_CHAR_flags(const U8 * const s0, const U8 * const e, const U32 flags) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_ISUTF8_CHAR_FLAGS \ - assert(s0); assert(e) + PERL_ASSUME_NON_NULL(s0); PERL_ASSUME_NON_NULL(e) PERL_STATIC_INLINE bool -Perl_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el); +Perl_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING_LOCLEN \ - assert(s) + PERL_ASSUME_NON_NULL(s) PERL_STATIC_INLINE bool Perl_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_SAFE_SYSCALL \ - assert(pv); assert(what); assert(op_name) + ASSUME(pv); ASSUME(what); ASSUME(op_name) PERL_STATIC_INLINE bool -Perl_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el); +Perl_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING_LOCLEN \ - assert(s) + PERL_ASSUME_NON_NULL(s) PERL_STATIC_INLINE bool -Perl_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags); +Perl_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_LOCLEN_FLAGS \ - assert(s) + PERL_ASSUME_NON_NULL(s) PERL_STATIC_INLINE bool Perl_is_utf8_invariant_string_loc(const U8 * const s, STRLEN len, const U8 **ep) + __attribute__nonnull__(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_UTF8_INVARIANT_STRING_LOC \ - assert(s) + PERL_ASSUME_NON_NULL(s) PERL_STATIC_INLINE bool Perl_is_utf8_string_flags(const U8 *s, STRLEN len, const U32 flags) + __attribute__nonnull__(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_UTF8_STRING_FLAGS \ - assert(s) + PERL_ASSUME_NON_NULL(s) PERL_STATIC_INLINE bool -Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el); +Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN \ - assert(s) + PERL_ASSUME_NON_NULL(s) PERL_STATIC_INLINE bool -Perl_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags); +Perl_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN_FLAGS \ - assert(s) + PERL_ASSUME_NON_NULL(s) PERL_STATIC_INLINE bool Perl_is_utf8_valid_partial_char_flags(const U8 * const s0, const U8 * const e, const U32 flags) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR_FLAGS \ - assert(s0); assert(e) + PERL_ASSUME_NON_NULL(s0); PERL_ASSUME_NON_NULL(e) PERL_STATIC_INLINE unsigned Perl_lsbit_pos32(U32 word) @@ -9990,9 +10260,10 @@ Perl_lsbit_pos32(U32 word) PERL_STATIC_INLINE char * Perl_mortal_getenv(const char *str) + __attribute__nonnull__(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_MORTAL_GETENV \ - assert(str) + PERL_ASSUME_NON_NULL(str) PERL_STATIC_INLINE unsigned Perl_msbit_pos32(U32 word) @@ -10008,7 +10279,7 @@ PERL_STATIC_INLINE SV * Perl_newRV_noinc(pTHX_ SV * const tmpRef) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NEWRV_NOINC \ - assert(tmpRef) + ASSUME(tmpRef) PERL_STATIC_INLINE SV * Perl_newSV_type(pTHX_ const svtype type) @@ -10029,7 +10300,7 @@ Perl_newSVsv_flags(pTHX_ SV * const old, I32 flags) PERL_STATIC_INLINE SV * Perl_new_sv(pTHX_ const char *file, int line, const char *func); # define PERL_ARGS_ASSERT_NEW_SV \ - assert(file); assert(func) + ASSUME(file); ASSUME(func) PERL_STATIC_INLINE void Perl_pop_stackinfo(pTHX); @@ -10042,7 +10313,7 @@ Perl_push_stackinfo(pTHX_ I32 type, UV flags); PERL_STATIC_INLINE void Perl_rpp_context(pTHX_ SV **mark, U8 gimme, SSize_t extra); # define PERL_ARGS_ASSERT_RPP_CONTEXT \ - assert(mark) + ASSUME(mark) PERL_STATIC_INLINE void Perl_rpp_extend(pTHX_ SSize_t n); @@ -10051,12 +10322,12 @@ Perl_rpp_extend(pTHX_ SSize_t n); PERL_STATIC_INLINE void Perl_rpp_invoke_xs(pTHX_ CV *cv); # define PERL_ARGS_ASSERT_RPP_INVOKE_XS \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_STATIC_INLINE bool Perl_rpp_is_lone(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_RPP_IS_LONE \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE SV * Perl_rpp_pop_1_norc(pTHX); @@ -10081,87 +10352,87 @@ Perl_rpp_popfree_2_NN(pTHX); PERL_STATIC_INLINE void Perl_rpp_popfree_to(pTHX_ SV **sp); # define PERL_ARGS_ASSERT_RPP_POPFREE_TO \ - assert(sp) + ASSUME(sp) PERL_STATIC_INLINE void Perl_rpp_popfree_to_NN(pTHX_ SV **sp); # define PERL_ARGS_ASSERT_RPP_POPFREE_TO_NN \ - assert(sp) + ASSUME(sp) PERL_STATIC_INLINE void Perl_rpp_push_1(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_RPP_PUSH_1 \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE void Perl_rpp_push_1_norc(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_RPP_PUSH_1_NORC \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE void Perl_rpp_push_2(pTHX_ SV *sv1, SV *sv2); # define PERL_ARGS_ASSERT_RPP_PUSH_2 \ - assert(sv1); assert(sv2) + ASSUME(sv1); ASSUME(sv2) PERL_STATIC_INLINE void Perl_rpp_push_IMM(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_RPP_PUSH_IMM \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE void Perl_rpp_replace_1_1(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_RPP_REPLACE_1_1 \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE void Perl_rpp_replace_1_1_NN(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_RPP_REPLACE_1_1_NN \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE void Perl_rpp_replace_1_IMM_NN(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_RPP_REPLACE_1_IMM_NN \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE void Perl_rpp_replace_2_1(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_RPP_REPLACE_2_1 \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE void Perl_rpp_replace_2_1_COMMON(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_RPP_REPLACE_2_1_COMMON \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE void Perl_rpp_replace_2_1_NN(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_RPP_REPLACE_2_1_NN \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE void Perl_rpp_replace_2_IMM_NN(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_RPP_REPLACE_2_IMM_NN \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE void Perl_rpp_replace_at(pTHX_ SV **sp, SV *sv); # define PERL_ARGS_ASSERT_RPP_REPLACE_AT \ - assert(sp); assert(sv) + ASSUME(sp); ASSUME(sv) PERL_STATIC_INLINE void Perl_rpp_replace_at_NN(pTHX_ SV **sp, SV *sv); # define PERL_ARGS_ASSERT_RPP_REPLACE_AT_NN \ - assert(sp); assert(sv) + ASSUME(sp); ASSUME(sv) PERL_STATIC_INLINE void Perl_rpp_replace_at_norc(pTHX_ SV **sp, SV *sv); # define PERL_ARGS_ASSERT_RPP_REPLACE_AT_NORC \ - assert(sp); assert(sv) + ASSUME(sp); ASSUME(sv) PERL_STATIC_INLINE void Perl_rpp_replace_at_norc_NN(pTHX_ SV **sp, SV *sv); # define PERL_ARGS_ASSERT_RPP_REPLACE_AT_NORC_NN \ - assert(sp); assert(sv) + ASSUME(sp); ASSUME(sv) PERL_STATIC_INLINE bool Perl_rpp_stack_is_rc(pTHX); @@ -10178,17 +10449,17 @@ Perl_rpp_try_AMAGIC_2(pTHX_ int method, int flags); PERL_STATIC_INLINE void Perl_rpp_xpush_1(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_RPP_XPUSH_1 \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE void Perl_rpp_xpush_2(pTHX_ SV *sv1, SV *sv2); # define PERL_ARGS_ASSERT_RPP_XPUSH_2 \ - assert(sv1); assert(sv2) + ASSUME(sv1); ASSUME(sv2) PERL_STATIC_INLINE void Perl_rpp_xpush_IMM(pTHX_ SV *sv); # define PERL_ARGS_ASSERT_RPP_XPUSH_IMM \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE char * Perl_savepv(pTHX_ const char *pv) @@ -10207,14 +10478,14 @@ Perl_savesharedsvpv(pTHX_ SV *sv) __attribute__malloc__ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SAVESHAREDSVPV \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE char * Perl_savesvpv(pTHX_ SV *sv) __attribute__malloc__ __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SAVESVPV \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE unsigned Perl_single_1bit_pos32(U32 word) @@ -10222,205 +10493,222 @@ Perl_single_1bit_pos32(U32 word) # define PERL_ARGS_ASSERT_SINGLE_1BIT_POS32 # define PERL_ARGS_ASSERT_SV_ONLY_TAINT_GMAGIC \ - assert(sv) + PERL_ASSUME_NON_NULL(sv) PERL_STATIC_INLINE char * Perl_sv_pvbyten_force_wrapper(pTHX_ SV * const sv, STRLEN * const lp, const U32 dummy); # define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE_WRAPPER \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE char * Perl_sv_pvutf8n_force_wrapper(pTHX_ SV * const sv, STRLEN * const lp, const U32 dummy); # define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE_WRAPPER \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE char * Perl_sv_setpv_freshbuf(pTHX_ SV * const sv); # define PERL_ARGS_ASSERT_SV_SETPV_FRESHBUF \ - assert(sv) + ASSUME(sv) PERL_STATIC_INLINE void Perl_switch_argstack(pTHX_ AV *to); # define PERL_ARGS_ASSERT_SWITCH_ARGSTACK \ - assert(to); assert(SvTYPE(to) == SVt_PVAV) + ASSUME(to); ASSUME(SvTYPE(to) == SVt_PVAV) PERL_STATIC_INLINE IV Perl_utf8_distance(pTHX_ const U8 *a, const U8 *b) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_UTF8_DISTANCE \ - assert(a); assert(b) + ASSUME(a); ASSUME(b) PERL_STATIC_INLINE U8 * Perl_utf8_hop(const U8 *s, SSize_t off) + __attribute__nonnull__(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_UTF8_HOP \ - assert(s) + PERL_ASSUME_NON_NULL(s) PERL_STATIC_INLINE U8 * Perl_utf8_hop_back_overshoot(const U8 *s, SSize_t off, const U8 * const start, SSize_t *remaining) + __attribute__nonnull__(1) + __attribute__nonnull__(3) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_UTF8_HOP_BACK_OVERSHOOT \ - assert(s); assert(start) + PERL_ASSUME_NON_NULL(s); PERL_ASSUME_NON_NULL(start) PERL_STATIC_INLINE U8 * Perl_utf8_hop_forward_overshoot(const U8 *s, SSize_t off, const U8 * const end, SSize_t *remaining) + __attribute__nonnull__(1) + __attribute__nonnull__(3) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_UTF8_HOP_FORWARD_OVERSHOOT \ - assert(s); assert(end) + PERL_ASSUME_NON_NULL(s); PERL_ASSUME_NON_NULL(end) PERL_STATIC_INLINE U8 * Perl_utf8_hop_overshoot(const U8 *s, SSize_t off, const U8 * const start, const U8 * const end, SSize_t *remaining) + __attribute__nonnull__(1) + __attribute__nonnull__(3) + __attribute__nonnull__(4) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_UTF8_HOP_OVERSHOOT \ - assert(s); assert(start); assert(end) + PERL_ASSUME_NON_NULL(s); PERL_ASSUME_NON_NULL(start); \ + PERL_ASSUME_NON_NULL(end) PERL_STATIC_INLINE bool Perl_utf8_to_bytes_new_pv(pTHX_ U8 const **s_ptr, STRLEN *lenp, void **free_me); # define PERL_ARGS_ASSERT_UTF8_TO_BYTES_NEW_PV \ - assert(s_ptr); assert(lenp); assert(free_me) + ASSUME(s_ptr); ASSUME(lenp); ASSUME(free_me) PERL_STATIC_INLINE bool Perl_utf8_to_bytes_overwrite(pTHX_ U8 **s_ptr, STRLEN *lenp); # define PERL_ARGS_ASSERT_UTF8_TO_BYTES_OVERWRITE \ - assert(s_ptr); assert(lenp) + ASSUME(s_ptr); ASSUME(lenp) PERL_STATIC_INLINE bool Perl_utf8_to_bytes_temp_pv(pTHX_ U8 const **s_ptr, STRLEN *lenp); # define PERL_ARGS_ASSERT_UTF8_TO_BYTES_TEMP_PV \ - assert(s_ptr); assert(lenp) + ASSUME(s_ptr); ASSUME(lenp) PERL_STATIC_INLINE bool -Perl_utf8_to_uv_msgs(const U8 * const s0, const U8 *e, UV *cp_p, Size_t *advance_p, U32 flags, U32 *errors, AV **msgs); +Perl_utf8_to_uv_msgs(const U8 * const s0, const U8 *e, UV *cp_p, Size_t *advance_p, U32 flags, U32 *errors, AV **msgs) + __attribute__nonnull__(1) + __attribute__nonnull__(2) + __attribute__nonnull__(3); # define PERL_ARGS_ASSERT_UTF8_TO_UV_MSGS \ - assert(s0); assert(e); assert(cp_p) + PERL_ASSUME_NON_NULL(s0); PERL_ASSUME_NON_NULL(e); \ + PERL_ASSUME_NON_NULL(cp_p) PERL_STATIC_INLINE UV -Perl_utf8_to_uv_or_die(const U8 * const s, const U8 *e, Size_t *advance_p); +Perl_utf8_to_uv_or_die(const U8 * const s, const U8 *e, Size_t *advance_p) + __attribute__nonnull__(1) + __attribute__nonnull__(2); # define PERL_ARGS_ASSERT_UTF8_TO_UV_OR_DIE \ - assert(s); assert(e) + PERL_ASSUME_NON_NULL(s); PERL_ASSUME_NON_NULL(e) PERL_STATIC_INLINE UV Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen); # define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF \ - assert(s); assert(send) + ASSUME(s); ASSUME(send) PERL_STATIC_INLINE UV -Perl_utf8n_to_uvchr_msgs(const U8 * const s0, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 *errors, AV **msgs); +Perl_utf8n_to_uvchr_msgs(const U8 * const s0, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 *errors, AV **msgs) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_MSGS \ - assert(s0) + PERL_ASSUME_NON_NULL(s0) PERL_STATIC_INLINE U8 * Perl_uv_to_utf8(pTHX_ U8 *d, UV uv); # define PERL_ARGS_ASSERT_UV_TO_UTF8 \ - assert(d) + ASSUME(d) PERL_STATIC_INLINE U8 * Perl_uv_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); # define PERL_ARGS_ASSERT_UV_TO_UTF8_FLAGS \ - assert(d) + ASSUME(d) PERL_STATIC_INLINE UV Perl_valid_utf8_to_uv(const U8 *s, STRLEN *retlen) + __attribute__nonnull__(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_VALID_UTF8_TO_UV \ - assert(s) + PERL_ASSUME_NON_NULL(s) PERL_STATIC_INLINE void Perl_cx_popblock(pTHX_ PERL_CONTEXT *cx); # define PERL_ARGS_ASSERT_CX_POPBLOCK \ - assert(cx) + ASSUME(cx) PERL_STATIC_INLINE void Perl_cx_popeval(pTHX_ PERL_CONTEXT *cx); # define PERL_ARGS_ASSERT_CX_POPEVAL \ - assert(cx) + ASSUME(cx) PERL_STATIC_INLINE void Perl_cx_popformat(pTHX_ PERL_CONTEXT *cx); # define PERL_ARGS_ASSERT_CX_POPFORMAT \ - assert(cx) + ASSUME(cx) PERL_STATIC_INLINE void Perl_cx_popgiven(pTHX_ PERL_CONTEXT *cx); # define PERL_ARGS_ASSERT_CX_POPGIVEN \ - assert(cx) + ASSUME(cx) PERL_STATIC_INLINE void Perl_cx_poploop(pTHX_ PERL_CONTEXT *cx); # define PERL_ARGS_ASSERT_CX_POPLOOP \ - assert(cx) + ASSUME(cx) PERL_STATIC_INLINE void Perl_cx_popsub(pTHX_ PERL_CONTEXT *cx); # define PERL_ARGS_ASSERT_CX_POPSUB \ - assert(cx) + ASSUME(cx) PERL_STATIC_INLINE void Perl_cx_popsub_args(pTHX_ PERL_CONTEXT *cx); # define PERL_ARGS_ASSERT_CX_POPSUB_ARGS \ - assert(cx) + ASSUME(cx) PERL_STATIC_INLINE void Perl_cx_popsub_common(pTHX_ PERL_CONTEXT *cx); # define PERL_ARGS_ASSERT_CX_POPSUB_COMMON \ - assert(cx) + ASSUME(cx) PERL_STATIC_INLINE void Perl_cx_popwhen(pTHX_ PERL_CONTEXT *cx); # define PERL_ARGS_ASSERT_CX_POPWHEN \ - assert(cx) + ASSUME(cx) PERL_STATIC_INLINE PERL_CONTEXT * Perl_cx_pushblock(pTHX_ U8 type, U8 gimme, SV **sp, I32 saveix); # define PERL_ARGS_ASSERT_CX_PUSHBLOCK \ - assert(sp) + ASSUME(sp) PERL_STATIC_INLINE void Perl_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv); # define PERL_ARGS_ASSERT_CX_PUSHEVAL \ - assert(cx) + ASSUME(cx) PERL_STATIC_INLINE void Perl_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv); # define PERL_ARGS_ASSERT_CX_PUSHFORMAT \ - assert(cx); assert(cv); \ - assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(cx); ASSUME(cv); \ + ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_STATIC_INLINE void Perl_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv); # define PERL_ARGS_ASSERT_CX_PUSHGIVEN \ - assert(cx) + ASSUME(cx) PERL_STATIC_INLINE void Perl_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV *itersave); # define PERL_ARGS_ASSERT_CX_PUSHLOOP_FOR \ - assert(cx); assert(itervarp) + ASSUME(cx); ASSUME(itervarp) PERL_STATIC_INLINE void Perl_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx); # define PERL_ARGS_ASSERT_CX_PUSHLOOP_PLAIN \ - assert(cx) + ASSUME(cx) PERL_STATIC_INLINE void Perl_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs); # define PERL_ARGS_ASSERT_CX_PUSHSUB \ - assert(cx); assert(cv); \ - assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(cx); ASSUME(cv); \ + ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) PERL_STATIC_INLINE void Perl_cx_pushtry(pTHX_ PERL_CONTEXT *cx, OP *retop); # define PERL_ARGS_ASSERT_CX_PUSHTRY \ - assert(cx) + ASSUME(cx) PERL_STATIC_INLINE void Perl_cx_pushwhen(pTHX_ PERL_CONTEXT *cx); # define PERL_ARGS_ASSERT_CX_PUSHWHEN \ - assert(cx) + ASSUME(cx) PERL_STATIC_INLINE void Perl_cx_topblock(pTHX_ PERL_CONTEXT *cx); # define PERL_ARGS_ASSERT_CX_TOPBLOCK \ - assert(cx) + ASSUME(cx) PERL_STATIC_INLINE U8 Perl_gimme_V(pTHX); @@ -10431,41 +10719,40 @@ PERL_STATIC_INLINE Size_t Perl_my_strlcat(char *dst, const char *src, Size_t size); # define PERL_ARGS_ASSERT_MY_STRLCAT -# endif -# if !defined(HAS_STRNLEN) -PERL_STATIC_INLINE Size_t -Perl_my_strnlen(const char *str, Size_t maxlen); -# define PERL_ARGS_ASSERT_MY_STRNLEN \ - assert(str) - # endif # if defined(PERL_CORE) || defined(PERL_EXT) PERL_STATIC_INLINE void -Perl_append_utf8_from_native_byte(const U8 byte, U8 **dest); +Perl_append_utf8_from_native_byte(const U8 byte, U8 **dest) + __attribute__nonnull__(2); PERL_STATIC_INLINE bool -Perl_sv_only_taint_gmagic(SV *sv); +Perl_sv_only_taint_gmagic(SV *sv) + __attribute__nonnull__(1); PERL_STATIC_INLINE bool Perl_is_utf8_non_invariant_string(const U8 * const s, STRLEN len) + __attribute__nonnull__(1) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_IS_UTF8_NON_INVARIANT_STRING \ - assert(s) + PERL_ASSUME_NON_NULL(s) PERL_STATIC_INLINE STRLEN S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp); # define PERL_ARGS_ASSERT_SV_OR_PV_POS_U2B \ - assert(sv); assert(pv) + ASSUME(sv); ASSUME(pv) PERL_STATIC_INLINE Size_t S_variant_under_utf8_count(const U8 * const s, const U8 * const e) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_VARIANT_UNDER_UTF8_COUNT \ - assert(s); assert(e) + PERL_ASSUME_NON_NULL(s); PERL_ASSUME_NON_NULL(e) # if !defined(HAS_MEMRCHR) PERL_STATIC_INLINE void * -S_my_memrchr(const char *s, const char c, const STRLEN len); +S_my_memrchr(const char *s, const char c, const STRLEN len) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_MY_MEMRCHR \ - assert(s) + PERL_ASSUME_NON_NULL(s) # endif # if defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || \ @@ -10474,15 +10761,19 @@ S_my_memrchr(const char *s, const char c, const STRLEN len); defined(PERL_IN_UTF8_C) PERL_STATIC_INLINE bool S__invlist_contains_cp(SV * const invlist, const UV cp) + __attribute__nonnull__(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE UV S__invlist_len(SV * const invlist) + __attribute__nonnull__(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE bool * S_get_invlist_offset_addr(SV *invlist) + __attribute__nonnull__(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE UV * S_invlist_array(SV * const invlist) + __attribute__nonnull__(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE bool S_is_invlist(const SV * const invlist) @@ -10500,6 +10791,7 @@ PERL_STATIC_INLINE void S_invlist_extend(pTHX_ SV * const invlist, const UV len); PERL_STATIC_INLINE UV S_invlist_highest(SV * const invlist) + __attribute__nonnull__(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV * const invlist, const UV len, const bool offset); @@ -10508,7 +10800,8 @@ S_invlist_set_len(pTHX_ SV * const invlist, const UV len, const bool offset); # if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_ANY) || \ defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C) PERL_STATIC_INLINE const char * -S_get_regex_charset_name(const U32 flags, STRLEN * const lenp); +S_get_regex_charset_name(const U32 flags, STRLEN * const lenp) + __attribute__nonnull__(2); # endif # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # if defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || \ @@ -10516,16 +10809,16 @@ S_get_regex_charset_name(const U32 flags, STRLEN * const lenp); defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C) || \ defined(PERL_IN_UTF8_C) # define PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # define PERL_ARGS_ASSERT__INVLIST_LEN \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # define PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # define PERL_ARGS_ASSERT_INVLIST_ARRAY \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # define PERL_ARGS_ASSERT_IS_INVLIST @@ -10538,61 +10831,70 @@ S_get_regex_charset_name(const U32 flags, STRLEN * const lenp); # define PERL_ARGS_ASSERT_ADD_CP_TO_INVLIST # define PERL_ARGS_ASSERT_INVLIST_EXTEND \ - assert(invlist) + ASSUME(invlist) # define PERL_ARGS_ASSERT_INVLIST_HIGHEST \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # define PERL_ARGS_ASSERT_INVLIST_SET_LEN \ - assert(invlist) + ASSUME(invlist) # endif /* defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_REGCOMP_ANY) */ # if defined(PERL_IN_OP_C) || defined(PERL_IN_PAD_C) PERL_STATIC_INLINE bool -S_PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq); +S_PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_PADNAMEIN_SCOPE \ - assert(pn) + PERL_ASSUME_NON_NULL(pn) # endif # if defined(PERL_IN_OP_C) || defined(PERL_IN_REGCOMP_ANY) # define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # define PERL_ARGS_ASSERT_INVLIST_ITERFINISH \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # define PERL_ARGS_ASSERT_INVLIST_ITERINIT \ - assert(invlist) + PERL_ASSUME_NON_NULL(invlist) # define PERL_ARGS_ASSERT_INVLIST_ITERNEXT \ - assert(invlist); assert(start); assert(end) + PERL_ASSUME_NON_NULL(invlist); PERL_ASSUME_NON_NULL(start); \ + PERL_ASSUME_NON_NULL(end) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_STATIC_INLINE STRLEN * S_get_invlist_iter_addr(SV *invlist) + __attribute__nonnull__(1) __attribute__warn_unused_result__; PERL_STATIC_INLINE void -S_invlist_iterfinish(SV *invlist); +S_invlist_iterfinish(SV *invlist) + __attribute__nonnull__(1); PERL_STATIC_INLINE void -S_invlist_iterinit(SV *invlist); +S_invlist_iterinit(SV *invlist) + __attribute__nonnull__(1); PERL_STATIC_INLINE bool S_invlist_iternext(SV *invlist, UV *start, UV *end) + __attribute__nonnull__(1) + __attribute__nonnull__(2) + __attribute__nonnull__(3) __attribute__warn_unused_result__; # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # endif /* defined(PERL_IN_OP_C) || defined(PERL_IN_REGCOMP_ANY) */ # if defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C) PERL_STATIC_INLINE bool S_lossless_NV_to_IV(const NV nv, IV *ivp) + __attribute__nonnull__(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_LOSSLESS_NV_TO_IV \ - assert(ivp) + PERL_ASSUME_NON_NULL(ivp) # endif # if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_ANY) || \ defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C) # define PERL_ARGS_ASSERT_GET_REGEX_CHARSET_NAME \ - assert(lenp) + PERL_ASSUME_NON_NULL(lenp) # endif # if defined(U64TYPE) @@ -10616,13 +10918,13 @@ Perl_single_1bit_pos64(U64 word) PERL_STATIC_INLINE AV * Perl_cop_file_avn(pTHX_ const COP *cop); # define PERL_ARGS_ASSERT_COP_FILE_AVN \ - assert(cop) + ASSUME(cop) # if !defined(PERL_IMPLICIT_SYS) PERL_STATIC_INLINE bool S_PerlEnv_putenv(pTHX_ char *str); # define PERL_ARGS_ASSERT_PERLENV_PUTENV \ - assert(str) + ASSUME(str) # endif # endif /* defined(USE_ITHREADS) */ @@ -10636,7 +10938,7 @@ Perl_get_context(void) #endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ #if defined(PERL_RC_STACK) # define PERL_ARGS_ASSERT_PP_WRAP \ - assert(real_pp_fn) + ASSUME(real_pp_fn) PERL_CALLCONV int Perl_runops_wrap(pTHX); @@ -10645,8 +10947,8 @@ Perl_runops_wrap(pTHX); PERL_CALLCONV void Perl_xs_wrap(pTHX_ XSUBADDR_t xsub, CV *cv); # define PERL_ARGS_ASSERT_XS_WRAP \ - assert(xsub); assert(cv); \ - assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(xsub); ASSUME(cv); \ + ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV OP * @@ -10681,14 +10983,14 @@ Perl_sighandler(int sig) PERL_CALLCONV I32 Perl_unlnk(pTHX_ const char *f); # define PERL_ARGS_ASSERT_UNLNK \ - assert(f) + ASSUME(f) #endif #if defined(USE_C_BACKTRACE) PERL_CALLCONV bool Perl_dump_c_backtrace(pTHX_ PerlIO *fp, int max_depth, int skip); # define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE \ - assert(fp) + ASSUME(fp) /* PERL_CALLCONV void free_c_backtrace(pTHX_ Perl_c_backtrace *bt); */ @@ -10705,13 +11007,13 @@ Perl_get_c_backtrace_dump(pTHX_ int max_depth, int skip); #endif /* defined(USE_C_BACKTRACE) */ #if defined(USE_DTRACE) # define PERL_ARGS_ASSERT_DTRACE_PROBE_CALL \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + ASSUME(cv); ASSUME(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) # define PERL_ARGS_ASSERT_DTRACE_PROBE_LOAD \ - assert(name) + ASSUME(name) # define PERL_ARGS_ASSERT_DTRACE_PROBE_OP \ - assert(op) + ASSUME(op) # define PERL_ARGS_ASSERT_DTRACE_PROBE_PHASE @@ -10730,154 +11032,158 @@ Perl_dtrace_probe_phase(pTHX_ enum perl_phase phase); PERL_CALLCONV PADOFFSET Perl_alloccopstash(pTHX_ HV *hv); # define PERL_ARGS_ASSERT_ALLOCCOPSTASH \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + ASSUME(hv); ASSUME(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void * Perl_any_dup(pTHX_ void *v, const PerlInterpreter *proto_perl) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_ANY_DUP \ - assert(proto_perl) + ASSUME(proto_perl) PERL_CALLCONV void -Perl_clone_params_del(CLONE_PARAMS *param); +Perl_clone_params_del(CLONE_PARAMS *param) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_CLONE_PARAMS_DEL \ - assert(param) + PERL_ASSUME_NON_NULL(param) PERL_CALLCONV CLONE_PARAMS * Perl_clone_params_new(PerlInterpreter * const from, PerlInterpreter * const to) + __attribute__nonnull__(1) + __attribute__nonnull__(2) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_CLONE_PARAMS_NEW \ - assert(from); assert(to) + PERL_ASSUME_NON_NULL(from); PERL_ASSUME_NON_NULL(to) PERL_CALLCONV PERL_CONTEXT * Perl_cx_dup(pTHX_ PERL_CONTEXT *cx, I32 ix, I32 max, CLONE_PARAMS *param) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_CX_DUP \ - assert(param) + ASSUME(param) PERL_CALLCONV DIR * Perl_dirp_dup(pTHX_ DIR * const dp, CLONE_PARAMS * const param) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_DIRP_DUP \ - assert(param) + ASSUME(param) PERL_CALLCONV PerlIO * Perl_fp_dup(pTHX_ PerlIO * const fp, const char type, CLONE_PARAMS * const param); # define PERL_ARGS_ASSERT_FP_DUP \ - assert(param) + ASSUME(param) PERL_CALLCONV GP * Perl_gp_dup(pTHX_ GP * const gp, CLONE_PARAMS * const param) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_GP_DUP \ - assert(param) + ASSUME(param) PERL_CALLCONV HE * Perl_he_dup(pTHX_ const HE *e, bool shared, CLONE_PARAMS *param) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_HE_DUP \ - assert(param) + ASSUME(param) PERL_CALLCONV HEK * Perl_hek_dup(pTHX_ HEK *e, CLONE_PARAMS *param) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_HEK_DUP \ - assert(param) + ASSUME(param) PERL_CALLCONV MAGIC * Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS * const param) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_MG_DUP \ - assert(param) + ASSUME(param) PERL_CALLCONV struct mro_meta * Perl_mro_meta_dup(pTHX_ struct mro_meta *smeta, CLONE_PARAMS *param) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MRO_META_DUP \ - assert(smeta); assert(param) + ASSUME(smeta); ASSUME(param) PERL_CALLCONV OP * Perl_newPADOP(pTHX_ I32 type, I32 flags, SV *sv) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_NEWPADOP \ - assert(sv) + ASSUME(sv) PERL_CALLCONV PADLIST * Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_PADLIST_DUP \ - assert(srcpad); assert(param) + ASSUME(srcpad); ASSUME(param) PERL_CALLCONV PADNAME * Perl_padname_dup(pTHX_ PADNAME *src, CLONE_PARAMS *param) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_PADNAME_DUP \ - assert(src); assert(param) + ASSUME(src); ASSUME(param) PERL_CALLCONV PADNAMELIST * Perl_padnamelist_dup(pTHX_ PADNAMELIST *srcpad, CLONE_PARAMS *param) __attribute__warn_unused_result__ __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_PADNAMELIST_DUP \ - assert(srcpad); assert(param) + ASSUME(srcpad); ASSUME(param) PERL_CALLCONV yy_parser * Perl_parser_dup(pTHX_ const yy_parser * const proto, CLONE_PARAMS * const param); # define PERL_ARGS_ASSERT_PARSER_DUP \ - assert(param) + ASSUME(param) PERL_CALLCONV PerlInterpreter * -perl_clone(PerlInterpreter *proto_perl, UV flags); +perl_clone(PerlInterpreter *proto_perl, UV flags) + __attribute__nonnull__(1); # define PERL_ARGS_ASSERT_PERL_CLONE \ - assert(proto_perl) + PERL_ASSUME_NON_NULL(proto_perl) PERL_CALLCONV void Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS *param); # define PERL_ARGS_ASSERT_RE_DUP_GUTS \ - assert(sstr); assert(dstr); assert(param) + ASSUME(sstr); ASSUME(dstr); ASSUME(param) PERL_CALLCONV void * Perl_regdupe_internal(pTHX_ REGEXP * const r, CLONE_PARAMS *param); # define PERL_ARGS_ASSERT_REGDUPE_INTERNAL \ - assert(r); assert(param) + ASSUME(r); ASSUME(param) PERL_CALLCONV void Perl_rvpv_dup(pTHX_ SV * const dsv, const SV * const ssv, CLONE_PARAMS * const param); # define PERL_ARGS_ASSERT_RVPV_DUP \ - assert(dsv); assert(ssv); assert(param) + ASSUME(dsv); ASSUME(ssv); ASSUME(param) PERL_CALLCONV PERL_SI * Perl_si_dup(pTHX_ PERL_SI *si, CLONE_PARAMS *param) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SI_DUP \ - assert(param) + ASSUME(param) PERL_CALLCONV ANY * Perl_ss_dup(pTHX_ PerlInterpreter *proto_perl, CLONE_PARAMS *param) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SS_DUP \ - assert(proto_perl); assert(param) + ASSUME(proto_perl); ASSUME(param) PERL_CALLCONV SV * Perl_sv_dup(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SV_DUP \ - assert(param) + ASSUME(param) PERL_CALLCONV SV * Perl_sv_dup_inc(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_SV_DUP_INC \ - assert(param) + ASSUME(param) # if defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) PERL_CALLCONV void Perl_op_relocate_sv(pTHX_ SV **svp, PADOFFSET *targp) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_OP_RELOCATE_SV \ - assert(svp); assert(targp) + ASSUME(svp); ASSUME(targp) # endif #else /* if !defined(USE_ITHREADS) */ @@ -10890,16 +11196,16 @@ PERL_CALLCONV int Perl_magic_freecollxfrm(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MAGIC_FREECOLLXFRM \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) PERL_CALLCONV int Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM \ - assert(sv); assert(mg) + ASSUME(sv); ASSUME(mg) # define PERL_ARGS_ASSERT_STRXFRM \ - assert(src) + ASSUME(src) /* PERL_CALLCONV char * Perl_sv_collxfrm(pTHX_ SV * const sv, STRLEN * const nxp); */ @@ -10907,7 +11213,7 @@ Perl_sv_collxfrm(pTHX_ SV * const sv, STRLEN * const nxp); */ PERL_CALLCONV char * Perl_sv_collxfrm_flags(pTHX_ SV * const sv, STRLEN * const nxp, I32 const flags); # define PERL_ARGS_ASSERT_SV_COLLXFRM_FLAGS \ - assert(sv); assert(nxp) + ASSUME(sv); ASSUME(nxp) # if defined(PERL_CORE) || defined(PERL_EXT) PERL_CALLCONV SV * @@ -10922,7 +11228,7 @@ Perl_mem_collxfrm_(pTHX_ const char *input_string, STRLEN len, STRLEN *xlen, boo # if defined(PERL_IN_LOCALE_C) || defined(PERL_IN_MATHOMS_C) || \ defined(PERL_IN_SV_C) # define PERL_ARGS_ASSERT_MEM_COLLXFRM_ \ - assert(input_string); assert(xlen) + ASSUME(input_string); ASSUME(xlen) # endif #endif /* defined(USE_LOCALE_COLLATE) */ @@ -10982,7 +11288,7 @@ Perl_PerlIO_get_ptr(pTHX_ PerlIO *f); PERL_CALLCONV SSize_t Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count); # define PERL_ARGS_ASSERT_PERLIO_READ \ - assert(vbuf) + ASSUME(vbuf) PERL_CALLCONV void Perl_PerlIO_restore_errno(pTHX_ PerlIO *f); @@ -11030,12 +11336,12 @@ Perl_PerlIO_tell(pTHX_ PerlIO *f); PERL_CALLCONV SSize_t Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count); # define PERL_ARGS_ASSERT_PERLIO_UNREAD \ - assert(vbuf) + ASSUME(vbuf) PERL_CALLCONV SSize_t Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count); # define PERL_ARGS_ASSERT_PERLIO_WRITE \ - assert(vbuf) + ASSUME(vbuf) #endif /* defined(USE_PERLIO) */ #if defined(USE_PERL_SWITCH_LOCALE_CONTEXT) @@ -11047,15 +11353,17 @@ Perl_switch_locale_context(pTHX); #if defined(USE_QUADMATH) PERL_CALLCONV bool Perl_quadmath_format_needed(const char *format) + __attribute__nonnull__(1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_QUADMATH_FORMAT_NEEDED \ - assert(format) + PERL_ASSUME_NON_NULL(format) PERL_CALLCONV bool Perl_quadmath_format_valid(const char *format) + __attribute__nonnull__(1) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_QUADMATH_FORMAT_VALID \ - assert(format) + PERL_ASSUME_NON_NULL(format) #endif /* defined(USE_QUADMATH) */ #if defined(USE_THREADS) @@ -11072,17 +11380,17 @@ Perl_thread_locale_term(pTHX); PERL_CALLCONV int Perl_do_aspawn(pTHX_ SV *really, SV **mark, SV **sp); # define PERL_ARGS_ASSERT_DO_ASPAWN \ - assert(mark); assert(sp) + ASSUME(mark); ASSUME(sp) PERL_CALLCONV int Perl_do_spawn(pTHX_ char *cmd); # define PERL_ARGS_ASSERT_DO_SPAWN \ - assert(cmd) + ASSUME(cmd) PERL_CALLCONV int Perl_do_spawn_nowait(pTHX_ char *cmd); # define PERL_ARGS_ASSERT_DO_SPAWN_NOWAIT \ - assert(cmd) + ASSUME(cmd) #endif /* defined(VMS) || defined(WIN32) */ #if defined(WIN32) @@ -11098,16 +11406,17 @@ Perl_get_win32_message_utf8ness(pTHX_ const char *string) PERL_CALLCONV_NO_RET void win32_croak_not_implemented(const char *fname) + __attribute__nonnull__(1) __attribute__noreturn__; # define PERL_ARGS_ASSERT_WIN32_CROAK_NOT_IMPLEMENTED \ - assert(fname) + PERL_ASSUME_NON_NULL(fname) #else /* if !defined(WIN32) */ PERL_CALLCONV bool Perl_do_exec3(pTHX_ const char *incmd, int fd, int do_report) __attribute__visibility__("hidden"); # define PERL_ARGS_ASSERT_DO_EXEC3 \ - assert(incmd) + ASSUME(incmd) #endif diff --git a/regen/embed.pl b/regen/embed.pl index 5a9ea2fa58c1..d944564ee297 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -138,6 +138,7 @@ sub generate_proto_h { my $can_ignore = $flags !~ /[RP]/ && !$is_malloc; my $extensions_only = ( $flags =~ /E/ ); my @asserts; + my @attrs; my $func; if (! $can_ignore && $retval eq 'void') { @@ -293,8 +294,6 @@ sub generate_proto_h { warn "$func: $arg should not have NZ\n" if $nz; } - push( @nonnull, $n ) if $nn; - # Make sure each arg has at least a type and a var name. # An arg of "int" is valid C, but want it to be "int foo". my $argtype = ( $arg =~ m/^(\w+(?:\s*\*+)?)/ )[0]; @@ -310,8 +309,20 @@ sub generate_proto_h { my $argname = $1; if (defined $argname && (! $has_mflag || $binarycompat)) { - if ($nn||$nz) { - push @asserts, "assert($argname)"; + if ($nn) { + if ($has_context) { + # XXX pTHX_ complicates things by having to + # use $n+1 when threaded, $n when not; so + # currently we don't handle it. + push @asserts, "ASSUME($argname)"; + } + else { + push @asserts, "PERL_ASSUME_NON_NULL($argname)"; + push @attrs, "__attribute__nonnull__($n)"; + } + } + elsif ($nz) { + push @asserts, "ASSUME($argname)"; } if ( ! $nocheck @@ -321,7 +332,7 @@ sub generate_proto_h { my $type_assert = $type_asserts{$argtype} =~ s/__arg__/$argname/gr; $type_assert = "!$argname || $type_assert" if $nullok; - push @asserts, "assert($type_assert)"; + push @asserts, "ASSUME($type_assert)"; } } } @@ -336,7 +347,6 @@ sub generate_proto_h { push @asserts, @$assertions if $assertions; - my @attrs; if ( $flags =~ /r/ ) { push @attrs, "__attribute__noreturn__"; } @@ -455,7 +465,22 @@ sub generate_proto_h { my $clean= normalize_group_content($proto_buffer); my $fh = open_print_header("proto.h"); + + # For each function that doesn't have a thread context, we generate two + # lines that check each argument that is supposed to be NULL to be sure it + # is. However, only one of those lines expands to being non-empty, + # depending on the compiler's capabilities. perl.h sets + # '__attribute__nonnull__()' to expand to nothing if the compiler doesn't + # support it. But when we do have it, we get compile-time checking for + # the parameter. If we don't have it, we fall back to using ASSUME(), + # which can be runtime. print $fh <<~"EOF"; + #ifdef HASATTRIBUTE_NONNULL + # define PERL_ASSUME_NON_NULL(what) + #else + # define PERL_ASSUME_NON_NULL(what) ASSUME(what) + #endif + START_EXTERN_C $clean #ifdef PERL_CORE