assert() that every NN argument is not NULL. Otherwise we have the

ability to create landmines that will explode under someone in the
future when they upgrade their compiler to one with better
optimisation. We've already done this at least twice.
(Yes, some of the assertions are after code that would already have
SEGVd because it already deferences a pointer, but they are put in
to make it easier to automate checking that each and every case is
covered.)
Add a tool, checkARGS_ASSERT.pl, to check that every case is covered.

p4raw-id: //depot/perl@33291

1 files changed, 49 insertions, 15 deletions

diff --git a/regexec.c b/regexec.c
index e64846fdd0..16b1495a79 100644
--- a/regexec.c
+++ b/regexec.c
@@ -237,9 +237,10 @@ S_regcppop(pTHX_ const regexp *rex)
     dVAR;
     U32 i;
     char *input;
-
     GET_RE_DEBUG_FLAGS_DECL;
 
+    PERL_ARGS_ASSERT_REGCPPOP;
+
     /* Pop REGCP_OTHER_ELEMS before the parentheses loop starts. */
     i = SSPOPINT;
     assert(i == SAVEt_REGCONTEXT); /* Check that the magic cookie is there. */
@@ -314,6 +315,8 @@ Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, register char *strend,
 /* minend: end of match must be >=minend after stringarg. */
 /* nosave: For optimizations. */
 {
+    PERL_ARGS_ASSERT_PREGEXEC;
+
     return
 	regexec_flags(prog, stringarg, strend, strbeg, minend, screamer, NULL,
 		      nosave ? 0 : REXEC_COPY_STR);
@@ -392,9 +395,10 @@ Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV *sv, char *strpos,
 #ifdef DEBUGGING
     const char * const i_strpos = strpos;
 #endif
-
     GET_RE_DEBUG_FLAGS_DECL;
 
+    PERL_ARGS_ASSERT_RE_INTUIT_START;
+
     RX_MATCH_UTF8_set(rx,do_utf8);
 
     if (RX_UTF8(rx)) {
@@ -1181,6 +1185,8 @@ S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s,
 	register I32 tmp = 1;	/* Scratch variable? */
 	register const bool do_utf8 = PL_reg_match_utf8;
         RXi_GET_DECL(prog,progi);
+
+	PERL_ARGS_ASSERT_FIND_BYCLASS;
         
 	/* We know what class it must start with. */
 	switch (OP(c)) {
@@ -1720,9 +1726,12 @@ S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s,
 }
 
 static void 
-S_swap_match_buff (pTHX_ regexp *prog) {
+S_swap_match_buff (pTHX_ regexp *prog)
+{
     regexp_paren_pair *t;
 
+    PERL_ARGS_ASSERT_SWAP_MATCH_BUFF;
+
     if (!prog->swap) {
     /* We have to be careful. If the previous successful match
        was from this regex we don't want a subsequent paritally
@@ -1768,9 +1777,9 @@ Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, register char *stre
     RXi_GET_DECL(prog,progi);
     regmatch_info reginfo;  /* create some info to pass to regtry etc */
     bool swap_on_fail = 0;
-
     GET_RE_DEBUG_FLAGS_DECL;
 
+    PERL_ARGS_ASSERT_REGEXEC_FLAGS;
     PERL_UNUSED_ARG(data);
 
     /* Be paranoid... */
@@ -2211,6 +2220,9 @@ S_regtry(pTHX_ regmatch_info *reginfo, char **startpos)
     regexp *const prog = (struct regexp *)SvANY(rx);
     RXi_GET_DECL(prog,progi);
     GET_RE_DEBUG_FLAGS_DECL;
+
+    PERL_ARGS_ASSERT_REGTRY;
+
     reginfo->cutpoint=NULL;
 
     if ((prog->extflags & RXf_EVAL_SEEN) && !PL_reg_eval_set) {
@@ -2566,6 +2578,9 @@ S_debug_start_match(pTHX_ const REGEXP *prog, const bool do_utf8,
     const char *start, const char *end, const char *blurb)
 {
     const bool utf8_pat = RX_UTF8(prog) ? 1 : 0;
+
+    PERL_ARGS_ASSERT_DEBUG_START_MATCH;
+
     if (!PL_colorset)   
             reginitcolors();    
     {
@@ -2609,6 +2624,8 @@ S_dump_exec_pos(pTHX_ const char *locinput,
 	? (5 + taill) - l : locinput - loc_bostr;
     int pref0_len;
 
+    PERL_ARGS_ASSERT_DUMP_EXEC_POS;
+
     while (do_utf8 && UTF8_IS_CONTINUATION(*(U8*)(locinput - pref_len)))
 	pref_len++;
     pref0_len = pref_len  - (locinput - loc_reg_starttry);
@@ -2659,11 +2676,15 @@ S_dump_exec_pos(pTHX_ const char *locinput,
  * or 0 if non of the buffers matched.
  */
 STATIC I32
-S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan) {
+S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan)
+{
     I32 n;
     RXi_GET_DECL(rex,rexi);
     SV *sv_dat=(SV*)rexi->data->data[ ARG( scan ) ];
     I32 *nums=(I32*)SvPVX(sv_dat);
+
+    PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED;
+
     for ( n=0; n<SvIVX(sv_dat); n++ ) {
         if ((I32)*PL_reglastparen >= nums[n] &&
             PL_regoffs[nums[n]].end != -1)
@@ -2707,16 +2728,12 @@ S_regmatch(pTHX_ regmatch_info *reginfo, regnode *prog)
     dVAR;
     register const bool do_utf8 = PL_reg_match_utf8;
     const U32 uniflags = UTF8_ALLOW_DEFAULT;
-
     REGEXP *rex_sv = reginfo->prog;
     regexp *rex = (struct regexp *)SvANY(rex_sv);
     RXi_GET_DECL(rex,rexi);
-    
     I32	oldsave;
-
     /* the current state. This is a cached copy of PL_regmatch_state */
     register regmatch_state *st;
-
     /* cache heavy used fields of st in registers */
     register regnode *scan;
     register regnode *next;
@@ -2731,13 +2748,11 @@ S_regmatch(pTHX_ regmatch_info *reginfo, regnode *prog)
     const U32 max_nochange_depth =
         (3 * rex->nparens > MAX_RECURSE_EVAL_NOCHANGE_DEPTH) ?
         3 * rex->nparens : MAX_RECURSE_EVAL_NOCHANGE_DEPTH;
-            
     regmatch_state *yes_state = NULL; /* state to pop to on success of
 							    subpattern */
     /* mark_state piggy backs on the yes_state logic so that when we unwind 
        the stack on success we can update the mark_state as we go */
     regmatch_state *mark_state = NULL; /* last mark state we have seen */
-    
     regmatch_state *cur_eval = NULL; /* most recent EVAL_AB state */
     struct regmatch_state  *cur_curlyx = NULL; /* most recent curlyx */
     U32 state_num;
@@ -2750,10 +2765,7 @@ S_regmatch(pTHX_ regmatch_info *reginfo, regnode *prog)
                                during a successfull match */
     U32 lastopen = 0;       /* last open we saw */
     bool has_cutgroup = RX_HAS_CUTGROUP(rex) ? 1 : 0;   
-
     SV* const oreplsv = GvSV(PL_replgv);
-               
-    
     /* these three flags are set by various ops to signal information to
      * the very next op. They have a useful lifetime of exactly one loop
      * iteration, and are not preserved or restored by state pushes/pops
@@ -2768,11 +2780,12 @@ S_regmatch(pTHX_ regmatch_info *reginfo, regnode *prog)
 			        false: plain (?=foo)
 				true:  used as a condition: (?(?=foo))
 			    */
-
 #ifdef DEBUGGING
     GET_RE_DEBUG_FLAGS_DECL;
 #endif
 
+    PERL_ARGS_ASSERT_REGMATCH;
+
     DEBUG_OPTIMISE_r( DEBUG_EXECUTE_r({
 	    PerlIO_printf(Perl_debug_log,"regmatch start\n");
     }));
@@ -5348,6 +5361,8 @@ S_regrepeat(pTHX_ const regexp *prog, const regnode *p, I32 max, int depth)
     PERL_UNUSED_ARG(depth);
 #endif
 
+    PERL_ARGS_ASSERT_REGREPEAT;
+
     scan = PL_reginput;
     if (max == REG_INFTY)
 	max = I32_MAX;
@@ -5663,6 +5678,8 @@ Perl_regclass_swash(pTHX_ const regexp *prog, register const regnode* node, bool
     RXi_GET_DECL(prog,progi);
     const struct reg_data * const data = prog ? progi->data : NULL;
 
+    PERL_ARGS_ASSERT_REGCLASS_SWASH;
+
     if (data && data->count) {
 	const U32 n = ARG(node);
 
@@ -5719,6 +5736,8 @@ S_reginclass(pTHX_ const regexp *prog, register const regnode *n, register const
     STRLEN len = 0;
     STRLEN plen;
 
+    PERL_ARGS_ASSERT_REGINCLASS;
+
     if (do_utf8 && !UTF8_IS_INVARIANT(c)) {
 	c = utf8n_to_uvchr(p, UTF8_MAXBYTES, &len,
 		(UTF8_ALLOW_DEFAULT & UTF8_ALLOW_ANYUV) | UTF8_CHECK_ONLY);
@@ -5836,6 +5855,9 @@ STATIC U8 *
 S_reghop3(U8 *s, I32 off, const U8* lim)
 {
     dVAR;
+
+    PERL_ARGS_ASSERT_REGHOP3;
+
     if (off >= 0) {
 	while (off-- && s < lim) {
 	    /* XXX could check well-formedness here */
@@ -5864,6 +5886,9 @@ STATIC U8 *
 S_reghop4(U8 *s, I32 off, const U8* llim, const U8* rlim)
 {
     dVAR;
+
+    PERL_ARGS_ASSERT_REGHOP4;
+
     if (off >= 0) {
         while (off-- && s < rlim) {
             /* XXX could check well-formedness here */
@@ -5888,6 +5913,9 @@ STATIC U8 *
 S_reghopmaybe3(U8* s, I32 off, const U8* lim)
 {
     dVAR;
+
+    PERL_ARGS_ASSERT_REGHOPMAYBE3;
+
     if (off >= 0) {
 	while (off-- && s < lim) {
 	    /* XXX could check well-formedness here */
@@ -5935,6 +5963,9 @@ STATIC void
 S_to_utf8_substr(pTHX_ register regexp *prog)
 {
     int i = 1;
+
+    PERL_ARGS_ASSERT_TO_UTF8_SUBSTR;
+
     do {
 	if (prog->substrs->data[i].substr
 	    && !prog->substrs->data[i].utf8_substr) {
@@ -5964,6 +5995,9 @@ S_to_byte_substr(pTHX_ register regexp *prog)
 {
     dVAR;
     int i = 1;
+
+    PERL_ARGS_ASSERT_TO_BYTE_SUBSTR;
+
     do {
 	if (prog->substrs->data[i].utf8_substr
 	    && !prog->substrs->data[i].substr) {