diff options
Diffstat (limited to 'gcc/gimplify.c')
| -rw-r--r-- | gcc/gimplify.c | 153 |
1 files changed, 78 insertions, 75 deletions
diff --git a/gcc/gimplify.c b/gcc/gimplify.c index 0919d9ff76a..8d555f833b9 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -231,9 +231,10 @@ pop_gimplify_context (gimple body) { struct gimplify_ctx *c = gimplify_ctxp; - gcc_assert (c && (c->bind_expr_stack == NULL - || VEC_empty (gimple, c->bind_expr_stack))); - VEC_free (gimple, heap, c->bind_expr_stack); + gcc_assert (c + && (!c->bind_expr_stack.exists () + || c->bind_expr_stack.is_empty ())); + c->bind_expr_stack.release (); gimplify_ctxp = c->prev_context; if (body) @@ -250,9 +251,8 @@ pop_gimplify_context (gimple body) static void gimple_push_bind_expr (gimple gimple_bind) { - if (gimplify_ctxp->bind_expr_stack == NULL) - gimplify_ctxp->bind_expr_stack = VEC_alloc (gimple, heap, 8); - VEC_safe_push (gimple, heap, gimplify_ctxp->bind_expr_stack, gimple_bind); + gimplify_ctxp->bind_expr_stack.reserve (8); + gimplify_ctxp->bind_expr_stack.safe_push (gimple_bind); } /* Pop the first element off the stack of bindings. */ @@ -260,7 +260,7 @@ gimple_push_bind_expr (gimple gimple_bind) static void gimple_pop_bind_expr (void) { - VEC_pop (gimple, gimplify_ctxp->bind_expr_stack); + gimplify_ctxp->bind_expr_stack.pop (); } /* Return the first element of the stack of bindings. */ @@ -268,12 +268,12 @@ gimple_pop_bind_expr (void) gimple gimple_current_bind_expr (void) { - return VEC_last (gimple, gimplify_ctxp->bind_expr_stack); + return gimplify_ctxp->bind_expr_stack.last (); } /* Return the stack of bindings created during gimplification. */ -VEC(gimple, heap) * +vec<gimple> gimple_bind_expr_stack (void) { return gimplify_ctxp->bind_expr_stack; @@ -1258,7 +1258,8 @@ gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p) && !is_gimple_reg (t) && flag_stack_reuse != SR_NONE) { - tree clobber = build_constructor (TREE_TYPE (t), NULL); + tree clobber = build_constructor (TREE_TYPE (t), + NULL); TREE_THIS_VOLATILE (clobber) = 1; gimplify_seq_add_stmt (&cleanup, gimple_build_assign (t, clobber)); } @@ -1569,9 +1570,9 @@ compare_case_labels (const void *p1, const void *p2) /* Sort the case labels in LABEL_VEC in place in ascending order. */ void -sort_case_labels (VEC(tree,heap)* label_vec) +sort_case_labels (vec<tree> label_vec) { - VEC_qsort (tree, label_vec, compare_case_labels); + label_vec.qsort (compare_case_labels); } /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement. @@ -1594,7 +1595,7 @@ sort_case_labels (VEC(tree,heap)* label_vec) found or not. */ void -preprocess_case_label_vec_for_gimple (VEC(tree,heap) *labels, +preprocess_case_label_vec_for_gimple (vec<tree> labels, tree index_type, tree *default_casep) { @@ -1605,9 +1606,9 @@ preprocess_case_label_vec_for_gimple (VEC(tree,heap) *labels, i = 0; min_value = TYPE_MIN_VALUE (index_type); max_value = TYPE_MAX_VALUE (index_type); - while (i < VEC_length (tree, labels)) + while (i < labels.length ()) { - tree elt = VEC_index (tree, labels, i); + tree elt = labels[i]; tree low = CASE_LOW (elt); tree high = CASE_HIGH (elt); bool remove_element = FALSE; @@ -1696,13 +1697,13 @@ preprocess_case_label_vec_for_gimple (VEC(tree,heap) *labels, } if (remove_element) - VEC_ordered_remove (tree, labels, i); + labels.ordered_remove (i); else i++; } len = i; - if (!VEC_empty (tree, labels)) + if (!labels.is_empty ()) sort_case_labels (labels); if (default_casep && !default_case) @@ -1714,20 +1715,20 @@ preprocess_case_label_vec_for_gimple (VEC(tree,heap) *labels, if (len && TYPE_MIN_VALUE (index_type) && TYPE_MAX_VALUE (index_type) - && tree_int_cst_equal (CASE_LOW (VEC_index (tree, labels, 0)), + && tree_int_cst_equal (CASE_LOW (labels[0]), TYPE_MIN_VALUE (index_type))) { - tree low, high = CASE_HIGH (VEC_index (tree, labels, len - 1)); + tree low, high = CASE_HIGH (labels[len - 1]); if (!high) - high = CASE_LOW (VEC_index (tree, labels, len - 1)); + high = CASE_LOW (labels[len - 1]); if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type))) { for (i = 1; i < len; i++) { - high = CASE_LOW (VEC_index (tree, labels, i)); - low = CASE_HIGH (VEC_index (tree, labels, i - 1)); + high = CASE_LOW (labels[i]); + low = CASE_HIGH (labels[i - 1]); if (!low) - low = CASE_LOW (VEC_index (tree, labels, i - 1)); + low = CASE_LOW (labels[i - 1]); if ((TREE_INT_CST_LOW (low) + 1 != TREE_INT_CST_LOW (high)) || (TREE_INT_CST_HIGH (low) @@ -1737,7 +1738,7 @@ preprocess_case_label_vec_for_gimple (VEC(tree,heap) *labels, } if (i == len) { - tree label = CASE_LABEL (VEC_index (tree, labels, 0)); + tree label = CASE_LABEL (labels[0]); default_case = build_case_label (NULL_TREE, NULL_TREE, label); } @@ -1769,8 +1770,8 @@ gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p) if (SWITCH_BODY (switch_expr)) { - VEC (tree,heap) *labels; - VEC (tree,heap) *saved_labels; + vec<tree> labels; + vec<tree> saved_labels; tree default_case = NULL_TREE; gimple gimple_switch; @@ -1781,7 +1782,7 @@ gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p) /* Save old labels, get new ones from body, then restore the old labels. Save all the things from the switch body to append after. */ saved_labels = gimplify_ctxp->case_labels; - gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8); + gimplify_ctxp->case_labels.create (8); gimplify_stmt (&SWITCH_BODY (switch_expr), &switch_body_seq); labels = gimplify_ctxp->case_labels; @@ -1805,7 +1806,7 @@ gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p) default_case, labels); gimplify_seq_add_stmt (pre_p, gimple_switch); gimplify_seq_add_seq (pre_p, switch_body_seq); - VEC_free(tree, heap, labels); + labels.release (); } else gcc_assert (SWITCH_LABELS (switch_expr)); @@ -1825,11 +1826,11 @@ gimplify_case_label_expr (tree *expr_p, gimple_seq *pre_p) #pragma omp parallel. At least in the C front end, we don't detect such invalid branches until after gimplification. */ for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context) - if (ctxp->case_labels) + if (ctxp->case_labels.exists ()) break; gimple_label = gimple_build_label (CASE_LABEL (*expr_p)); - VEC_safe_push (tree, heap, ctxp->case_labels, *expr_p); + ctxp->case_labels.safe_push (*expr_p); gimplify_seq_add_stmt (pre_p, gimple_label); return GS_ALL_DONE; @@ -2129,7 +2130,7 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, fallback_t fallback) { tree *p; - VEC(tree,heap) *expr_stack; + vec<tree> expr_stack; enum gimplify_status ret = GS_ALL_DONE, tret; int i; location_t loc = EXPR_LOCATION (*expr_p); @@ -2137,7 +2138,7 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, /* Create a stack of the subexpressions so later we can walk them in order from inner to outer. */ - expr_stack = VEC_alloc (tree, heap, 10); + expr_stack.create (10); /* We can handle anything that get_inner_reference can deal with. */ for (p = expr_p; ; p = &TREE_OPERAND (*p, 0)) @@ -2157,10 +2158,10 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, else break; - VEC_safe_push (tree, heap, expr_stack, *p); + expr_stack.safe_push (*p); } - gcc_assert (VEC_length (tree, expr_stack)); + gcc_assert (expr_stack.length ()); /* Now EXPR_STACK is a stack of pointers to all the refs we've walked through and P points to the innermost expression. @@ -2174,9 +2175,9 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, So we do this in three steps. First we deal with the annotations for any variables in the components, then we gimplify the base, then we gimplify any indices, from left to right. */ - for (i = VEC_length (tree, expr_stack) - 1; i >= 0; i--) + for (i = expr_stack.length () - 1; i >= 0; i--) { - tree t = VEC_index (tree, expr_stack, i); + tree t = expr_stack[i]; if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF) { @@ -2269,9 +2270,9 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, /* And finally, the indices and operands of ARRAY_REF. During this loop we also remove any useless conversions. */ - for (; VEC_length (tree, expr_stack) > 0; ) + for (; expr_stack.length () > 0; ) { - tree t = VEC_pop (tree, expr_stack); + tree t = expr_stack.pop (); if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF) { @@ -2299,7 +2300,7 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, canonicalize_component_ref (expr_p); } - VEC_free (tree, heap, expr_stack); + expr_stack.release (); gcc_assert (*expr_p == expr || ret != GS_ALL_DONE); @@ -3461,7 +3462,7 @@ gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value, from = TREE_OPERAND (from, 0); gcc_assert (TREE_CODE (from) == CONSTRUCTOR - && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (from))); + && vec_safe_is_empty (CONSTRUCTOR_ELTS (from))); /* Now proceed. */ to = TREE_OPERAND (*expr_p, 0); @@ -3572,9 +3573,9 @@ gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, { unsigned HOST_WIDE_INT ix; constructor_elt *ce; - VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p); + vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (*expr_p); - FOR_EACH_VEC_ELT (constructor_elt, v, ix, ce) + FOR_EACH_VEC_SAFE_ELT (v, ix, ce) gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data); return; @@ -3634,7 +3635,7 @@ gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, Note that we never have to deal with SAVE_EXPRs here, because this has already been taken care of for us, in gimplify_init_ctor_preeval(). */ -static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *, +static void gimplify_init_ctor_eval (tree, vec<constructor_elt, va_gc> *, gimple_seq *, bool); static void @@ -3720,7 +3721,7 @@ zero_sized_type (const_tree type) zeroed first. */ static void -gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts, +gimplify_init_ctor_eval (tree object, vec<constructor_elt, va_gc> *elts, gimple_seq *pre_p, bool cleared) { tree array_elt_type = NULL; @@ -3876,12 +3877,12 @@ static tree optimize_compound_literals_in_ctor (tree orig_ctor) { tree ctor = orig_ctor; - VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (ctor); - unsigned int idx, num = VEC_length (constructor_elt, elts); + vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (ctor); + unsigned int idx, num = vec_safe_length (elts); for (idx = 0; idx < num; idx++) { - tree value = VEC_index (constructor_elt, elts, idx).value; + tree value = (*elts)[idx].value; tree newval = value; if (TREE_CODE (value) == CONSTRUCTOR) newval = optimize_compound_literals_in_ctor (value); @@ -3903,10 +3904,10 @@ optimize_compound_literals_in_ctor (tree orig_ctor) if (ctor == orig_ctor) { ctor = copy_node (orig_ctor); - CONSTRUCTOR_ELTS (ctor) = VEC_copy (constructor_elt, gc, elts); + CONSTRUCTOR_ELTS (ctor) = vec_safe_copy (elts); elts = CONSTRUCTOR_ELTS (ctor); } - VEC_index (constructor_elt, elts, idx).value = newval; + (*elts)[idx].value = newval; } return ctor; } @@ -3930,7 +3931,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, { tree object, ctor, type; enum gimplify_status ret; - VEC(constructor_elt,gc) *elts; + vec<constructor_elt, va_gc> *elts; gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == CONSTRUCTOR); @@ -3963,7 +3964,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, /* Aggregate types must lower constructors to initialization of individual elements. The exception is that a CONSTRUCTOR node with no elements indicates zero-initialization of the whole. */ - if (VEC_empty (constructor_elt, elts)) + if (vec_safe_is_empty (elts)) { if (notify_temp_creation) return GS_OK; @@ -4099,7 +4100,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, if (TREE_THIS_VOLATILE (object) && !TREE_ADDRESSABLE (type) && num_nonzero_elements > 0 - && VEC_length (constructor_elt, elts) > 1) + && vec_safe_length (elts) > 1) { tree temp = create_tmp_var (TYPE_MAIN_VARIANT (type), NULL); TREE_OPERAND (*expr_p, 0) = temp; @@ -4156,9 +4157,9 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, return GS_OK; /* Extract the real and imaginary parts out of the ctor. */ - gcc_assert (VEC_length (constructor_elt, elts) == 2); - r = VEC_index (constructor_elt, elts, 0).value; - i = VEC_index (constructor_elt, elts, 1).value; + gcc_assert (elts->length () == 2); + r = (*elts)[0].value; + i = (*elts)[1].value; if (r == NULL || i == NULL) { tree zero = build_zero_cst (TREE_TYPE (type)); @@ -4230,7 +4231,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, /* Vector types use CONSTRUCTOR all the way through gimple compilation as a general initializer. */ - FOR_EACH_VEC_ELT (constructor_elt, elts, ix, ce) + FOR_EACH_VEC_SAFE_ELT (elts, ix, ce) { enum gimplify_status tret; tret = gimplify_expr (&ce->value, pre_p, post_p, is_gimple_val, @@ -5223,17 +5224,20 @@ gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) bool allows_mem, allows_reg, is_inout; enum gimplify_status ret, tret; gimple stmt; - VEC(tree, gc) *inputs; - VEC(tree, gc) *outputs; - VEC(tree, gc) *clobbers; - VEC(tree, gc) *labels; + vec<tree, va_gc> *inputs; + vec<tree, va_gc> *outputs; + vec<tree, va_gc> *clobbers; + vec<tree, va_gc> *labels; tree link_next; expr = *expr_p; noutputs = list_length (ASM_OUTPUTS (expr)); oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *)); - inputs = outputs = clobbers = labels = NULL; + inputs = NULL; + outputs = NULL; + clobbers = NULL; + labels = NULL; ret = GS_ALL_DONE; link_next = NULL_TREE; @@ -5271,7 +5275,7 @@ gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) ret = tret; } - VEC_safe_push (tree, gc, outputs, link); + vec_safe_push (outputs, link); TREE_CHAIN (link) = NULL_TREE; if (is_inout) @@ -5418,14 +5422,14 @@ gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) } TREE_CHAIN (link) = NULL_TREE; - VEC_safe_push (tree, gc, inputs, link); + vec_safe_push (inputs, link); } for (link = ASM_CLOBBERS (expr); link; ++i, link = TREE_CHAIN (link)) - VEC_safe_push (tree, gc, clobbers, link); + vec_safe_push (clobbers, link); for (link = ASM_LABELS (expr); link; ++i, link = TREE_CHAIN (link)) - VEC_safe_push (tree, gc, labels, link); + vec_safe_push (labels, link); /* Do not add ASMs with errors to the gimple IL stream. */ if (ret != GS_ERROR) @@ -5658,7 +5662,8 @@ gimplify_target_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) && needs_to_live_in_memory (temp) && flag_stack_reuse == SR_ALL) { - tree clobber = build_constructor (TREE_TYPE (temp), NULL); + tree clobber = build_constructor (TREE_TYPE (temp), + NULL); TREE_THIS_VOLATILE (clobber) = true; clobber = build2 (MODIFY_EXPR, TREE_TYPE (temp), temp, clobber); if (cleanup) @@ -8254,38 +8259,36 @@ gimplify_body (tree fndecl, bool do_parms) } typedef char *char_p; /* For DEF_VEC_P. */ -DEF_VEC_P(char_p); -DEF_VEC_ALLOC_P(char_p,heap); /* Return whether we should exclude FNDECL from instrumentation. */ static bool flag_instrument_functions_exclude_p (tree fndecl) { - VEC(char_p,heap) *vec; + vec<char_p> *v; - vec = (VEC(char_p,heap) *) flag_instrument_functions_exclude_functions; - if (VEC_length (char_p, vec) > 0) + v = (vec<char_p> *) flag_instrument_functions_exclude_functions; + if (v && v->length () > 0) { const char *name; int i; char *s; name = lang_hooks.decl_printable_name (fndecl, 0); - FOR_EACH_VEC_ELT (char_p, vec, i, s) + FOR_EACH_VEC_ELT (*v, i, s) if (strstr (name, s) != NULL) return true; } - vec = (VEC(char_p,heap) *) flag_instrument_functions_exclude_files; - if (VEC_length (char_p, vec) > 0) + v = (vec<char_p> *) flag_instrument_functions_exclude_files; + if (v && v->length () > 0) { const char *name; int i; char *s; name = DECL_SOURCE_FILE (fndecl); - FOR_EACH_VEC_ELT (char_p, vec, i, s) + FOR_EACH_VEC_ELT (*v, i, s) if (strstr (name, s) != NULL) return true; } |