update size after Renew

RT #130841

In general code, change this idiom:

    PL_foo_max += size;
    Renew(PL_foo, PL_foo_max, foo_t);

to
    Renew(PL_foo, PL_foo_max + size, foo_t);
    PL_foo_max += size;

so that if Renew dies, PL_foo_max won't be left hanging.

6 files changed, 40 insertions, 28 deletions

diff --git a/perlio.c b/perlio.c
index 3e936a26d0..e9d3700cfe 100644
--- a/perlio.c
+++ b/perlio.c
@@ -547,11 +547,12 @@ PerlIO_list_push(pTHX_ PerlIO_list_t *list, PerlIO_funcs *funcs, SV *arg)
     PERL_UNUSED_CONTEXT;
 
     if (list->cur >= list->len) {
-	list->len += 8;
+        const IV new_len = list->len + 8;
 	if (list->array)
-	    Renew(list->array, list->len, PerlIO_pair_t);
+	    Renew(list->array, new_len, PerlIO_pair_t);
 	else
-	    Newx(list->array, list->len, PerlIO_pair_t);
+	    Newx(list->array, new_len, PerlIO_pair_t);
+	list->len = new_len;
     }
     p = &(list->array[list->cur++]);
     p->funcs = funcs;
diff --git a/pp_hot.c b/pp_hot.c
index 58bbe2f1e9..4f0d094ce6 100644
--- a/pp_hot.c
+++ b/pp_hot.c
@@ -4134,8 +4134,8 @@ PP(pp_entersub)
             items = SP - MARK;
 	    if (UNLIKELY(items - 1 > AvMAX(av))) {
                 SV **ary = AvALLOC(av);
-                AvMAX(av) = items - 1;
                 Renew(ary, items, SV*);
+                AvMAX(av) = items - 1;
                 AvALLOC(av) = ary;
                 AvARRAY(av) = ary;
             }
diff --git a/pp_sort.c b/pp_sort.c
index 21e4574c1f..a54768a022 100644
--- a/pp_sort.c
+++ b/pp_sort.c
@@ -1831,8 +1831,8 @@ S_sortcv_stacked(pTHX_ SV *const a, SV *const b)
 	    AvARRAY(av) = ary;
 	}
 	if (AvMAX(av) < 1) {
-	    AvMAX(av) = 1;
 	    Renew(ary,2,SV*);
+	    AvMAX(av) = 1;
 	    AvARRAY(av) = ary;
 	    AvALLOC(av) = ary;
 	}
diff --git a/regcomp.c b/regcomp.c
index 0a80cedec5..810c4573d1 100644
--- a/regcomp.c
+++ b/regcomp.c
@@ -2355,8 +2355,9 @@ is the recommended Unicode-aware way of saying
 
 #define TRIE_LIST_PUSH(state,fid,ns) STMT_START {               \
     if ( TRIE_LIST_CUR( state ) >=TRIE_LIST_LEN( state ) ) {    \
-	U32 ging = TRIE_LIST_LEN( state ) *= 2;                 \
+	U32 ging = TRIE_LIST_LEN( state ) * 2;                  \
 	Renew( trie->states[ state ].trans.list, ging, reg_trie_trans_le ); \
+        TRIE_LIST_LEN( state ) = ging;                          \
     }                                                           \
     TRIE_LIST_ITEM( state, TRIE_LIST_CUR( state ) ).forid = fid;     \
     TRIE_LIST_ITEM( state, TRIE_LIST_CUR( state ) ).newstate = ns;   \
@@ -6416,10 +6417,11 @@ S_concat_pat(pTHX_ RExC_state_t * const pRExC_state,
                  * different closure than last time */
                 *recompile_p = 1;
                 if (pRExC_state->code_blocks) {
-                    pRExC_state->code_blocks->count += ri->code_blocks->count;
+                    int new_count = pRExC_state->code_blocks->count
+                            + ri->code_blocks->count;
                     Renew(pRExC_state->code_blocks->cb,
-                            pRExC_state->code_blocks->count,
-                            struct reg_code_block);
+                            new_count, struct reg_code_block);
+                    pRExC_state->code_blocks->count = new_count;
                 }
                 else
                     pRExC_state->code_blocks = S_alloc_code_blocks(aTHX_
diff --git a/scope.c b/scope.c
index 4b302e7665..c51a125dfa 100644
--- a/scope.c
+++ b/scope.c
@@ -90,11 +90,12 @@ I32
 Perl_cxinc(pTHX)
 {
     const IV old_max = cxstack_max;
-    cxstack_max = GROW(cxstack_max);
-    Renew(cxstack, cxstack_max + 1, PERL_CONTEXT);
+    const IV new_max = GROW(cxstack_max);
+    Renew(cxstack, new_max + 1, PERL_CONTEXT);
+    cxstack_max = new_max;
     /* Without any kind of initialising deep enough recursion
      * will end up reading uninitialised PERL_CONTEXTs. */
-    PoisonNew(cxstack + old_max + 1, cxstack_max - old_max, PERL_CONTEXT);
+    PoisonNew(cxstack + old_max + 1, new_max - old_max, PERL_CONTEXT);
     return cxstack_ix + 1;
 }
 
@@ -102,11 +103,12 @@ void
 Perl_push_scope(pTHX)
 {
     if (UNLIKELY(PL_scopestack_ix == PL_scopestack_max)) {
-	PL_scopestack_max = GROW(PL_scopestack_max);
-	Renew(PL_scopestack, PL_scopestack_max, I32);
+        const IV new_max = GROW(PL_scopestack_max);
+	Renew(PL_scopestack, new_max, I32);
 #ifdef DEBUGGING
-	Renew(PL_scopestack_name, PL_scopestack_max, const char*);
+	Renew(PL_scopestack_name, new_max, const char*);
 #endif
+	PL_scopestack_max = new_max;
     }
 #ifdef DEBUGGING
     PL_scopestack_name[PL_scopestack_ix] = "unknown";
@@ -140,23 +142,26 @@ Perl_markstack_grow(pTHX)
 void
 Perl_savestack_grow(pTHX)
 {
+    IV new_max;
 #ifdef STRESS_REALLOC
-    PL_savestack_max += SS_MAXPUSH;
+    new_max = PL_savestack_max + SS_MAXPUSH;
 #else
-    PL_savestack_max = GROW(PL_savestack_max);
+    new_max = GROW(PL_savestack_max);
 #endif
     /* Note that we allocate SS_MAXPUSH slots higher than ss_max
      * so that SS_ADD_END(), SSGROW() etc can do a simper check */
-    Renew(PL_savestack, PL_savestack_max + SS_MAXPUSH, ANY);
+    Renew(PL_savestack, new_max + SS_MAXPUSH, ANY);
+    PL_savestack_max = new_max;
 }
 
 void
 Perl_savestack_grow_cnt(pTHX_ I32 need)
 {
-    PL_savestack_max = PL_savestack_ix + need;
+    const IV new_max = PL_savestack_ix + need;
     /* Note that we allocate SS_MAXPUSH slots higher than ss_max
      * so that SS_ADD_END(), SSGROW() etc can do a simper check */
-    Renew(PL_savestack, PL_savestack_max + SS_MAXPUSH, ANY);
+    Renew(PL_savestack, new_max + SS_MAXPUSH, ANY);
+    PL_savestack_max = new_max;
 }
 
 #undef GROW
@@ -186,8 +191,8 @@ Perl_tmps_grow_p(pTHX_ SSize_t ix)
     if (ix - PL_tmps_max < 128)
 	extend_to += (PL_tmps_max < 512) ? 128 : 512;
 #endif
+    Renew(PL_tmps_stack, extend_to + 1, SV*);
     PL_tmps_max = extend_to + 1;
-    Renew(PL_tmps_stack, PL_tmps_max, SV*);
     return ix;
 }
 
diff --git a/util.c b/util.c
index bd568bc22a..b324af43ed 100644
--- a/util.c
+++ b/util.c
@@ -5352,9 +5352,11 @@ Perl_my_cxt_init(pTHX_ int *index, size_t size)
     /* make sure the array is big enough */
     if (PL_my_cxt_size <= *index) {
 	if (PL_my_cxt_size) {
-	    while (PL_my_cxt_size <= *index)
-		PL_my_cxt_size *= 2;
-	    Renew(PL_my_cxt_list, PL_my_cxt_size, void *);
+            IV new_size = PL_my_cxt_size;
+	    while (new_size <= *index)
+		new_size *= 2;
+	    Renew(PL_my_cxt_list, new_size, void *);
+            PL_my_cxt_size = new_size;
 	}
 	else {
 	    PL_my_cxt_size = 16;
@@ -5415,10 +5417,12 @@ Perl_my_cxt_init(pTHX_ const char *my_cxt_key, size_t size)
 	int old_size = PL_my_cxt_size;
 	int i;
 	if (PL_my_cxt_size) {
-	    while (PL_my_cxt_size <= index)
-		PL_my_cxt_size *= 2;
-	    Renew(PL_my_cxt_list, PL_my_cxt_size, void *);
-	    Renew(PL_my_cxt_keys, PL_my_cxt_size, const char *);
+            IV new_size = PL_my_cxt_size;
+	    while (new_size <= index)
+		new_size *= 2;
+	    Renew(PL_my_cxt_list, new_size, void *);
+	    Renew(PL_my_cxt_keys, new_size, const char *);
+            PL_my_cxt_size = new_size;
 	}
 	else {
 	    PL_my_cxt_size = 16;