vec: add exact argument for various grow functions.
authorMartin Liska <mliska@suse.cz>
Mon, 10 Aug 2020 09:11:05 +0000 (11:11 +0200)
committerMartin Liska <mliska@suse.cz>
Thu, 27 Aug 2020 11:29:43 +0000 (13:29 +0200)
gcc/ada/ChangeLog:

* gcc-interface/trans.c (gigi): Set exact argument of a vector
growth function to true.
(Attribute_to_gnu): Likewise.

gcc/ChangeLog:

* alias.c (init_alias_analysis): Set exact argument of a vector
growth function to true.
* calls.c (internal_arg_pointer_based_exp_scan): Likewise.
* cfgbuild.c (find_many_sub_basic_blocks): Likewise.
* cfgexpand.c (expand_asm_stmt): Likewise.
* cfgrtl.c (rtl_create_basic_block): Likewise.
* combine.c (combine_split_insns): Likewise.
(combine_instructions): Likewise.
* config/aarch64/aarch64-sve-builtins.cc (function_expander::add_output_operand): Likewise.
(function_expander::add_input_operand): Likewise.
(function_expander::add_integer_operand): Likewise.
(function_expander::add_address_operand): Likewise.
(function_expander::add_fixed_operand): Likewise.
* df-core.c (df_worklist_dataflow_doublequeue): Likewise.
* dwarf2cfi.c (update_row_reg_save): Likewise.
* early-remat.c (early_remat::init_block_info): Likewise.
(early_remat::finalize_candidate_indices): Likewise.
* except.c (sjlj_build_landing_pads): Likewise.
* final.c (compute_alignments): Likewise.
(grow_label_align): Likewise.
* function.c (temp_slots_at_level): Likewise.
* fwprop.c (build_single_def_use_links): Likewise.
(update_uses): Likewise.
* gcc.c (insert_wrapper): Likewise.
* genautomata.c (create_state_ainsn_table): Likewise.
(add_vect): Likewise.
(output_dead_lock_vect): Likewise.
* genmatch.c (capture_info::capture_info): Likewise.
(parser::finish_match_operand): Likewise.
* genrecog.c (optimize_subroutine_group): Likewise.
(merge_pattern_info::merge_pattern_info): Likewise.
(merge_into_decision): Likewise.
(print_subroutine_start): Likewise.
(main): Likewise.
* gimple-loop-versioning.cc (loop_versioning::loop_versioning): Likewise.
* gimple.c (gimple_set_bb): Likewise.
* graphite-isl-ast-to-gimple.c (translate_isl_ast_node_user): Likewise.
* haifa-sched.c (sched_extend_luids): Likewise.
(extend_h_i_d): Likewise.
* insn-addr.h (insn_addresses_new): Likewise.
* ipa-cp.c (gather_context_independent_values): Likewise.
(find_more_contexts_for_caller_subset): Likewise.
* ipa-devirt.c (final_warning_record::grow_type_warnings): Likewise.
(ipa_odr_read_section): Likewise.
* ipa-fnsummary.c (evaluate_properties_for_edge): Likewise.
(ipa_fn_summary_t::duplicate): Likewise.
(analyze_function_body): Likewise.
(ipa_merge_fn_summary_after_inlining): Likewise.
(read_ipa_call_summary): Likewise.
* ipa-icf.c (sem_function::bb_dict_test): Likewise.
* ipa-prop.c (ipa_alloc_node_params): Likewise.
(parm_bb_aa_status_for_bb): Likewise.
(ipa_compute_jump_functions_for_edge): Likewise.
(ipa_analyze_node): Likewise.
(update_jump_functions_after_inlining): Likewise.
(ipa_read_edge_info): Likewise.
(read_ipcp_transformation_info): Likewise.
(ipcp_transform_function): Likewise.
* ipa-reference.c (ipa_reference_write_optimization_summary): Likewise.
* ipa-split.c (execute_split_functions): Likewise.
* ira.c (find_moveable_pseudos): Likewise.
* lower-subreg.c (decompose_multiword_subregs): Likewise.
* lto-streamer-in.c (input_eh_regions): Likewise.
(input_cfg): Likewise.
(input_struct_function_base): Likewise.
(input_function): Likewise.
* modulo-sched.c (set_node_sched_params): Likewise.
(extend_node_sched_params): Likewise.
(schedule_reg_moves): Likewise.
* omp-general.c (omp_construct_simd_compare): Likewise.
* passes.c (pass_manager::create_pass_tab): Likewise.
(enable_disable_pass): Likewise.
* predict.c (determine_unlikely_bbs): Likewise.
* profile.c (compute_branch_probabilities): Likewise.
* read-rtl-function.c (function_reader::parse_block): Likewise.
* read-rtl.c (rtx_reader::read_rtx_code): Likewise.
* reg-stack.c (stack_regs_mentioned): Likewise.
* regrename.c (regrename_init): Likewise.
* rtlanal.c (T>::add_single_to_queue): Likewise.
* sched-deps.c (init_deps_data_vector): Likewise.
* sel-sched-ir.c (sel_extend_global_bb_info): Likewise.
(extend_region_bb_info): Likewise.
(extend_insn_data): Likewise.
* symtab.c (symtab_node::create_reference): Likewise.
* tracer.c (tail_duplicate): Likewise.
* trans-mem.c (tm_region_init): Likewise.
(get_bb_regions_instrumented): Likewise.
* tree-cfg.c (init_empty_tree_cfg_for_function): Likewise.
(build_gimple_cfg): Likewise.
(create_bb): Likewise.
(move_block_to_fn): Likewise.
* tree-complex.c (tree_lower_complex): Likewise.
* tree-if-conv.c (predicate_rhs_code): Likewise.
* tree-inline.c (copy_bb): Likewise.
* tree-into-ssa.c (get_ssa_name_ann): Likewise.
(mark_phi_for_rewrite): Likewise.
* tree-object-size.c (compute_builtin_object_size): Likewise.
(init_object_sizes): Likewise.
* tree-predcom.c (initialize_root_vars_store_elim_1): Likewise.
(initialize_root_vars_store_elim_2): Likewise.
(prepare_initializers_chain_store_elim): Likewise.
* tree-ssa-address.c (addr_for_mem_ref): Likewise.
(multiplier_allowed_in_address_p): Likewise.
* tree-ssa-coalesce.c (ssa_conflicts_new): Likewise.
* tree-ssa-forwprop.c (simplify_vector_constructor): Likewise.
* tree-ssa-loop-ivopts.c (addr_offset_valid_p): Likewise.
(get_address_cost_ainc): Likewise.
* tree-ssa-loop-niter.c (discover_iteration_bound_by_body_walk): Likewise.
* tree-ssa-pre.c (add_to_value): Likewise.
(phi_translate_1): Likewise.
(do_pre_regular_insertion): Likewise.
(do_pre_partial_partial_insertion): Likewise.
(init_pre): Likewise.
* tree-ssa-propagate.c (ssa_prop_init): Likewise.
(update_call_from_tree): Likewise.
* tree-ssa-reassoc.c (optimize_range_tests_cmp_bitwise): Likewise.
* tree-ssa-sccvn.c (vn_reference_lookup_3): Likewise.
(vn_reference_lookup_pieces): Likewise.
(eliminate_dom_walker::eliminate_push_avail): Likewise.
* tree-ssa-strlen.c (set_strinfo): Likewise.
(get_stridx_plus_constant): Likewise.
(zero_length_string): Likewise.
(find_equal_ptrs): Likewise.
(printf_strlen_execute): Likewise.
* tree-ssa-threadedge.c (set_ssa_name_value): Likewise.
* tree-ssanames.c (make_ssa_name_fn): Likewise.
* tree-streamer-in.c (streamer_read_tree_bitfields): Likewise.
* tree-vect-loop.c (vect_record_loop_mask): Likewise.
(vect_get_loop_mask): Likewise.
(vect_record_loop_len): Likewise.
(vect_get_loop_len): Likewise.
* tree-vect-patterns.c (vect_recog_mask_conversion_pattern): Likewise.
* tree-vect-slp.c (vect_slp_convert_to_external): Likewise.
(vect_bb_slp_scalar_cost): Likewise.
(vect_bb_vectorization_profitable_p): Likewise.
(vectorizable_slp_permutation): Likewise.
* tree-vect-stmts.c (vectorizable_call): Likewise.
(vectorizable_simd_clone_call): Likewise.
(scan_store_can_perm_p): Likewise.
(vectorizable_store): Likewise.
* expr.c: Likewise.
* vec.c (test_safe_grow_cleared): Likewise.
* vec.h (vec_safe_grow): Likewise.
(vec_safe_grow_cleared): Likewise.
(vl_ptr>::safe_grow): Likewise.
(vl_ptr>::safe_grow_cleared): Likewise.
* config/c6x/c6x.c (insn_set_clock): Likewise.

gcc/c/ChangeLog:

* gimple-parser.c (c_parser_gimple_compound_statement): Set exact argument of a vector
growth function to true.

gcc/cp/ChangeLog:

* class.c (build_vtbl_initializer): Set exact argument of a vector
growth function to true.
* constraint.cc (get_mapped_args): Likewise.
* decl.c (cp_maybe_mangle_decomp): Likewise.
(cp_finish_decomp): Likewise.
* parser.c (cp_parser_omp_for_loop): Likewise.
* pt.c (canonical_type_parameter): Likewise.
* rtti.c (get_pseudo_ti_init): Likewise.

gcc/fortran/ChangeLog:

* trans-openmp.c (gfc_trans_omp_do): Set exact argument of a vector
growth function to true.

gcc/lto/ChangeLog:

* lto-common.c (lto_file_finalize): Set exact argument of a vector
growth function to true.

86 files changed:
gcc/ada/gcc-interface/trans.c
gcc/alias.c
gcc/c/gimple-parser.c
gcc/calls.c
gcc/cfgbuild.c
gcc/cfgexpand.c
gcc/cfgrtl.c
gcc/combine.c
gcc/config/aarch64/aarch64-sve-builtins.cc
gcc/config/c6x/c6x.c
gcc/cp/class.c
gcc/cp/constraint.cc
gcc/cp/decl.c
gcc/cp/parser.c
gcc/cp/pt.c
gcc/cp/rtti.c
gcc/df-core.c
gcc/dwarf2cfi.c
gcc/early-remat.c
gcc/except.c
gcc/expr.c
gcc/final.c
gcc/fortran/trans-openmp.c
gcc/function.c
gcc/fwprop.c
gcc/gcc.c
gcc/genautomata.c
gcc/genmatch.c
gcc/genrecog.c
gcc/gimple-loop-versioning.cc
gcc/gimple.c
gcc/graphite-isl-ast-to-gimple.c
gcc/haifa-sched.c
gcc/insn-addr.h
gcc/ipa-cp.c
gcc/ipa-devirt.c
gcc/ipa-fnsummary.c
gcc/ipa-icf.c
gcc/ipa-prop.c
gcc/ipa-reference.c
gcc/ipa-split.c
gcc/ira.c
gcc/lower-subreg.c
gcc/lto-streamer-in.c
gcc/lto/lto-common.c
gcc/modulo-sched.c
gcc/omp-general.c
gcc/passes.c
gcc/predict.c
gcc/profile.c
gcc/read-rtl-function.c
gcc/read-rtl.c
gcc/reg-stack.c
gcc/regrename.c
gcc/rtlanal.c
gcc/sched-deps.c
gcc/sel-sched-ir.c
gcc/symtab.c
gcc/tracer.c
gcc/trans-mem.c
gcc/tree-cfg.c
gcc/tree-complex.c
gcc/tree-if-conv.c
gcc/tree-inline.c
gcc/tree-into-ssa.c
gcc/tree-object-size.c
gcc/tree-predcom.c
gcc/tree-ssa-address.c
gcc/tree-ssa-coalesce.c
gcc/tree-ssa-forwprop.c
gcc/tree-ssa-loop-ivopts.c
gcc/tree-ssa-loop-niter.c
gcc/tree-ssa-pre.c
gcc/tree-ssa-propagate.c
gcc/tree-ssa-reassoc.c
gcc/tree-ssa-sccvn.c
gcc/tree-ssa-strlen.c
gcc/tree-ssa-threadedge.c
gcc/tree-ssanames.c
gcc/tree-streamer-in.c
gcc/tree-vect-loop.c
gcc/tree-vect-patterns.c
gcc/tree-vect-slp.c
gcc/tree-vect-stmts.c
gcc/vec.c
gcc/vec.h

index f74e0e728c9a78aba0b9ff5e3725102417de619d..e3d71bca40f0b97a4fe486cbaf0508d6b2ae9e7a 100644 (file)
@@ -624,7 +624,7 @@ gigi (Node_Id gnat_root,
       constructor_elt *elt;
 
       fdesc_type_node = make_node (RECORD_TYPE);
-      vec_safe_grow (null_vec, TARGET_VTABLE_USES_DESCRIPTORS);
+      vec_safe_grow (null_vec, TARGET_VTABLE_USES_DESCRIPTORS, true);
       elt = (null_vec->address () + TARGET_VTABLE_USES_DESCRIPTORS - 1);
 
       for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; j++)
@@ -1747,7 +1747,7 @@ Attribute_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, int attribute)
              gnu_result = build1 (INDIRECT_REF, gnu_result_type, gnu_result);
            }
 
-         vec_safe_grow (gnu_vec, TARGET_VTABLE_USES_DESCRIPTORS);
+         vec_safe_grow (gnu_vec, TARGET_VTABLE_USES_DESCRIPTORS, true);
          elt = (gnu_vec->address () + TARGET_VTABLE_USES_DESCRIPTORS - 1);
          for (gnu_field = TYPE_FIELDS (gnu_result_type), i = 0;
               i < TARGET_VTABLE_USES_DESCRIPTORS;
index 49bd7b37966f1e836b601840328a77cdd4af61f5..df85f07ee9acfd8fdfb3a65229afc4bc1bde38b0 100644 (file)
@@ -3349,7 +3349,8 @@ init_alias_analysis (void)
 
   timevar_push (TV_ALIAS_ANALYSIS);
 
-  vec_safe_grow_cleared (reg_known_value, maxreg - FIRST_PSEUDO_REGISTER);
+  vec_safe_grow_cleared (reg_known_value, maxreg - FIRST_PSEUDO_REGISTER,
+                        true);
   reg_known_equiv_p = sbitmap_alloc (maxreg - FIRST_PSEUDO_REGISTER);
   bitmap_clear (reg_known_equiv_p);
 
@@ -3360,7 +3361,7 @@ init_alias_analysis (void)
   if (reg_base_value)
     reg_base_value->truncate (0);
 
-  vec_safe_grow_cleared (reg_base_value, maxreg);
+  vec_safe_grow_cleared (reg_base_value, maxreg, true);
 
   new_reg_base_value = XNEWVEC (rtx, maxreg);
   reg_seen = sbitmap_alloc (maxreg);
index 577d8b58c7d80dd0170ace60acfff4f9e6a1a609..5c0ed826119795ae0a59d9c8e0b467428a930257 100644 (file)
@@ -590,7 +590,7 @@ c_parser_gimple_compound_statement (gimple_parser &parser, gimple_seq *seq)
                               : ENTRY_BLOCK_PTR_FOR_FN (cfun)));
              if (basic_block_info_for_fn (cfun)->length () <= (size_t)index)
                vec_safe_grow_cleared (basic_block_info_for_fn (cfun),
-                                      index + 1);
+                                      index + 1, true);
              SET_BASIC_BLOCK_FOR_FN (cfun, index, bb);
              if (last_basic_block_for_fn (cfun) <= index)
                last_basic_block_for_fn (cfun) = index + 1;
@@ -617,7 +617,7 @@ c_parser_gimple_compound_statement (gimple_parser &parser, gimple_seq *seq)
                      loop->num = is_loop_header_of;
                      loop->header = bb;
                      vec_safe_grow_cleared (loops_for_fn (cfun)->larray,
-                                            is_loop_header_of + 1);
+                                            is_loop_header_of + 1, true);
                      (*loops_for_fn (cfun)->larray)[is_loop_header_of] = loop;
                      flow_loop_tree_node_add (loops_for_fn (cfun)->tree_root,
                                               loop);
index 44401e6350d8d59538b386fbf9963726f062fbc1..a11da66492d001cd0bd56f07a11e35c2bcf6e754 100644 (file)
@@ -2881,7 +2881,7 @@ internal_arg_pointer_based_exp_scan (void)
            {
              if (idx >= internal_arg_pointer_exp_state.cache.length ())
                internal_arg_pointer_exp_state.cache
-                 .safe_grow_cleared (idx + 1);
+                 .safe_grow_cleared (idx + 1, true);
              internal_arg_pointer_exp_state.cache[idx] = val;
            }
        }
index 478afa5fe91c6c74c27220c421b1747dd7f3ebdd..5c3772cd40af1d13323d2e068850da9d98d38d37 100644 (file)
@@ -657,7 +657,7 @@ find_many_sub_basic_blocks (sbitmap blocks)
   basic_block bb, min, max;
   bool found = false;
   auto_vec<unsigned int> n_succs;
-  n_succs.safe_grow_cleared (last_basic_block_for_fn (cfun));
+  n_succs.safe_grow_cleared (last_basic_block_for_fn (cfun), true);
 
   FOR_EACH_BB_FN (bb, cfun)
     SET_STATE (bb,
index b270a4ddb9db469ba52e42f36a1bc2f02d8f03fc..b334ea03c2568a79e778c41c68a7c71327ad46f8 100644 (file)
@@ -2949,9 +2949,9 @@ expand_asm_stmt (gasm *stmt)
 
   /* Copy the gimple vectors into new vectors that we can manipulate.  */
 
-  output_tvec.safe_grow (noutputs);
-  input_tvec.safe_grow (ninputs);
-  constraints.safe_grow (noutputs + ninputs);
+  output_tvec.safe_grow (noutputs, true);
+  input_tvec.safe_grow (ninputs, true);
+  constraints.safe_grow (noutputs + ninputs, true);
 
   for (i = 0; i < noutputs; ++i)
     {
@@ -3124,7 +3124,7 @@ expand_asm_stmt (gasm *stmt)
   auto_vec<int, MAX_RECOG_OPERANDS> inout_opnum;
   rtx_insn *after_rtl_seq = NULL, *after_rtl_end = NULL;
 
-  output_rvec.safe_grow (noutputs);
+  output_rvec.safe_grow (noutputs, true);
 
   for (i = 0; i < noutputs; ++i)
     {
@@ -3203,8 +3203,8 @@ expand_asm_stmt (gasm *stmt)
   auto_vec<rtx, MAX_RECOG_OPERANDS> input_rvec;
   auto_vec<machine_mode, MAX_RECOG_OPERANDS> input_mode;
 
-  input_rvec.safe_grow (ninputs);
-  input_mode.safe_grow (ninputs);
+  input_rvec.safe_grow (ninputs, true);
+  input_mode.safe_grow (ninputs, true);
 
   generating_concat_p = 0;
 
index 827e84a44ddd957b3d0d37c1313b9e6cef190a1c..03fa688fed681dec2f25d72e721189834350a839 100644 (file)
@@ -378,7 +378,7 @@ rtl_create_basic_block (void *headp, void *endp, basic_block after)
       size_t new_size =
        (last_basic_block_for_fn (cfun)
         + (last_basic_block_for_fn (cfun) + 3) / 4);
-      vec_safe_grow_cleared (basic_block_info_for_fn (cfun), new_size);
+      vec_safe_grow_cleared (basic_block_info_for_fn (cfun), new_size, true);
     }
 
   n_basic_blocks_for_fn (cfun)++;
index 4fee114b3cc141de18f05ec9b243e36f0855de33..c88382efbd3bdf1a1801f1837f244451922879ef 100644 (file)
@@ -544,7 +544,7 @@ combine_split_insns (rtx pattern, rtx_insn *insn)
   ret = split_insns (pattern, insn);
   nregs = max_reg_num ();
   if (nregs > reg_stat.length ())
-    reg_stat.safe_grow_cleared (nregs);
+    reg_stat.safe_grow_cleared (nregs, true);
   return ret;
 }
 
@@ -1172,7 +1172,7 @@ combine_instructions (rtx_insn *f, unsigned int nregs)
 
   rtl_hooks = combine_rtl_hooks;
 
-  reg_stat.safe_grow_cleared (nregs);
+  reg_stat.safe_grow_cleared (nregs, true);
 
   init_recog_no_volatile ();
 
index e753966efba70c0ce77e796b8a7a4dc5f77a2181..e73aa9ad8a988734ec91ac5afbee04962f80b84d 100644 (file)
@@ -2793,7 +2793,7 @@ function_expander::add_output_operand (insn_code icode)
 {
   unsigned int opno = m_ops.length ();
   machine_mode mode = insn_data[icode].operand[opno].mode;
-  m_ops.safe_grow (opno + 1);
+  m_ops.safe_grow (opno + 1, true);
   create_output_operand (&m_ops.last (), possible_target, mode);
 }
 
@@ -2830,7 +2830,7 @@ function_expander::add_input_operand (insn_code icode, rtx x)
       gcc_assert (GET_MODE (x) == VNx16BImode);
       x = gen_lowpart (mode, x);
     }
-  m_ops.safe_grow (m_ops.length () + 1);
+  m_ops.safe_grow (m_ops.length () + 1, true);
   create_input_operand (&m_ops.last (), x, mode);
 }
 
@@ -2838,7 +2838,7 @@ function_expander::add_input_operand (insn_code icode, rtx x)
 void
 function_expander::add_integer_operand (HOST_WIDE_INT x)
 {
-  m_ops.safe_grow (m_ops.length () + 1);
+  m_ops.safe_grow (m_ops.length () + 1, true);
   create_integer_operand (&m_ops.last (), x);
 }
 
@@ -2862,7 +2862,7 @@ function_expander::add_mem_operand (machine_mode mode, rtx addr)
 void
 function_expander::add_address_operand (rtx x)
 {
-  m_ops.safe_grow (m_ops.length () + 1);
+  m_ops.safe_grow (m_ops.length () + 1, true);
   create_address_operand (&m_ops.last (), x);
 }
 
@@ -2871,7 +2871,7 @@ function_expander::add_address_operand (rtx x)
 void
 function_expander::add_fixed_operand (rtx x)
 {
-  m_ops.safe_grow (m_ops.length () + 1);
+  m_ops.safe_grow (m_ops.length () + 1, true);
   create_fixed_operand (&m_ops.last (), x);
 }
 
index 39b0f753047b42b4d1b1eeb3982c2e01dafd0625..6bd793bdd21bc324935907a8cb0c101aa620cbb8 100644 (file)
@@ -3698,7 +3698,7 @@ insn_set_clock (rtx insn, int cycle)
   unsigned uid = INSN_UID (insn);
 
   if (uid >= INSN_INFO_LENGTH)
-    insn_info.safe_grow (uid * 5 / 4 + 10);
+    insn_info.safe_grow (uid * 5 / 4 + 10, true);
 
   INSN_INFO_ENTRY (uid).clock = cycle;
   INSN_INFO_ENTRY (uid).new_cond = NULL;
index b39bdaaa3ab7b0379b891b79bd8383ad0871ecd0..3479b8207d2d1a8a5e696229c74fbc1efc61343a 100644 (file)
@@ -9742,7 +9742,8 @@ build_vtbl_initializer (tree binfo,
     {
       int n_entries = vec_safe_length (vid.inits);
 
-      vec_safe_grow (vid.inits, TARGET_VTABLE_DATA_ENTRY_DISTANCE * n_entries);
+      vec_safe_grow (vid.inits, TARGET_VTABLE_DATA_ENTRY_DISTANCE * n_entries,
+                    true);
 
       /* Move data entries into their new positions and add padding
         after the new positions.  Iterate backwards so we don't
@@ -9774,7 +9775,7 @@ build_vtbl_initializer (tree binfo,
      order.  Straighten them out and add them to the running list in one
      step.  */
   jx = vec_safe_length (*inits);
-  vec_safe_grow (*inits, jx + vid.inits->length ());
+  vec_safe_grow (*inits, jx + vid.inits->length (), true);
 
   for (ix = vid.inits->length () - 1;
        vid.inits->iterate (ix, &e);
index 7a2f3b9fde02f5c90602ab201615e7336c3e8e92..ad9d47070e3890e3a411f1807ccd88bc3288e0fb 100644 (file)
@@ -2552,7 +2552,7 @@ get_mapped_args (tree map)
       /* Insert the argument into its corresponding position.  */
       vec<tree> &list = lists[level - 1];
       if (index >= (int)list.length ())
-       list.safe_grow_cleared (index + 1);
+       list.safe_grow_cleared (index + 1, true);
       list[index] = TREE_PURPOSE (p);
     }
 
index 5e17e4dc4b1626201cf90a259aa93c159ad953d9..4c84f2d0a9bebb2d1b457cc1db010f8a89f2e1ba 100644 (file)
@@ -8214,7 +8214,7 @@ cp_maybe_mangle_decomp (tree decl, tree first, unsigned int count)
       && TREE_STATIC (decl))
     {
       auto_vec<tree, 16> v;
-      v.safe_grow (count);
+      v.safe_grow (count, true);
       tree d = first;
       for (unsigned int i = 0; i < count; i++, d = DECL_CHAIN (d))
        v[count - i - 1] = d;
@@ -8274,7 +8274,7 @@ cp_finish_decomp (tree decl, tree first, unsigned int count)
     }
 
   auto_vec<tree, 16> v;
-  v.safe_grow (count);
+  v.safe_grow (count, true);
   tree d = first;
   for (unsigned int i = 0; i < count; i++, d = DECL_CHAIN (d))
     {
index 7cc2dbed5fe5bd9d13c8bdc0af59a933c8003219..147d5374907959aeb99611e67051239cbb222f1d 100644 (file)
@@ -39302,7 +39302,7 @@ cp_parser_omp_for_loop (cp_parser *parser, enum tree_code code, tree clauses,
       TREE_VEC_ELT (incrv, i) = incr;
       if (orig_init)
        {
-         orig_inits.safe_grow_cleared (i + 1);
+         orig_inits.safe_grow_cleared (i + 1, true);
          orig_inits[i] = orig_init;
        }
       if (orig_decl)
index 5dbdd37f6e3ed6b34e8457125fb3bbe22e1d00dd..ad8c988d41e26653e6109d6282af11ad5ed6227f 100644 (file)
@@ -4431,7 +4431,7 @@ canonical_type_parameter (tree type)
   gcc_assert (TREE_CODE (type) != TEMPLATE_TEMPLATE_PARM);
 
   if (vec_safe_length (canonical_template_parms) <= (unsigned) idx)
-    vec_safe_grow_cleared (canonical_template_parms, idx + 1);
+    vec_safe_grow_cleared (canonical_template_parms, idx + 1, true);
 
   for (tree list = (*canonical_template_parms)[idx];
        list; list = TREE_CHAIN (list))
index 432ebab2639339a8c1ce2bde741a4f445f7f568e..0ab3c425c7338c71d5aba594ebab3cbb34ac8d14 100644 (file)
@@ -1177,7 +1177,7 @@ get_pseudo_ti_init (tree type, unsigned tk_index)
 
        gcc_assert (tk_index - TK_VMI_CLASS_TYPES + 1 == nbases);
 
-       vec_safe_grow (init_vec, nbases);
+       vec_safe_grow (init_vec, nbases, true);
        /* Generate the base information initializer.  */
        for (unsigned ix = nbases; ix--;)
          {
index 9875a26895c62518c297ac534e793a27dbd4534c..e0490893703bbb02af8aa708eaad98dc8122ce20 100644 (file)
@@ -1014,8 +1014,8 @@ df_worklist_dataflow_doublequeue (struct dataflow *dataflow,
   vec<int> last_change_age = vNULL;
   int prev_age;
 
-  last_visit_age.safe_grow_cleared (n_blocks);
-  last_change_age.safe_grow_cleared (n_blocks);
+  last_visit_age.safe_grow_cleared (n_blocks, true);
+  last_change_age.safe_grow_cleared (n_blocks, true);
 
   /* Double-queueing. Worklist is for the current iteration,
      and pending is for the next. */
index 0d179b388e49256e31af13cf6a9fedd87cd53728..ccfc2bd0ea90065c87a4473cef0e1b1da488bc54 100644 (file)
@@ -524,7 +524,7 @@ static void
 update_row_reg_save (dw_cfi_row *row, unsigned column, dw_cfi_ref cfi)
 {
   if (vec_safe_length (row->reg_save) <= column)
-    vec_safe_grow_cleared (row->reg_save, column + 1);
+    vec_safe_grow_cleared (row->reg_save, column + 1, true);
   (*row->reg_save)[column] = cfi;
 }
 
index 9f5f85416448b046c16ec59f9499da48576f11f1..5e415f77d5d35f830af2ad29f2229c527ce160cd 100644 (file)
@@ -1007,7 +1007,7 @@ void
 early_remat::init_block_info (void)
 {
   unsigned int n_blocks = last_basic_block_for_fn (m_fn);
-  m_block_info.safe_grow_cleared (n_blocks);
+  m_block_info.safe_grow_cleared (n_blocks, true);
 }
 
 /* Maps basic block indices to their position in the post order.  */
@@ -1068,7 +1068,7 @@ void
 early_remat::finalize_candidate_indices (void)
 {
   /* Create a bitmap for each candidate register.  */
-  m_regno_to_candidates.safe_grow (max_reg_num ());
+  m_regno_to_candidates.safe_grow (max_reg_num (), true);
   unsigned int regno;
   bitmap_iterator bi;
   EXECUTE_IF_SET_IN_BITMAP (&m_candidate_regnos, 0, regno, bi)
index 5df0a4c163d426275efe52d41ac541e71a6add6b..3152ee120a8400c0d7630fa96c7cb636b3c10542 100644 (file)
@@ -1454,7 +1454,7 @@ sjlj_build_landing_pads (void)
   num_dispatch = vec_safe_length (cfun->eh->lp_array);
   if (num_dispatch == 0)
     return;
-  sjlj_lp_call_site_index.safe_grow_cleared (num_dispatch);
+  sjlj_lp_call_site_index.safe_grow_cleared (num_dispatch, true);
 
   num_dispatch = sjlj_assign_call_site_values ();
   if (num_dispatch > 0)
index 437faeaba08030f54b26325e0747049f0be164d5..1a15f24b3979abae628c0fd9857f62d70c149d33 100644 (file)
@@ -11639,7 +11639,7 @@ convert_to_bytes (tree type, tree expr, vec<unsigned char> *bytes)
              if (unsigned HOST_WIDE_INT size = cur_idx - (last_idx + 1))
                {
                  size = size * elsize + bytes->length ();
-                 bytes->safe_grow_cleared (size);
+                 bytes->safe_grow_cleared (size, true);
                }
 
              if (!convert_to_bytes (eltype, val, bytes))
@@ -11658,7 +11658,7 @@ convert_to_bytes (tree type, tree expr, vec<unsigned char> *bytes)
                 any padding.  */
              unsigned HOST_WIDE_INT cur_off = int_byte_position (fld);
              if (bytes->length () < cur_off)
-               bytes->safe_grow_cleared (cur_off);
+               bytes->safe_grow_cleared (cur_off, true);
 
              if (!convert_to_bytes (TREE_TYPE (val), val, bytes))
                return false;
@@ -11678,7 +11678,7 @@ convert_to_bytes (tree type, tree expr, vec<unsigned char> *bytes)
       unsigned HOST_WIDE_INT type_size = tree_to_uhwi (size);
       if (ctor_size < type_size)
        if (unsigned HOST_WIDE_INT size_grow = type_size - ctor_size)
-         bytes->safe_grow_cleared (bytes->length () + size_grow);
+         bytes->safe_grow_cleared (bytes->length () + size_grow, true);
 
       return true;
     }
@@ -11699,7 +11699,7 @@ convert_to_bytes (tree type, tree expr, vec<unsigned char> *bytes)
 
   /* Unlike for RECORD_TYPE, there is no need to clear the memory since
      it's completely overwritten by native_encode_expr.  */
-  bytes->safe_grow (bytes_sofar + expr_bytes);
+  bytes->safe_grow (bytes_sofar + expr_bytes, true);
   unsigned char *pnext = bytes->begin () + bytes_sofar;
   int nbytes = native_encode_expr (expr, pnext, expr_bytes, 0);
   /* NBYTES is zero on failure.  Otherwise it should equal EXPR_BYTES.  */
index a3601964a8d31f2436e7c8e3d378345c8cf8dd60..80423d117d9c11b612de67b68ee06826010bed8b 100644 (file)
@@ -642,7 +642,7 @@ compute_alignments (void)
 
   max_labelno = max_label_num ();
   min_labelno = get_first_label_num ();
-  label_align.safe_grow_cleared (max_labelno - min_labelno + 1);
+  label_align.safe_grow_cleared (max_labelno - min_labelno + 1, true);
 
   /* If not optimizing or optimizing for size, don't assign any alignments.  */
   if (! optimize || optimize_function_for_size_p (cfun))
@@ -771,7 +771,7 @@ grow_label_align (void)
   n_labels = max_labelno - min_labelno + 1;
   n_old_labels = old - min_labelno + 1;
 
-  label_align.safe_grow_cleared (n_labels);
+  label_align.safe_grow_cleared (n_labels, true);
 
   /* Range of labels grows monotonically in the function.  Failing here
      means that the initialization of array got lost.  */
index 063d4c145e20f0ad022eb17f5ce771d4c3cf20f9..7d3365fe7e0045aa1ce68d66a002f34b848e7758 100644 (file)
@@ -4480,7 +4480,7 @@ gfc_trans_omp_do (gfc_code *code, gfc_exec_op op, stmtblock_t *pblock,
          if (clauses->orderedc)
            {
              if (doacross_steps == NULL)
-               vec_safe_grow_cleared (doacross_steps, clauses->orderedc);
+               vec_safe_grow_cleared (doacross_steps, clauses->orderedc, true);
              (*doacross_steps)[i] = step;
            }
        }
index cdfcc4b6b86810f9a3d677f827ae6c8b98b9191e..2c8fa217f1ff8266d62928814f3f3b1cdd6e24eb 100644 (file)
@@ -637,7 +637,7 @@ static class temp_slot **
 temp_slots_at_level (int level)
 {
   if (level >= (int) vec_safe_length (used_temp_slots))
-    vec_safe_grow_cleared (used_temp_slots, level + 1);
+    vec_safe_grow_cleared (used_temp_slots, level + 1, true);
 
   return &(*used_temp_slots)[level];
 }
index 705d2885aae07ae8d231de0993c61295a9cec6dc..756c1d6b4055aa97028aec9efa9d14a96ee81fa3 100644 (file)
@@ -292,10 +292,10 @@ build_single_def_use_links (void)
   df_maybe_reorganize_use_refs (DF_REF_ORDER_BY_INSN_WITH_NOTES);
 
   use_def_ref.create (DF_USES_TABLE_SIZE ());
-  use_def_ref.safe_grow_cleared (DF_USES_TABLE_SIZE ());
+  use_def_ref.safe_grow_cleared (DF_USES_TABLE_SIZE (), true);
 
   reg_defs.create (max_reg_num ());
-  reg_defs.safe_grow_cleared (max_reg_num ());
+  reg_defs.safe_grow_cleared (max_reg_num (), true);
 
   reg_defs_stack.create (n_basic_blocks_for_fn (cfun) * 10);
   local_md = BITMAP_ALLOC (NULL);
@@ -975,7 +975,7 @@ update_uses (df_ref use)
 
       /* Set up the use-def chain.  */
       if (DF_REF_ID (use) >= (int) use_def_ref.length ())
-        use_def_ref.safe_grow_cleared (DF_REF_ID (use) + 1);
+       use_def_ref.safe_grow_cleared (DF_REF_ID (use) + 1, true);
 
       if (flag_checking)
        gcc_assert (sparseset_bit_p (active_defs_check, regno));
index a38d684f34dbcdc79436cc9ccfa2bf24dfd04839..531f4e02dbdbdd8d5b1884ce9afdf37dda973fb1 100644 (file)
--- a/gcc/gcc.c
+++ b/gcc/gcc.c
@@ -5482,7 +5482,7 @@ insert_wrapper (const char *wrapper)
     }
   while ((p = strchr (p, ',')) != NULL);
 
-  argbuf.safe_grow (old_length + n);
+  argbuf.safe_grow (old_length + n, true);
   memmove (argbuf.address () + n,
           argbuf.address (),
           old_length * sizeof (const_char_p));
index 0f29e206dcb2c3e7b91c277a330a1d69c52a4e2e..849a16162e537ee31a4a49b47ba873e79a9c2942 100644 (file)
@@ -7247,7 +7247,7 @@ create_state_ainsn_table (automaton_t automaton)
   tab->check_vect.create (10000);
 
   tab->base_vect.create (0);
-  tab->base_vect.safe_grow (automaton->achieved_states_num);
+  tab->base_vect.safe_grow (automaton->achieved_states_num, true);
 
   full_vect_length = (automaton->insn_equiv_classes_num
                       * automaton->achieved_states_num);
@@ -7339,7 +7339,7 @@ add_vect (state_ainsn_table_t tab, int vect_num, vla_hwint_t vect)
   {
     size_t full_base = tab->automaton->insn_equiv_classes_num * vect_num;
     if (tab->full_vect.length () < full_base + vect_length)
-      tab->full_vect.safe_grow (full_base + vect_length);
+      tab->full_vect.safe_grow (full_base + vect_length, true);
     for (i = 0; i < vect_length; i++)
       tab->full_vect[full_base + i] = vect[i];
   }
@@ -7743,7 +7743,7 @@ output_dead_lock_vect (automaton_t automaton)
   output_states_vect.create (0);
   pass_states (automaton, add_states_vect_el);
 
-  dead_lock_vect.safe_grow (output_states_vect.length ());
+  dead_lock_vect.safe_grow (output_states_vect.length (), true);
   for (i = 0; i < output_states_vect.length (); i++)
     {
       state_t s = output_states_vect[i];
index 107f6f2ec9ee97cfaaceb7ede88c8c3198cf811f..906d842c4d831d2609410aee8b7215fb042dcd86 100644 (file)
@@ -2122,7 +2122,7 @@ capture_info::capture_info (simplify *s, operand *result, bool gimple_)
     }
 
   force_no_side_effects = 0;
-  info.safe_grow_cleared (s->capture_max + 1);
+  info.safe_grow_cleared (s->capture_max + 1, true);
   for (int i = 0; i <= s->capture_max; ++i)
     info[i].same_as = i;
 
@@ -5050,7 +5050,7 @@ parser::finish_match_operand (operand *op)
   /* Look for matching captures, diagnose mis-uses of @@ and apply
      early lowering and distribution of value_match.  */
   auto_vec<vec<capture *> > cpts;
-  cpts.safe_grow_cleared (capture_ids->elements ());
+  cpts.safe_grow_cleared (capture_ids->elements (), true);
   walk_captures (op, cpts);
   for (unsigned i = 0; i < cpts.length (); ++i)
     {
index bc371b1903c65197dc5c42e0f5b655041dc260d7..5b5b72fd6ca76584fec903454e0d9abbdf0a6495 100644 (file)
@@ -2214,8 +2214,8 @@ optimize_subroutine_group (const char *type, state *root)
   if (cse_tests_p)
     {
       known_conditions kc;
-      kc.position_tests.safe_grow_cleared (num_positions);
-      kc.set_operands.safe_grow_cleared (num_operands);
+      kc.position_tests.safe_grow_cleared (num_positions, true);
+      kc.set_operands.safe_grow_cleared (num_operands, true);
       kc.peep2_count = 1;
       cse_tests (&root_pos, root, &kc);
     }
@@ -2337,7 +2337,7 @@ merge_pattern_info::merge_pattern_info (unsigned int num_transitions)
     num_results (0),
     routine (0)
 {
-  transitions.safe_grow_cleared (num_transitions);
+  transitions.safe_grow_cleared (num_transitions, true);
 }
 
 /* Describes one way of matching a particular state to a particular
@@ -3667,7 +3667,7 @@ merge_into_decision (decision *d1, state *s2, const int_set *exclude,
     {
       transition *trans1 = intersecting[i];
       next->truncate (0);
-      next->safe_grow (trans1->labels.length () + combined->length ());
+      next->safe_grow (trans1->labels.length () + combined->length (), true);
       int_set::iterator end
        = std::set_union (trans1->labels.begin (), trans1->labels.end (),
                          combined->begin (), combined->end (),
@@ -5148,7 +5148,7 @@ print_subroutine_start (output_state *os, state *s, position *root)
        }
 
       /* Say that x1 is valid and the rest aren't.  */
-      os->seen_vars.safe_grow_cleared (num_vars);
+      os->seen_vars.safe_grow_cleared (num_vars, true);
       os->seen_vars[1] = true;
     }
   if (os->type == SUBPATTERN || os->type == RECOG)
@@ -5421,7 +5421,7 @@ main (int argc, const char **argv)
   optimize_subroutine_group ("peephole2_insns", &peephole2_root);
 
   output_state os;
-  os.id_to_var.safe_grow_cleared (num_positions);
+  os.id_to_var.safe_grow_cleared (num_positions, true);
 
   if (use_pattern_routines_p)
     {
index 002b2a68b96a2b9aa6fbcb54d682c1385a92d5fb..2687088a9084aae66d098ea064d3886d61b6c22c 100644 (file)
@@ -555,7 +555,7 @@ loop_versioning::loop_versioning (function *fn)
   gcc_obstack_init (&m_obstack);
 
   /* Initialize the loop information.  */
-  m_loops.safe_grow_cleared (m_nloops);
+  m_loops.safe_grow_cleared (m_nloops, true);
   for (unsigned int i = 0; i < m_nloops; ++i)
     {
       m_loops[i].outermost = get_loop (m_fn, 0);
@@ -564,7 +564,7 @@ loop_versioning::loop_versioning (function *fn)
 
   /* Initialize the list of blocks that belong to each loop.  */
   unsigned int nbbs = last_basic_block_for_fn (fn);
-  m_next_block_in_loop.safe_grow (nbbs);
+  m_next_block_in_loop.safe_grow (nbbs, true);
   basic_block bb;
   FOR_EACH_BB_FN (bb, fn)
     {
index bf863f67ee28715de5517d0a88dbe5731412b7fa..70aa3bc4233afaef2132467cfd003ab4ae2c267e 100644 (file)
@@ -1693,7 +1693,7 @@ gimple_set_bb (gimple *stmt, basic_block bb)
              unsigned new_len = 3 * uid / 2 + 1;
 
              vec_safe_grow_cleared (label_to_block_map_for_fn (cfun),
-                                    new_len);
+                                    new_len, true);
            }
        }
 
index 5fa70ff2d4e028d0c1bf0b48ccd91747ea1cb5f8..9f39df67b88ec99c824cf72731231de75dd87134 100644 (file)
@@ -808,7 +808,7 @@ translate_isl_ast_node_user (__isl_keep isl_ast_node *node,
   const int nb_loops = number_of_loops (cfun);
   vec<tree> iv_map;
   iv_map.create (nb_loops);
-  iv_map.safe_grow_cleared (nb_loops);
+  iv_map.safe_grow_cleared (nb_loops, true);
 
   build_iv_mapping (iv_map, gbb, user_expr, ip, pbb->scop->scop_info->region);
   isl_ast_expr_free (user_expr);
index 80687fb5359ec4f27645c4f535c4e47e16c3414c..350178c82b8143987d9e28ecd6a83436ff974247 100644 (file)
@@ -8967,7 +8967,7 @@ sched_extend_luids (void)
 {
   int new_luids_max_uid = get_max_uid () + 1;
 
-  sched_luids.safe_grow_cleared (new_luids_max_uid);
+  sched_luids.safe_grow_cleared (new_luids_max_uid, true);
 }
 
 /* Initialize LUID for INSN.  */
@@ -9039,7 +9039,7 @@ extend_h_i_d (void)
   if (reserve > 0
       && ! h_i_d.space (reserve))
     {
-      h_i_d.safe_grow_cleared (3 * get_max_uid () / 2);
+      h_i_d.safe_grow_cleared (3 * get_max_uid () / 2, true);
       sched_extend_target ();
     }
 }
index f595c379b42a4656f7785122702ff6d26d6e7178..b897c65235c7cd66962abbc5d8e6d53c1fd93144 100644 (file)
@@ -28,7 +28,7 @@ extern int insn_current_address;
   do                                                   \
     {                                                  \
       insn_addresses_.create (size);                   \
-      insn_addresses_.safe_grow_cleared (size);                \
+      insn_addresses_.safe_grow_cleared (size, true);  \
       memset (insn_addresses_.address (),              \
              0, sizeof (int) * size);                  \
     }                                                  \
@@ -48,7 +48,7 @@ insn_addresses_new (rtx_insn *insn, int insn_addr)
       if (size <= insn_uid)
        {
          int *p;
-         insn_addresses_.safe_grow (insn_uid + 1);
+         insn_addresses_.safe_grow (insn_uid + 1, true);
          p = insn_addresses_.address ();
          memset (&p[size],
                  0, sizeof (int) * (insn_uid + 1 - size));
index e4910a04ffaa03776cbaed17dd7dcbb34ba4b2e1..7ae6c883a1d0d2af998b336305616aef5f6fcf7f 100644 (file)
@@ -3325,12 +3325,12 @@ gather_context_independent_values (class ipa_node_params *info,
 
   known_csts->create (0);
   known_contexts->create (0);
-  known_csts->safe_grow_cleared (count);
-  known_contexts->safe_grow_cleared (count);
+  known_csts->safe_grow_cleared (count, true);
+  known_contexts->safe_grow_cleared (count, true);
   if (known_aggs)
     {
       known_aggs->create (0);
-      known_aggs->safe_grow_cleared (count);
+      known_aggs->safe_grow_cleared (count, true);
     }
 
   if (removable_params_cost)
@@ -4823,7 +4823,8 @@ find_more_contexts_for_caller_subset (cgraph_node *node,
            }
 
          if (!known_contexts->exists ())
-           known_contexts->safe_grow_cleared (ipa_get_param_count (info));
+           known_contexts->safe_grow_cleared (ipa_get_param_count (info),
+                                              true);
          (*known_contexts)[i] = newval;
        }
 
index 3ab7049734ff0984291c2f8a673dd4395191d729..067ed5ba0731fc525dc21e4d90e2a656de7021a2 100644 (file)
@@ -2987,7 +2987,7 @@ final_warning_record::grow_type_warnings (unsigned newlen)
   unsigned len = type_warnings.length ();
   if (newlen > len)
     {
-      type_warnings.safe_grow_cleared (newlen);
+      type_warnings.safe_grow_cleared (newlen, true);
       for (unsigned i = len; i < newlen; i++)
        type_warnings[i].dyn_count = profile_count::zero ();
     }
@@ -4146,7 +4146,7 @@ ipa_odr_read_section (struct lto_file_decl_data *file_data, const char *data,
       /* If this is first time we see the enum, remember its definition.  */
       if (!existed_p)
        {
-         this_enum.vals.safe_grow_cleared (nvals);
+         this_enum.vals.safe_grow_cleared (nvals, true);
          this_enum.warned = false;
          if (dump_file)
            fprintf (dump_file, "enum %s\n{\n", name);
index 2cfab40156e516e3d45910ff6cea5526f9f17194..86d01addb4498d31dc217c971fe28f8e363f7805 100644 (file)
@@ -609,13 +609,13 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
                  {
                    gcc_checking_assert (TREE_CODE (cst) != TREE_BINFO);
                    if (!known_vals_ptr->length ())
-                     vec_safe_grow_cleared (known_vals_ptr, count);
+                     vec_safe_grow_cleared (known_vals_ptr, count, true);
                    (*known_vals_ptr)[i] = cst;
                  }
                else if (inline_p && !es->param[i].change_prob)
                  {
                    if (!known_vals_ptr->length ())
-                     vec_safe_grow_cleared (known_vals_ptr, count);
+                     vec_safe_grow_cleared (known_vals_ptr, count, true);
                    (*known_vals_ptr)[i] = error_mark_node;
                  }
 
@@ -632,7 +632,7 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
                      {
                        if (!known_value_ranges.length ())
                          {
-                           known_value_ranges.safe_grow (count);
+                           known_value_ranges.safe_grow (count, true);
                            for (int i = 0; i < count; ++i)
                              new (&known_value_ranges[i]) value_range ();
                          }
@@ -649,7 +649,7 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
                    if (agg.items.length ())
                      {
                        if (!known_aggs_ptr->length ())
-                         vec_safe_grow_cleared (known_aggs_ptr, count);
+                         vec_safe_grow_cleared (known_aggs_ptr, count, true);
                        (*known_aggs_ptr)[i] = agg;
                      }
                  }
@@ -665,7 +665,7 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
                if (!ctx.useless_p ())
                  {
                    if (!known_contexts_ptr->length ())
-                     known_contexts_ptr->safe_grow_cleared (count);
+                     known_contexts_ptr->safe_grow_cleared (count, true);
                    (*known_contexts_ptr)[i]
                      = ipa_context_from_jfunc (caller_parms_info, e, i, jf);
                  }
@@ -686,7 +686,7 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
          if (cst)
            {
              if (!known_vals_ptr->length ())
-               vec_safe_grow_cleared (known_vals_ptr, count);
+               vec_safe_grow_cleared (known_vals_ptr, count, true);
              (*known_vals_ptr)[i] = cst;
            }
        }
@@ -792,7 +792,7 @@ ipa_fn_summary_t::duplicate (cgraph_node *src,
       struct cgraph_edge *edge, *next;
 
       info->size_time_table = 0;
-      known_vals.safe_grow_cleared (count);
+      known_vals.safe_grow_cleared (count, true);
       for (i = 0; i < count; i++)
        {
          struct ipa_replace_map *r;
@@ -2485,12 +2485,12 @@ analyze_function_body (struct cgraph_node *node, bool early)
          fbi.node = node;
          fbi.info = IPA_NODE_REF (node);
          fbi.bb_infos = vNULL;
-         fbi.bb_infos.safe_grow_cleared (last_basic_block_for_fn (cfun));
+         fbi.bb_infos.safe_grow_cleared (last_basic_block_for_fn (cfun), true);
          fbi.param_count = count_formal_params (node->decl);
          fbi.aa_walk_budget = opt_for_fn (node->decl, param_ipa_max_aa_steps);
 
          nonconstant_names.safe_grow_cleared
-           (SSANAMES (my_function)->length ());
+           (SSANAMES (my_function)->length (), true);
        }
     }
 
@@ -2624,7 +2624,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
                  int i;
 
                  if (count)
-                   es->param.safe_grow_cleared (count);
+                   es->param.safe_grow_cleared (count, true);
                  for (i = 0; i < count; i++)
                    {
                      int prob = param_change_prob (&fbi, stmt, i);
@@ -3927,8 +3927,8 @@ ipa_merge_fn_summary_after_inlining (struct cgraph_edge *edge)
 
       if (count)
        {
-         operand_map.safe_grow_cleared (count);
-         offset_map.safe_grow_cleared (count);
+         operand_map.safe_grow_cleared (count, true);
+         offset_map.safe_grow_cleared (count, true);
        }
       for (i = 0; i < count; i++)
        {
@@ -4167,7 +4167,7 @@ read_ipa_call_summary (class lto_input_block *ib, struct cgraph_edge *e,
   length = streamer_read_uhwi (ib);
   if (length && es && e->possibly_call_in_translation_unit_p ())
     {
-      es->param.safe_grow_cleared (length);
+      es->param.safe_grow_cleared (length, true);
       for (i = 0; i < length; i++)
        es->param[i].change_prob = streamer_read_uhwi (ib);
     }
index 069de9d82fb3e2c6385b54b412e9e81a6993ab1c..d2b4e78138926804e24b5e5ef0b59eefd56938c4 100644 (file)
@@ -1586,7 +1586,7 @@ sem_function::bb_dict_test (vec<int> *bb_dict, int source, int target)
   target++;
 
   if (bb_dict->length () <= (unsigned)source)
-    bb_dict->safe_grow_cleared (source + 1);
+    bb_dict->safe_grow_cleared (source + 1, true);
 
   if ((*bb_dict)[source] == 0)
     {
index da50f0837fd73c7df3e729a34767280928e0ba1c..b28c78eeab422764903e7bb685b5840760afce16 100644 (file)
@@ -276,7 +276,7 @@ ipa_alloc_node_params (struct cgraph_node *node, int param_count)
 
   if (!info->descriptors && param_count)
     {
-      vec_safe_grow_cleared (info->descriptors, param_count);
+      vec_safe_grow_cleared (info->descriptors, param_count, true);
       return true;
     }
   else
@@ -906,7 +906,7 @@ parm_bb_aa_status_for_bb (struct ipa_func_body_info *fbi, basic_block bb,
   gcc_checking_assert (fbi);
   struct ipa_bb_info *bi = ipa_get_bb_info (fbi, bb);
   if (bi->param_aa_statuses.is_empty ())
-    bi->param_aa_statuses.safe_grow_cleared (fbi->param_count);
+    bi->param_aa_statuses.safe_grow_cleared (fbi->param_count, true);
   struct ipa_param_aa_status *paa = &bi->param_aa_statuses[index];
   if (!paa->valid)
     {
@@ -2113,9 +2113,9 @@ ipa_compute_jump_functions_for_edge (struct ipa_func_body_info *fbi,
 
   if (arg_num == 0 || args->jump_functions)
     return;
-  vec_safe_grow_cleared (args->jump_functions, arg_num);
+  vec_safe_grow_cleared (args->jump_functions, arg_num, true);
   if (flag_devirtualize)
-    vec_safe_grow_cleared (args->polymorphic_call_contexts, arg_num);
+    vec_safe_grow_cleared (args->polymorphic_call_contexts, arg_num, true);
 
   if (gimple_call_internal_p (call))
     return;
@@ -2877,7 +2877,7 @@ ipa_analyze_node (struct cgraph_node *node)
   fbi.node = node;
   fbi.info = IPA_NODE_REF (node);
   fbi.bb_infos = vNULL;
-  fbi.bb_infos.safe_grow_cleared (last_basic_block_for_fn (cfun));
+  fbi.bb_infos.safe_grow_cleared (last_basic_block_for_fn (cfun), true);
   fbi.param_count = ipa_get_param_count (info);
   fbi.aa_walk_budget = opt_for_fn (node->decl, param_ipa_max_aa_steps);
 
@@ -3024,7 +3024,7 @@ update_jump_functions_after_inlining (struct cgraph_edge *cs,
                  if (!dst_ctx)
                    {
                      vec_safe_grow_cleared (args->polymorphic_call_contexts,
-                                            count);
+                                            count, true);
                      dst_ctx = ipa_get_ith_polymorhic_call_context (args, i);
                    }
 
@@ -3095,7 +3095,7 @@ update_jump_functions_after_inlining (struct cgraph_edge *cs,
                      if (!dst_ctx)
                        {
                          vec_safe_grow_cleared (args->polymorphic_call_contexts,
-                                                count);
+                                                count, true);
                          dst_ctx = ipa_get_ith_polymorhic_call_context (args, i);
                        }
                      dst_ctx->combine_with (ctx);
@@ -4900,9 +4900,9 @@ ipa_read_edge_info (class lto_input_block *ib,
   if (prevails && e->possibly_call_in_translation_unit_p ())
     {
       class ipa_edge_args *args = IPA_EDGE_REF_GET_CREATE (e);
-      vec_safe_grow_cleared (args->jump_functions, count);
+      vec_safe_grow_cleared (args->jump_functions, count, true);
       if (contexts_computed)
-       vec_safe_grow_cleared (args->polymorphic_call_contexts, count);
+       vec_safe_grow_cleared (args->polymorphic_call_contexts, count, true);
       for (int k = 0; k < count; k++)
        {
          ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), e,
@@ -5197,7 +5197,7 @@ read_ipcp_transformation_info (lto_input_block *ib, cgraph_node *node,
     {
       ipcp_transformation_initialize ();
       ipcp_transformation *ts = ipcp_transformation_sum->get_create (node);
-      vec_safe_grow_cleared (ts->m_vr, count);
+      vec_safe_grow_cleared (ts->m_vr, count, true);
       for (i = 0; i < count; i++)
        {
          ipa_vr *parm_vr;
@@ -5219,7 +5219,7 @@ read_ipcp_transformation_info (lto_input_block *ib, cgraph_node *node,
     {
       ipcp_transformation_initialize ();
       ipcp_transformation *ts = ipcp_transformation_sum->get_create (node);
-      vec_safe_grow_cleared (ts->bits, count);
+      vec_safe_grow_cleared (ts->bits, count, true);
 
       for (i = 0; i < count; i++)
        {
@@ -5754,11 +5754,11 @@ ipcp_transform_function (struct cgraph_node *node)
   fbi.node = node;
   fbi.info = NULL;
   fbi.bb_infos = vNULL;
-  fbi.bb_infos.safe_grow_cleared (last_basic_block_for_fn (cfun));
+  fbi.bb_infos.safe_grow_cleared (last_basic_block_for_fn (cfun), true);
   fbi.param_count = param_count;
   fbi.aa_walk_budget = opt_for_fn (node->decl, param_ipa_max_aa_steps);
 
-  vec_safe_grow_cleared (descriptors, param_count);
+  vec_safe_grow_cleared (descriptors, param_count, true);
   ipa_populate_param_decls (node, *descriptors);
   calculate_dominance_info (CDI_DOMINATORS);
   ipcp_modif_dom_walker (&fbi, descriptors, aggval, &something_changed,
index c9bc1485a0ce769579948cb479ac051ec00c5db3..4a6c011c525eceb1e096618ff169a1b8ed95467d 100644 (file)
@@ -1057,7 +1057,7 @@ ipa_reference_write_optimization_summary (void)
   int i;
 
   vec_alloc (reference_vars_to_consider, ipa_reference_vars_uids);
-  reference_vars_to_consider->safe_grow (ipa_reference_vars_uids);
+  reference_vars_to_consider->safe_grow (ipa_reference_vars_uids, true);
 
   /* See what variables we are interested in.  */
   for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
index 973e72cea045635f67ada97776c9c7b7a227ada4..0a620247738a6334272521aff59cf6d8b8b2c11d 100644 (file)
@@ -1802,7 +1802,7 @@ execute_split_functions (void)
   calculate_dominance_info (CDI_DOMINATORS);
 
   /* Compute local info about basic blocks and determine function size/time.  */
-  bb_info_vec.safe_grow_cleared (last_basic_block_for_fn (cfun) + 1);
+  bb_info_vec.safe_grow_cleared (last_basic_block_for_fn (cfun) + 1, true);
   best_split_point.split_bbs = NULL;
   basic_block return_bb = find_return_bb ();
   int tsan_exit_found = -1;
index b748a6de3c29d1ce7614d7abeb8a6eb7e6a02933..a759f3c2aa875e0fa9316028fe67467fc7e380e3 100644 (file)
--- a/gcc/ira.c
+++ b/gcc/ira.c
@@ -4564,7 +4564,7 @@ find_moveable_pseudos (void)
 
   first_moveable_pseudo = max_regs;
   pseudo_replaced_reg.release ();
-  pseudo_replaced_reg.safe_grow_cleared (max_regs);
+  pseudo_replaced_reg.safe_grow_cleared (max_regs, true);
 
   df_analyze ();
   calculate_dominance_info (CDI_DOMINATORS);
index abe7180c686f9de5a2b2d8e57c3568c0a4daa192..82bb90ae3917d0f0919ece0ad03721f507c14447 100644 (file)
@@ -1526,7 +1526,7 @@ decompose_multiword_subregs (bool decompose_copies)
   subreg_context = BITMAP_ALLOC (NULL);
 
   reg_copy_graph.create (max);
-  reg_copy_graph.safe_grow_cleared (max);
+  reg_copy_graph.safe_grow_cleared (max, true);
   memset (reg_copy_graph.address (), 0, sizeof (bitmap) * max);
 
   speed_p = optimize_function_for_speed_p (cfun);
index 15bfb6141639381f1a99f62bc245921153004016..e02d69cc196f809f67d16ede42dc3058a933d9b3 100644 (file)
@@ -610,7 +610,7 @@ input_eh_regions (class lto_input_block *ib, class data_in *data_in,
   gcc_assert (len == (int) len);
   if (len > 0)
     {
-      vec_safe_grow_cleared (fn->eh->region_array, len);
+      vec_safe_grow_cleared (fn->eh->region_array, len, true);
       for (i = 0; i < len; i++)
        {
          eh_region r = input_eh_region (ib, data_in, i);
@@ -623,7 +623,7 @@ input_eh_regions (class lto_input_block *ib, class data_in *data_in,
   gcc_assert (len == (int) len);
   if (len > 0)
     {
-      vec_safe_grow_cleared (fn->eh->lp_array, len);
+      vec_safe_grow_cleared (fn->eh->lp_array, len, true);
       for (i = 0; i < len; i++)
        {
          eh_landing_pad lp = input_eh_lp (ib, data_in, i);
@@ -636,7 +636,7 @@ input_eh_regions (class lto_input_block *ib, class data_in *data_in,
   gcc_assert (len == (int) len);
   if (len > 0)
     {
-      vec_safe_grow_cleared (fn->eh->ttype_data, len);
+      vec_safe_grow_cleared (fn->eh->ttype_data, len, true);
       for (i = 0; i < len; i++)
        {
          tree ttype = stream_read_tree (ib, data_in);
@@ -651,7 +651,7 @@ input_eh_regions (class lto_input_block *ib, class data_in *data_in,
     {
       if (targetm.arm_eabi_unwinder)
        {
-         vec_safe_grow_cleared (fn->eh->ehspec_data.arm_eabi, len);
+         vec_safe_grow_cleared (fn->eh->ehspec_data.arm_eabi, len, true);
          for (i = 0; i < len; i++)
            {
              tree t = stream_read_tree (ib, data_in);
@@ -660,7 +660,7 @@ input_eh_regions (class lto_input_block *ib, class data_in *data_in,
        }
       else
        {
-         vec_safe_grow_cleared (fn->eh->ehspec_data.other, len);
+         vec_safe_grow_cleared (fn->eh->ehspec_data.other, len, true);
          for (i = 0; i < len; i++)
            {
              uchar c = streamer_read_uchar (ib);
@@ -712,10 +712,10 @@ input_cfg (class lto_input_block *ib, class data_in *data_in,
 
   last_basic_block_for_fn (fn) = bb_count;
   if (bb_count > basic_block_info_for_fn (fn)->length ())
-    vec_safe_grow_cleared (basic_block_info_for_fn (fn), bb_count);
+    vec_safe_grow_cleared (basic_block_info_for_fn (fn), bb_count, true);
 
   if (bb_count > label_to_block_map_for_fn (fn)->length ())
-    vec_safe_grow_cleared (label_to_block_map_for_fn (fn), bb_count);
+    vec_safe_grow_cleared (label_to_block_map_for_fn (fn), bb_count, true);
 
   index = streamer_read_hwi (ib);
   while (index != -1)
@@ -963,7 +963,7 @@ input_struct_function_base (struct function *fn, class data_in *data_in,
   if (len > 0)
     {
       int i;
-      vec_safe_grow_cleared (fn->local_decls, len);
+      vec_safe_grow_cleared (fn->local_decls, len, true);
       for (i = 0; i < len; i++)
        {
          tree t = stream_read_tree (ib, data_in);
@@ -1058,7 +1058,7 @@ input_function (tree fn_decl, class data_in *data_in,
   if (n_debugargs)
     {
       vec<tree, va_gc> **debugargs = decl_debug_args_insert (fn_decl);
-      vec_safe_grow (*debugargs, n_debugargs);
+      vec_safe_grow (*debugargs, n_debugargs, true);
       for (unsigned i = 0; i < n_debugargs; ++i)
        (**debugargs)[i] = stream_read_tree (ib, data_in);
     }
index 86d8851dac74e6e444bbe2cd0a41a4153c4e6da1..3ca0fd83a41d2ae55adc5108d648b72d1e948c45 100644 (file)
@@ -2227,7 +2227,7 @@ lto_file_finalize (struct lto_file_decl_data *file_data, lto_file *file,
 
   /* Create vector for fast access of resolution.  We do this lazily
      to save memory.  */
-  resolutions.safe_grow_cleared (file_data->max_index + 1);
+  resolutions.safe_grow_cleared (file_data->max_index + 1, true);
   for (i = 0; file_data->respairs.iterate (i, &rp); i++)
     resolutions[rp->index] = rp->res;
   file_data->respairs.release ();
index 77254b31b422099b8e852ab8a3706092f0e1f0ed..86701e0555048ae016af89f5a0294edd9de4bed6 100644 (file)
@@ -440,7 +440,7 @@ static void
 set_node_sched_params (ddg_ptr g)
 {
   node_sched_param_vec.truncate (0);
-  node_sched_param_vec.safe_grow_cleared (g->num_nodes);
+  node_sched_param_vec.safe_grow_cleared (g->num_nodes, true);
 }
 
 /* Make sure that node_sched_param_vec has an entry for every move in PS.  */
@@ -448,7 +448,7 @@ static void
 extend_node_sched_params (partial_schedule_ptr ps)
 {
   node_sched_param_vec.safe_grow_cleared (ps->g->num_nodes
-                                         + ps->reg_moves.length ());
+                                         + ps->reg_moves.length (), true);
 }
 
 /* Update the sched_params (time, row and stage) for node U using the II,
@@ -735,7 +735,7 @@ schedule_reg_moves (partial_schedule_ptr ps)
 
       /* Create NREG_MOVES register moves.  */
       first_move = ps->reg_moves.length ();
-      ps->reg_moves.safe_grow_cleared (first_move + nreg_moves);
+      ps->reg_moves.safe_grow_cleared (first_move + nreg_moves, true);
       extend_node_sched_params (ps);
 
       /* Record the moves associated with this node.  */
index 8e2665ab3a368d4887db11aa5506f16a25ffbe5e..b70e3e31352c06b8a9fa5690c7132ea2e7cc21c9 100644 (file)
@@ -1491,7 +1491,7 @@ omp_construct_simd_compare (tree clauses1, tree clauses2)
          }
        unsigned HOST_WIDE_INT argno = tree_to_uhwi (OMP_CLAUSE_DECL (c));
        if (argno >= v->length ())
-         v->safe_grow_cleared (argno + 1);
+         v->safe_grow_cleared (argno + 1, true);
        (*v)[argno] = c;
       }
   /* Here, r is used as a bitmask, 2 is set if CLAUSES1 has something
index a5da9a46f4e9d165707e68ea5227602c1dbe3012..6ff31ec37d7fd9f21bfa49a3102c112cebd0cbe0 100644 (file)
@@ -892,7 +892,7 @@ pass_manager::create_pass_tab (void) const
   if (!flag_dump_passes)
     return;
 
-  pass_tab.safe_grow_cleared (passes_by_id_size + 1);
+  pass_tab.safe_grow_cleared (passes_by_id_size + 1, true);
   m_name_to_pass_map->traverse <void *, passes_pass_traverse> (NULL);
 }
 
@@ -1046,7 +1046,7 @@ enable_disable_pass (const char *arg, bool is_enable)
     tab = &disabled_pass_uid_range_tab;
 
   if ((unsigned) pass->static_pass_number >= tab->length ())
-    tab->safe_grow_cleared (pass->static_pass_number + 1);
+    tab->safe_grow_cleared (pass->static_pass_number + 1, true);
 
   if (!range_str)
     {
index 4c4bba549398523f86b26684e068c130322db29b..3c7b46f4c747deb5b2a2eddae062a8f331fb8edf 100644 (file)
@@ -3764,7 +3764,7 @@ determine_unlikely_bbs ()
   propagate_unlikely_bbs_forward ();
 
   auto_vec<int, 64> nsuccs;
-  nsuccs.safe_grow_cleared (last_basic_block_for_fn (cfun));
+  nsuccs.safe_grow_cleared (last_basic_block_for_fn (cfun), true);
   FOR_ALL_BB_FN (bb, cfun)
     if (!(bb->count == profile_count::zero ())
        && bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
index bd1eac123dfb1f9f02ae69e144d81db17c750c94..f5c206813c7edf74984fd09f2edc3f43859164b3 100644 (file)
@@ -412,7 +412,7 @@ compute_branch_probabilities (unsigned cfg_checksum, unsigned lineno_checksum)
       return;
     }
 
-  bb_gcov_counts.safe_grow_cleared (last_basic_block_for_fn (cfun));
+  bb_gcov_counts.safe_grow_cleared (last_basic_block_for_fn (cfun), true);
   edge_gcov_counts = new hash_map<edge,gcov_type>;
 
   /* Attach extra info block to each bb.  */
index 3379d6453db2e22a379a8a6113ca0b46f8ebe123..5ff51571f1544b350dbe225b94c89c292f72d2cf 100644 (file)
@@ -632,7 +632,7 @@ function_reader::parse_block ()
 
   size_t new_size = m_highest_bb_idx + 1;
   if (basic_block_info_for_fn (cfun)->length () < new_size)
-    vec_safe_grow_cleared (basic_block_info_for_fn (cfun), new_size);
+    vec_safe_grow_cleared (basic_block_info_for_fn (cfun), new_size, true);
 
   last_basic_block_for_fn (cfun) = new_size;
 
index d5f2b11b4af30203be765325b5c91ea1c4da8318..3ec83a60baf4f61c5e9f149f368c0228b7aeaeb9 100644 (file)
@@ -1627,7 +1627,7 @@ rtx_reader::read_rtx_code (const char *code_name)
   if (reuse_id != -1)
     {
       /* Store away for later reuse.  */
-      m_reuse_rtx_by_id.safe_grow_cleared (reuse_id + 1);
+      m_reuse_rtx_by_id.safe_grow_cleared (reuse_id + 1, true);
       m_reuse_rtx_by_id[reuse_id] = return_rtx;
     }
 
index 3aac3c148170ce8be6b5c491e2d488a4c08bed8e..8f98bd857501143160380a2e615d0f965a5ef0b3 100644 (file)
@@ -318,7 +318,7 @@ stack_regs_mentioned (const_rtx insn)
       /* Allocate some extra size to avoid too many reallocs, but
         do not grow too quickly.  */
       max = uid + uid / 20 + 1;
-      stack_regs_mentioned_data.safe_grow_cleared (max);
+      stack_regs_mentioned_data.safe_grow_cleared (max, true);
     }
 
   test = stack_regs_mentioned_data[uid];
index ebe74c50d0a743a21e15455214ba42e65558da2a..2a0e892e5fdae7cfb90384f6e6d272148d583dbe 100644 (file)
@@ -1948,7 +1948,7 @@ regrename_init (bool insn_info)
   gcc_obstack_init (&rename_obstack);
   insn_rr.create (0);
   if (insn_info)
-    insn_rr.safe_grow_cleared (get_max_uid ());
+    insn_rr.safe_grow_cleared (get_max_uid (), true);
 }
 
 /* Free all global data used by the register renamer.  */
index 1d2874d867272b878a3bdf39e2b909f84ad73329..5ae38b7966d9ed47f0e6bfb41853ebf81453b0de 100644 (file)
@@ -97,7 +97,7 @@ generic_subrtx_iterator <T>::add_single_to_queue (array_type &array,
       /* A previous iteration might also have moved from the stack to the
         heap, in which case the heap array will already be big enough.  */
       if (vec_safe_length (array.heap) <= i)
-       vec_safe_grow (array.heap, i + 1);
+       vec_safe_grow (array.heap, i + 1, true);
       base = array.heap->address ();
       memcpy (base, array.stack, sizeof (array.stack));
       base[LOCAL_ELEMS] = x;
index 1bc75074e5d8c83c3b695f568df10d9cf6d07704..d8b5c53c6a40e5ec495f847b3cdadd79b216b8f0 100644 (file)
@@ -4072,7 +4072,7 @@ init_deps_data_vector (void)
 {
   int reserve = (sched_max_luid + 1 - h_d_i_d.length ());
   if (reserve > 0 && ! h_d_i_d.space (reserve))
-    h_d_i_d.safe_grow_cleared (3 * sched_max_luid / 2);
+    h_d_i_d.safe_grow_cleared (3 * sched_max_luid / 2, true);
 }
 
 /* If it is profitable to use them, initialize or extend (depending on
index 4f1e4afdc4ccebc78786fef9d39ef4d1e1bd2181..f58628ae92d90a0206a15795ad801c0acb4e94e6 100644 (file)
@@ -4152,14 +4152,14 @@ get_seqno_by_preds (rtx_insn *insn)
 void
 sel_extend_global_bb_info (void)
 {
-  sel_global_bb_info.safe_grow_cleared (last_basic_block_for_fn (cfun));
+  sel_global_bb_info.safe_grow_cleared (last_basic_block_for_fn (cfun), true);
 }
 
 /* Extend region-scope data structures for basic blocks.  */
 static void
 extend_region_bb_info (void)
 {
-  sel_region_bb_info.safe_grow_cleared (last_basic_block_for_fn (cfun));
+  sel_region_bb_info.safe_grow_cleared (last_basic_block_for_fn (cfun), true);
 }
 
 /* Extend all data structures to fit for all basic blocks.  */
@@ -4209,7 +4209,7 @@ extend_insn_data (void)
         size = 3 * sched_max_luid / 2;
 
 
-      s_i_d.safe_grow_cleared (size);
+      s_i_d.safe_grow_cleared (size, true);
     }
 }
 
index d7dfbb676df23c301d7b01815023c47fa15b7397..207c9e75890c0e39df94aedb4de26eba0803bfae 100644 (file)
@@ -592,7 +592,8 @@ symtab_node::create_reference (symtab_node *referred_node,
 
   list = &ref_list;
   old_references = vec_safe_address (list->references);
-  vec_safe_grow (list->references, vec_safe_length (list->references) + 1);
+  vec_safe_grow (list->references, vec_safe_length (list->references) + 1,
+                true);
   ref = &list->references->last ();
 
   list2 = &referred_node->ref_list;
index 7395dd5c9398decccfd530f30fcd92a74632d4f7..82ede7225343e4de2e87dc1f0b42600214108ef6 100644 (file)
@@ -257,7 +257,7 @@ static bool
 tail_duplicate (void)
 {
   auto_vec<fibonacci_node<long, basic_block_def>*> blocks;
-  blocks.safe_grow_cleared (last_basic_block_for_fn (cfun));
+  blocks.safe_grow_cleared (last_basic_block_for_fn (cfun), true);
 
   basic_block *trace = XNEWVEC (basic_block, n_basic_blocks_for_fn (cfun));
   int *counts = XNEWVEC (int, last_basic_block_for_fn (cfun));
index b6b9157006b53926bda25f3bc0841ac2bce161ca..e466b24400d090786488df1c734c95ae666d3830 100644 (file)
@@ -2030,7 +2030,7 @@ tm_region_init (struct tm_region *region)
   /* We could store this information in bb->aux, but we may get called
      through get_all_tm_blocks() from another pass that may be already
      using bb->aux.  */
-  bb_regions.safe_grow_cleared (last_basic_block_for_fn (cfun));
+  bb_regions.safe_grow_cleared (last_basic_block_for_fn (cfun), true);
 
   all_tm_regions = region;
   bb = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
@@ -2774,7 +2774,7 @@ get_bb_regions_instrumented (bool traverse_clones,
   vec<tm_region *> ret;
 
   ret.create (n);
-  ret.safe_grow_cleared (n);
+  ret.safe_grow_cleared (n, true);
   stuff.bb2reg = &ret;
   stuff.include_uninstrumented_p = include_uninstrumented_p;
   expand_regions (all_tm_regions, collect_bb2reg, &stuff, traverse_clones);
index b4d0c6db238146bc9a1ebd3e39ccfdaa7097a38a..2bae2eeddba34a8447bff299584f36f97898424b 100644 (file)
@@ -183,12 +183,12 @@ init_empty_tree_cfg_for_function (struct function *fn)
   last_basic_block_for_fn (fn) = NUM_FIXED_BLOCKS;
   vec_alloc (basic_block_info_for_fn (fn), initial_cfg_capacity);
   vec_safe_grow_cleared (basic_block_info_for_fn (fn),
-                        initial_cfg_capacity);
+                        initial_cfg_capacity, true);
 
   /* Build a mapping of labels to their associated blocks.  */
   vec_alloc (label_to_block_map_for_fn (fn), initial_cfg_capacity);
   vec_safe_grow_cleared (label_to_block_map_for_fn (fn),
-                        initial_cfg_capacity);
+                        initial_cfg_capacity, true);
 
   SET_BASIC_BLOCK_FOR_FN (fn, ENTRY_BLOCK, ENTRY_BLOCK_PTR_FOR_FN (fn));
   SET_BASIC_BLOCK_FOR_FN (fn, EXIT_BLOCK, EXIT_BLOCK_PTR_FOR_FN (fn));
@@ -232,7 +232,7 @@ build_gimple_cfg (gimple_seq seq)
   if (basic_block_info_for_fn (cfun)->length ()
       < (size_t) n_basic_blocks_for_fn (cfun))
     vec_safe_grow_cleared (basic_block_info_for_fn (cfun),
-                          n_basic_blocks_for_fn (cfun));
+                          n_basic_blocks_for_fn (cfun), true);
 
   /* To speed up statement iterator walks, we first purge dead labels.  */
   cleanup_dead_labels ();
@@ -685,7 +685,7 @@ create_bb (void *h, void *e, basic_block after)
       size_t new_size =
        (last_basic_block_for_fn (cfun)
         + (last_basic_block_for_fn (cfun) + 3) / 4);
-      vec_safe_grow_cleared (basic_block_info_for_fn (cfun), new_size);
+      vec_safe_grow_cleared (basic_block_info_for_fn (cfun), new_size, true);
     }
 
   /* Add the newly created block to the array.  */
@@ -7135,7 +7135,7 @@ move_block_to_fn (struct function *dest_cfun, basic_block bb,
   if ((unsigned) cfg->x_last_basic_block >= old_len)
     {
       new_len = cfg->x_last_basic_block + (cfg->x_last_basic_block + 3) / 4;
-      vec_safe_grow_cleared (cfg->x_basic_block_info, new_len);
+      vec_safe_grow_cleared (cfg->x_basic_block_info, new_len, true);
     }
 
   (*cfg->x_basic_block_info)[bb->index] = bb;
@@ -7211,7 +7211,7 @@ move_block_to_fn (struct function *dest_cfun, basic_block bb,
          if (old_len <= (unsigned) uid)
            {
              new_len = 3 * uid / 2 + 1;
-             vec_safe_grow_cleared (cfg->x_label_to_block_map, new_len);
+             vec_safe_grow_cleared (cfg->x_label_to_block_map, new_len, true);
            }
 
          (*cfg->x_label_to_block_map)[uid] = bb;
index c5febcea3eb1c123db491ff53729239e98e20bb8..2e54bbb917c643b9d8ffda9fea0d8b9723fbd801 100644 (file)
@@ -1776,7 +1776,7 @@ tree_lower_complex (void)
     return 0;
 
   complex_lattice_values.create (num_ssa_names);
-  complex_lattice_values.safe_grow_cleared (num_ssa_names);
+  complex_lattice_values.safe_grow_cleared (num_ssa_names, true);
 
   init_parameter_lattice_values ();
   class complex_propagate complex_propagate;
@@ -1787,7 +1787,7 @@ tree_lower_complex (void)
   complex_variable_components = new int_tree_htab_type (10);
 
   complex_ssa_name_components.create (2 * num_ssa_names);
-  complex_ssa_name_components.safe_grow_cleared (2 * num_ssa_names);
+  complex_ssa_name_components.safe_grow_cleared (2 * num_ssa_names, true);
 
   update_parameter_components ();
 
index 257759d01bfa8e45a20545de267b1e6c8afe5615..4b8d457867edb53ebed7646842748ec59645caee 100644 (file)
@@ -2222,7 +2222,7 @@ predicate_rhs_code (gassign *stmt, tree mask, tree cond,
 
   /* Construct the arguments to the conditional internal function.   */
   auto_vec<tree, 8> args;
-  args.safe_grow (nops + 1);
+  args.safe_grow (nops + 1, true);
   args[0] = mask;
   for (unsigned int i = 1; i < nops; ++i)
     args[i] = gimple_op (stmt, i);
index 3160ca3f88a4b7bf18be8a2f47147aadaffd77a5..0d33ee72c0f3e4d3825d19af0dfcdc081dc64851 100644 (file)
@@ -2099,7 +2099,7 @@ copy_bb (copy_body_data *id, basic_block bb,
              /* Create the new array of arguments.  */
              n = nargs + gimple_call_num_args (call_stmt);
              argarray.create (n);
-             argarray.safe_grow_cleared (n);
+             argarray.safe_grow_cleared (n, true);
 
              /* Copy all the arguments before '...'  */
              memcpy (argarray.address (),
index c24931effac557712b658821309dfece5bdf787c..0d01613477404ca8ee644be239da92f0fee4aa3d 100644 (file)
@@ -323,7 +323,7 @@ get_ssa_name_ann (tree name)
 
   /* Re-allocate the vector at most once per update/into-SSA.  */
   if (ver >= len)
-    info_for_ssa_name.safe_grow_cleared (num_ssa_names);
+    info_for_ssa_name.safe_grow_cleared (num_ssa_names, true);
 
   /* But allocate infos lazily.  */
   info = info_for_ssa_name[ver];
@@ -944,7 +944,7 @@ mark_phi_for_rewrite (basic_block bb, gphi *phi)
     {
       n = (unsigned) last_basic_block_for_fn (cfun) + 1;
       if (phis_to_rewrite.length () < n)
-       phis_to_rewrite.safe_grow_cleared (n);
+       phis_to_rewrite.safe_grow_cleared (n, true);
 
       phis = phis_to_rewrite[idx];
       gcc_assert (!phis.exists ());
index bc55b27cff08ea3b5bccbb5b0e500762e76f2695..c107cb4a86619e3f9cf9eac5e9182e4d244b2b02 100644 (file)
@@ -612,7 +612,7 @@ compute_builtin_object_size (tree ptr, int object_size_type,
       unsigned int i;
 
       if (num_ssa_names > object_sizes[object_size_type].length ())
-       object_sizes[object_size_type].safe_grow (num_ssa_names);
+       object_sizes[object_size_type].safe_grow (num_ssa_names, true);
       if (dump_file)
        {
          fprintf (dump_file, "Computing %s %sobject size for ",
@@ -1282,7 +1282,7 @@ init_object_sizes (void)
 
   for (object_size_type = 0; object_size_type <= 3; object_size_type++)
     {
-      object_sizes[object_size_type].safe_grow (num_ssa_names);
+      object_sizes[object_size_type].safe_grow (num_ssa_names, true);
       computed[object_size_type] = BITMAP_ALLOC (NULL);
     }
 
index d2dcfe7f42d3e65e4da24db2be4721271b1f7377..b1d6e63559c732d2f518ff6ef008cf3ebb11c1b2 100644 (file)
@@ -1783,7 +1783,7 @@ initialize_root_vars_store_elim_1 (chain_p chain)
   unsigned i, n = chain->length;
 
   chain->vars.create (n);
-  chain->vars.safe_grow_cleared (n);
+  chain->vars.safe_grow_cleared (n, true);
 
   /* Initialize root value for eliminated stores at each distance.  */
   for (i = 0; i < n; i++)
@@ -1843,7 +1843,7 @@ initialize_root_vars_store_elim_2 (class loop *loop,
   /* Root values are either rhs operand of stores to be eliminated, or
      loaded from memory before loop.  */
   auto_vec<tree> vtemps;
-  vtemps.safe_grow_cleared (n);
+  vtemps.safe_grow_cleared (n, true);
   for (i = 0; i < n; i++)
     {
       init = get_init_expr (chain, i);
@@ -2953,7 +2953,7 @@ prepare_initializers_chain_store_elim (class loop *loop, chain_p chain)
     }
 
   chain->inits.create (n);
-  chain->inits.safe_grow_cleared (n);
+  chain->inits.safe_grow_cleared (n, true);
 
   /* For store eliminatin chain like below:
 
@@ -2971,7 +2971,7 @@ prepare_initializers_chain_store_elim (class loop *loop, chain_p chain)
      elements because loop body is guaranteed to be executed at least once
      after loop's preheader edge.  */
   auto_vec<bool> bubbles;
-  bubbles.safe_grow_cleared (n + 1);
+  bubbles.safe_grow_cleared (n + 1, true);
   for (i = 0; i < chain->refs.length (); i++)
     bubbles[chain->refs[i]->distance] = true;
 
index 21ad4e57e40f2d16ea978145b303389c2c0352b9..ec3741d759824679f40d7ca0be92b39e784d4764 100644 (file)
@@ -216,7 +216,7 @@ addr_for_mem_ref (struct mem_address *addr, addr_space_t as,
        = TEMPL_IDX (as, addr->symbol, addr->base, addr->index, st, off);
 
       if (templ_index >= vec_safe_length (mem_addr_template_list))
-       vec_safe_grow_cleared (mem_addr_template_list, templ_index + 1);
+       vec_safe_grow_cleared (mem_addr_template_list, templ_index + 1, true);
 
       /* Reuse the templates for addresses, so that we do not waste memory.  */
       templ = &(*mem_addr_template_list)[templ_index];
@@ -570,7 +570,7 @@ multiplier_allowed_in_address_p (HOST_WIDE_INT ratio, machine_mode mode,
   sbitmap valid_mult;
 
   if (data_index >= valid_mult_list.length ())
-    valid_mult_list.safe_grow_cleared (data_index + 1);
+    valid_mult_list.safe_grow_cleared (data_index + 1, true);
 
   valid_mult = valid_mult_list[data_index];
   if (!valid_mult)
index 0b0b1b18dc5defa1fbc06b29aa3d32f0d2eec9da..a0537fb3d359ef79d3124928cd8eb0941a024c2f 100644 (file)
@@ -541,7 +541,7 @@ ssa_conflicts_new (unsigned size)
   ptr = XNEW (ssa_conflicts);
   bitmap_obstack_initialize (&ptr->obstack);
   ptr->conflicts.create (size);
-  ptr->conflicts.safe_grow_cleared (size);
+  ptr->conflicts.safe_grow_cleared (size, true);
   return ptr;
 }
 
index a4aed3ccade8fb85af19c572887299b0dab50e2c..e2d008dfb92a8781ef0a9b4633981ef025587799 100644 (file)
@@ -2290,7 +2290,7 @@ simplify_vector_constructor (gimple_stmt_iterator *gsi)
   tree one_constant = NULL_TREE;
   tree one_nonconstant = NULL_TREE;
   auto_vec<tree> constants;
-  constants.safe_grow_cleared (nelts);
+  constants.safe_grow_cleared (nelts, true);
   auto_vec<std::pair<unsigned, unsigned>, 64> elts;
   FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (op), i, elt)
     {
index 45b31640e75b07a9a1b6e1c1b4a3bba2903e0889..5acf044161c07b9b799a2a650f14dc5ddd55264c 100644 (file)
@@ -2601,7 +2601,7 @@ addr_offset_valid_p (struct iv_use *use, poly_int64 offset)
 
   list_index = (unsigned) as * MAX_MACHINE_MODE + (unsigned) mem_mode;
   if (list_index >= vec_safe_length (addr_list))
-    vec_safe_grow_cleared (addr_list, list_index + MAX_MACHINE_MODE);
+    vec_safe_grow_cleared (addr_list, list_index + MAX_MACHINE_MODE, true);
 
   addr = (*addr_list)[list_index];
   if (!addr)
@@ -4569,7 +4569,7 @@ get_address_cost_ainc (poly_int64 ainc_step, poly_int64 ainc_offset,
       unsigned nsize = ((unsigned) as + 1) *MAX_MACHINE_MODE;
 
       gcc_assert (nsize > idx);
-      ainc_cost_data_list.safe_grow_cleared (nsize);
+      ainc_cost_data_list.safe_grow_cleared (nsize, true);
     }
 
   ainc_cost_data *data = ainc_cost_data_list[idx];
index 7d61ef080ebac88982d4567d90b43d0c3931f0d0..b3647d9efcac0b30a5d5b424fdc93095c27f73a9 100644 (file)
@@ -4002,7 +4002,7 @@ discover_iteration_bound_by_body_walk (class loop *loop)
 
   /* Start walk in loop header with index set to infinite bound.  */
   queue_index = bounds.length ();
-  queues.safe_grow_cleared (queue_index + 1);
+  queues.safe_grow_cleared (queue_index + 1, true);
   queue.safe_push (loop->header);
   queues[queue_index] = queue;
   block_priority.put (loop->header, queue_index);
index 0a94f4e3355c57cebf27156e1644733309153546..63f3a81e94c2056f8a548e580e8f99c5bb12511b 100644 (file)
@@ -626,7 +626,7 @@ add_to_value (unsigned int v, pre_expr e)
 
   if (v >= value_expressions.length ())
     {
-      value_expressions.safe_grow_cleared (v + 1);
+      value_expressions.safe_grow_cleared (v + 1, true);
     }
 
   set = value_expressions[v];
@@ -1451,7 +1451,8 @@ phi_translate_1 (bitmap_set_t dest,
            else
              {
                new_val_id = get_next_value_id ();
-               value_expressions.safe_grow_cleared (get_max_value_id () + 1);
+               value_expressions.safe_grow_cleared (get_max_value_id () + 1,
+                                                    true);
                nary = vn_nary_op_insert_pieces (newnary->length,
                                                 newnary->opcode,
                                                 newnary->type,
@@ -1605,7 +1606,7 @@ phi_translate_1 (bitmap_set_t dest,
                  {
                    new_val_id = get_next_value_id ();
                    value_expressions.safe_grow_cleared
-                     (get_max_value_id () + 1);
+                     (get_max_value_id () + 1, true);
                  }
                else
                  new_val_id = ref->value_id;
@@ -3193,7 +3194,7 @@ do_pre_regular_insertion (basic_block block, basic_block dom)
   int i;
 
   exprs = sorted_array_from_bitmap_set (ANTIC_IN (block));
-  avail.safe_grow (EDGE_COUNT (block->preds));
+  avail.safe_grow (EDGE_COUNT (block->preds), true);
 
   FOR_EACH_VEC_ELT (exprs, i, expr)
     {
@@ -3360,7 +3361,7 @@ do_pre_partial_partial_insertion (basic_block block, basic_block dom)
   int i;
 
   exprs = sorted_array_from_bitmap_set (PA_IN (block));
-  avail.safe_grow (EDGE_COUNT (block->preds));
+  avail.safe_grow (EDGE_COUNT (block->preds), true);
 
   FOR_EACH_VEC_ELT (exprs, i, expr)
     {
@@ -4099,7 +4100,7 @@ init_pre (void)
   expressions.create (0);
   expressions.safe_push (NULL);
   value_expressions.create (get_max_value_id () + 1);
-  value_expressions.safe_grow_cleared (get_max_value_id () + 1);
+  value_expressions.safe_grow_cleared (get_max_value_id () + 1, true);
   name_to_id.create (0);
 
   inserted_exprs = BITMAP_ALLOC (NULL);
index 1e05728415437d6ddb5e3189cb1fa2b1f4a2cbb4..5a30176d3b451b208242c5c3642c1bc53814f050 100644 (file)
@@ -420,7 +420,7 @@ ssa_prop_init (void)
       FOR_EACH_EDGE (e, ei, bb->succs)
        e->flags &= ~EDGE_EXECUTABLE;
     }
-  uid_to_stmt.safe_grow (gimple_stmt_max_uid (cfun));
+  uid_to_stmt.safe_grow (gimple_stmt_max_uid (cfun), true);
 }
 
 
@@ -671,7 +671,7 @@ update_call_from_tree (gimple_stmt_iterator *si_p, tree expr)
       if (nargs > 0)
         {
           args.create (nargs);
-          args.safe_grow_cleared (nargs);
+         args.safe_grow_cleared (nargs, true);
 
           for (i = 0; i < nargs; i++)
             args[i] = CALL_EXPR_ARG (expr, i);
index a5f5d52edab4287eed2fe561bafee91562bf4c33..facc794cdcc0861213bf92d8223f16e9734eee3e 100644 (file)
@@ -3365,9 +3365,9 @@ optimize_range_tests_cmp_bitwise (enum tree_code opcode, int first, int length,
 
       b = TYPE_PRECISION (TREE_TYPE (ranges[i].exp)) * 2 + !zero_p;
       if (buckets.length () <= b)
-       buckets.safe_grow_cleared (b + 1);
+       buckets.safe_grow_cleared (b + 1, true);
       if (chains.length () <= (unsigned) i)
-       chains.safe_grow (i + 1);
+       chains.safe_grow (i + 1, true);
       chains[i] = buckets[b];
       buckets[b] = i + 1;
     }
index 789d3664db5f460a7316a85d9364bbecd67826b0..c5f4a1e53a9a7e045e57a8f0911179899ec1e4e8 100644 (file)
@@ -3157,7 +3157,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
       /* We need to pre-pend vr->operands[0..i] to rhs.  */
       vec<vn_reference_op_s> old = vr->operands;
       if (i + 1 + rhs.length () > vr->operands.length ())
-       vr->operands.safe_grow (i + 1 + rhs.length ());
+       vr->operands.safe_grow (i + 1 + rhs.length (), true);
       else
        vr->operands.truncate (i + 1 + rhs.length ());
       FOR_EACH_VEC_ELT (rhs, j, vro)
@@ -3362,7 +3362,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
       if (vr->operands.length () < 2)
        {
          vec<vn_reference_op_s> old = vr->operands;
-         vr->operands.safe_grow_cleared (2);
+         vr->operands.safe_grow_cleared (2, true);
          if (old == shared_lookup_references)
            shared_lookup_references = vr->operands;
        }
@@ -3448,7 +3448,7 @@ vn_reference_lookup_pieces (tree vuse, alias_set_type set,
 
   vr1.vuse = vuse_ssa_val (vuse);
   shared_lookup_references.truncate (0);
-  shared_lookup_references.safe_grow (operands.length ());
+  shared_lookup_references.safe_grow (operands.length (), true);
   memcpy (shared_lookup_references.address (),
          operands.address (),
          sizeof (vn_reference_op_s)
@@ -5715,7 +5715,7 @@ eliminate_dom_walker::eliminate_push_avail (basic_block, tree op)
   if (TREE_CODE (valnum) == SSA_NAME)
     {
       if (avail.length () <= SSA_NAME_VERSION (valnum))
-       avail.safe_grow_cleared (SSA_NAME_VERSION (valnum) + 1);
+       avail.safe_grow_cleared (SSA_NAME_VERSION (valnum) + 1, true);
       tree pushop = op;
       if (avail[SSA_NAME_VERSION (valnum)])
        pushop = avail[SSA_NAME_VERSION (valnum)];
index 96962286735a3b4d001043a578ea9d5b0eb8ca8d..47f537ab210e7aed85df114941fc262c5c382712 100644 (file)
@@ -712,7 +712,7 @@ set_strinfo (int idx, strinfo *si)
   if (vec_safe_length (stridx_to_strinfo) && (*stridx_to_strinfo)[0])
     unshare_strinfo_vec ();
   if (vec_safe_length (stridx_to_strinfo) <= (unsigned int) idx)
-    vec_safe_grow_cleared (stridx_to_strinfo, idx + 1);
+    vec_safe_grow_cleared (stridx_to_strinfo, idx + 1, true);
   (*stridx_to_strinfo)[idx] = si;
 }
 
@@ -1365,7 +1365,7 @@ get_stridx_plus_constant (strinfo *basesi, unsigned HOST_WIDE_INT off,
 
   if (TREE_CODE (ptr) == SSA_NAME
       && ssa_ver_to_stridx.length () <= SSA_NAME_VERSION (ptr))
-    ssa_ver_to_stridx.safe_grow_cleared (num_ssa_names);
+    ssa_ver_to_stridx.safe_grow_cleared (num_ssa_names, true);
 
   gcc_checking_assert (compare_tree_int (si->nonzero_chars, off) != -1);
   for (chainsi = si; chainsi->next; chainsi = si)
@@ -1429,7 +1429,7 @@ zero_length_string (tree ptr, strinfo *chainsi)
   strinfo *si;
   int idx;
   if (ssa_ver_to_stridx.length () <= SSA_NAME_VERSION (ptr))
-    ssa_ver_to_stridx.safe_grow_cleared (num_ssa_names);
+    ssa_ver_to_stridx.safe_grow_cleared (num_ssa_names, true);
   gcc_checking_assert (TREE_CODE (ptr) == SSA_NAME
                       && ssa_ver_to_stridx[SSA_NAME_VERSION (ptr)] == 0);
 
@@ -1582,7 +1582,7 @@ find_equal_ptrs (tree ptr, int idx)
       /* We might find an endptr created in this pass.  Grow the
         vector in that case.  */
       if (ssa_ver_to_stridx.length () <= SSA_NAME_VERSION (ptr))
-       ssa_ver_to_stridx.safe_grow_cleared (num_ssa_names);
+       ssa_ver_to_stridx.safe_grow_cleared (num_ssa_names, true);
 
       if (ssa_ver_to_stridx[SSA_NAME_VERSION (ptr)] != 0)
        return;
@@ -5920,7 +5920,7 @@ printf_strlen_execute (function *fun, bool warn_only)
 
   /* This has to happen after initializing the loop optimizer
      and initializing SCEV as they create new SSA_NAMEs.  */
-  ssa_ver_to_stridx.safe_grow_cleared (num_ssa_names);
+  ssa_ver_to_stridx.safe_grow_cleared (num_ssa_names, true);
   max_stridx = 1;
 
   /* String length optimization is implemented as a walk of the dominator
index c7c08213f9aeee375a0b48031ddcac1ce7c3a48d..03a210846cbe1fbd9f79e58f8faec8bf5b1de338 100644 (file)
@@ -59,7 +59,7 @@ void
 set_ssa_name_value (tree name, tree value)
 {
   if (SSA_NAME_VERSION (name) >= ssa_name_values.length ())
-    ssa_name_values.safe_grow_cleared (SSA_NAME_VERSION (name) + 1);
+    ssa_name_values.safe_grow_cleared (SSA_NAME_VERSION (name) + 1, true);
   if (value && TREE_OVERFLOW_P (value))
     value = drop_tree_overflow (value);
   ssa_name_values[SSA_NAME_VERSION (name)] = value;
index d9432657e3083ca24b28bc9c29f79d12abf9bfdd..6ac97fe39c49daa81a0b8dd2a54182235c51d8d4 100644 (file)
@@ -287,7 +287,7 @@ make_ssa_name_fn (struct function *fn, tree var, gimple *stmt,
       t = make_node (SSA_NAME);
       SSA_NAME_VERSION (t) = version;
       if (version >= SSANAMES (fn)->length ())
-       vec_safe_grow_cleared (SSANAMES (fn), version + 1);
+       vec_safe_grow_cleared (SSANAMES (fn), version + 1, true);
       gcc_assert ((*SSANAMES (fn))[version] == NULL);
       (*SSANAMES (fn))[version] = t;
       ssa_name_nodes_created++;
index 707a0591bfeadc7641a603891aee1ac589c865c3..a456709ffd84194cd1f71a9adcaac0a2918611c3 100644 (file)
@@ -555,7 +555,7 @@ streamer_read_tree_bitfields (class lto_input_block *ib,
     {
       unsigned HOST_WIDE_INT length = bp_unpack_var_len_unsigned (&bp);
       if (length > 0)
-       vec_safe_grow (CONSTRUCTOR_ELTS (expr), length);
+       vec_safe_grow (CONSTRUCTOR_ELTS (expr), length, true);
     }
 
 #ifndef ACCEL_COMPILER
index 50abb2b2f3cc44dce321e771d1ef75b865d32308..362cdc4f1cbd9bbb3ad6bc067debb4ba036059ad 100644 (file)
@@ -8394,7 +8394,7 @@ vect_record_loop_mask (loop_vec_info loop_vinfo, vec_loop_masks *masks,
 {
   gcc_assert (nvectors != 0);
   if (masks->length () < nvectors)
-    masks->safe_grow_cleared (nvectors);
+    masks->safe_grow_cleared (nvectors, true);
   rgroup_controls *rgm = &(*masks)[nvectors - 1];
   /* The number of scalars per iteration and the number of vectors are
      both compile-time constants.  */
@@ -8434,7 +8434,7 @@ vect_get_loop_mask (gimple_stmt_iterator *gsi, vec_loop_masks *masks,
      used it.  */
   if (rgm->controls.is_empty ())
     {
-      rgm->controls.safe_grow_cleared (nvectors);
+      rgm->controls.safe_grow_cleared (nvectors, true);
       for (unsigned int i = 0; i < nvectors; ++i)
        {
          tree mask = make_temp_ssa_name (mask_type, NULL, "loop_mask");
@@ -8476,7 +8476,7 @@ vect_record_loop_len (loop_vec_info loop_vinfo, vec_loop_lens *lens,
 {
   gcc_assert (nvectors != 0);
   if (lens->length () < nvectors)
-    lens->safe_grow_cleared (nvectors);
+    lens->safe_grow_cleared (nvectors, true);
   rgroup_controls *rgl = &(*lens)[nvectors - 1];
 
   /* The number of scalars per iteration, scalar occupied bytes and
@@ -8512,7 +8512,7 @@ vect_get_loop_len (loop_vec_info loop_vinfo, vec_loop_lens *lens,
      used it.  */
   if (rgl->controls.is_empty ())
     {
-      rgl->controls.safe_grow_cleared (nvectors);
+      rgl->controls.safe_grow_cleared (nvectors, true);
       for (unsigned int i = 0; i < nvectors; ++i)
        {
          tree len_type = LOOP_VINFO_RGROUP_COMPARE_TYPE (loop_vinfo);
index 03d50ec5c90b92594f77f7aaecdb0be6c049e006..478a45a228171077434c89ade5cf0ba15d62672c 100644 (file)
@@ -4282,7 +4282,7 @@ vect_recog_mask_conversion_pattern (vec_info *vinfo,
 
       auto_vec<tree, 8> args;
       unsigned int nargs = gimple_call_num_args (last_stmt);
-      args.safe_grow (nargs);
+      args.safe_grow (nargs, true);
       for (unsigned int i = 0; i < nargs; ++i)
        args[i] = ((int) i == mask_argno
                   ? tmp
index 167db07645486089cbe5d611da6c859fc25f9ad9..15e5f277eaccf892539c31f72aebea08ad02e8a2 100644 (file)
@@ -2804,7 +2804,7 @@ vect_slp_convert_to_external (vec_info *vinfo, slp_tree node,
      (need to) ignore child nodes of anything that isn't vect_internal_def.  */
   unsigned int group_size = SLP_TREE_LANES (node);
   SLP_TREE_DEF_TYPE (node) = vect_external_def;
-  SLP_TREE_SCALAR_OPS (node).safe_grow (group_size);
+  SLP_TREE_SCALAR_OPS (node).safe_grow (group_size, true);
   FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (node), i, stmt_info)
     {
       tree lhs = gimple_get_lhs (vect_orig_stmt (stmt_info)->stmt);
@@ -3102,7 +3102,7 @@ vect_bb_slp_scalar_cost (vec_info *vinfo,
             confine changes in the callee to the current child/subtree.  */
          if (SLP_TREE_CODE (node) == VEC_PERM_EXPR)
            {
-             subtree_life.safe_grow_cleared (SLP_TREE_LANES (child));
+             subtree_life.safe_grow_cleared (SLP_TREE_LANES (child), true);
              for (unsigned j = 0;
                   j < SLP_TREE_LANE_PERMUTATION (node).length (); ++j)
                {
@@ -3141,7 +3141,8 @@ vect_bb_vectorization_profitable_p (bb_vec_info bb_vinfo)
   FOR_EACH_VEC_ELT (slp_instances, i, instance)
     {
       auto_vec<bool, 20> life;
-      life.safe_grow_cleared (SLP_TREE_LANES (SLP_INSTANCE_TREE (instance)));
+      life.safe_grow_cleared (SLP_TREE_LANES (SLP_INSTANCE_TREE (instance)),
+                             true);
       vect_bb_slp_scalar_cost (bb_vinfo,
                               SLP_INSTANCE_TREE (instance),
                               &life, &scalar_costs, visited);
@@ -4127,7 +4128,7 @@ vectorizable_slp_permutation (vec_info *vinfo, gimple_stmt_iterator *gsi,
   auto_vec<std::pair<std::pair<unsigned, unsigned>, unsigned> > vperm;
   auto_vec<unsigned> active_lane;
   vperm.create (olanes);
-  active_lane.safe_grow_cleared (SLP_TREE_CHILDREN (node).length ());
+  active_lane.safe_grow_cleared (SLP_TREE_CHILDREN (node).length (), true);
   for (unsigned i = 0; i < vf; ++i)
     {
       for (unsigned pi = 0; pi < perm.length (); ++pi)
index 04d202e670ea202434ffa1f7050a8ed246999898..7e072a2e636ad539901719fd65ab518694fc3722 100644 (file)
@@ -3372,8 +3372,8 @@ vectorizable_call (vec_info *vinfo,
   if (modifier == NONE || ifn != IFN_LAST)
     {
       tree prev_res = NULL_TREE;
-      vargs.safe_grow (nargs);
-      orig_vargs.safe_grow (nargs);
+      vargs.safe_grow (nargs, true);
+      orig_vargs.safe_grow (nargs, true);
       auto_vec<vec<tree> > vec_defs (nargs);
       for (j = 0; j < ncopies; ++j)
        {
@@ -4020,7 +4020,8 @@ vectorizable_simd_clone_call (vec_info *vinfo, stmt_vec_info stmt_info,
                == SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP))
          {
            STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_grow_cleared (i * 3
-                                                                       + 1);
+                                                                       + 1,
+                                                                     true);
            STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_push (arginfo[i].op);
            tree lst = POINTER_TYPE_P (TREE_TYPE (arginfo[i].op))
                       ? size_type_node : TREE_TYPE (arginfo[i].op);
@@ -4060,8 +4061,8 @@ vectorizable_simd_clone_call (vec_info *vinfo, stmt_vec_info stmt_info,
 
   auto_vec<vec<tree> > vec_oprnds;
   auto_vec<unsigned> vec_oprnds_i;
-  vec_oprnds.safe_grow_cleared (nargs);
-  vec_oprnds_i.safe_grow_cleared (nargs);
+  vec_oprnds.safe_grow_cleared (nargs, true);
+  vec_oprnds_i.safe_grow_cleared (nargs, true);
   for (j = 0; j < ncopies; ++j)
     {
       /* Build argument list for the vectorized call.  */
@@ -6356,7 +6357,7 @@ scan_store_can_perm_p (tree vectype, tree init,
       if (use_whole_vector)
        {
          if (kind != scan_store_kind_perm && use_whole_vector->is_empty ())
-           use_whole_vector->safe_grow_cleared (i);
+           use_whole_vector->safe_grow_cleared (i, true);
          if (kind != scan_store_kind_perm || !use_whole_vector->is_empty ())
            use_whole_vector->safe_push (kind);
        }
@@ -7839,7 +7840,7 @@ vectorizable_store (vec_info *vinfo,
   tree vec_mask = NULL;
   auto_vec<tree> vec_offsets;
   auto_vec<vec<tree> > gvec_oprnds;
-  gvec_oprnds.safe_grow_cleared (group_size);
+  gvec_oprnds.safe_grow_cleared (group_size, true);
   for (j = 0; j < ncopies; j++)
     {
       gimple *new_stmt;
index 1c4b958871b474da0a98b8695d9fb3f134fa2426..a28899170ed65622ffcf755c6ffecb289dc4c12e 100644 (file)
--- a/gcc/vec.c
+++ b/gcc/vec.c
@@ -338,7 +338,7 @@ test_safe_grow_cleared ()
 {
   auto_vec <int> v;
   ASSERT_EQ (0, v.length ());
-  v.safe_grow_cleared (50);
+  v.safe_grow_cleared (50, true);
   ASSERT_EQ (50, v.length ());
   ASSERT_EQ (0, v[0]);
   ASSERT_EQ (0, v[49]);
index 6ede62791b0aee653052bb3958fc4543ccf06bc8..b0d2e3164e4f496b085c45def01af177ae6ba4d0 100644 (file)
--- a/gcc/vec.h
+++ b/gcc/vec.h
@@ -723,11 +723,12 @@ vec_free (vec<T, A, vl_embed> *&v)
 /* Grow V to length LEN.  Allocate it, if necessary.  */
 template<typename T, typename A>
 inline void
-vec_safe_grow (vec<T, A, vl_embed> *&v, unsigned len CXX_MEM_STAT_INFO)
+vec_safe_grow (vec<T, A, vl_embed> *&v, unsigned len,
+              bool exact CXX_MEM_STAT_INFO)
 {
   unsigned oldlen = vec_safe_length (v);
   gcc_checking_assert (len >= oldlen);
-  vec_safe_reserve_exact (v, len - oldlen PASS_MEM_STAT);
+  vec_safe_reserve (v, len - oldlen, exact PASS_MEM_STAT);
   v->quick_grow (len);
 }
 
@@ -735,10 +736,11 @@ vec_safe_grow (vec<T, A, vl_embed> *&v, unsigned len CXX_MEM_STAT_INFO)
 /* If V is NULL, allocate it.  Call V->safe_grow_cleared(LEN).  */
 template<typename T, typename A>
 inline void
-vec_safe_grow_cleared (vec<T, A, vl_embed> *&v, unsigned len CXX_MEM_STAT_INFO)
+vec_safe_grow_cleared (vec<T, A, vl_embed> *&v, unsigned len,
+                      bool exact CXX_MEM_STAT_INFO)
 {
   unsigned oldlen = vec_safe_length (v);
-  vec_safe_grow (v, len PASS_MEM_STAT);
+  vec_safe_grow (v, len, exact PASS_MEM_STAT);
   vec_default_construct (v->address () + oldlen, len - oldlen);
 }
 
@@ -748,9 +750,9 @@ vec_safe_grow_cleared (vec<T, A, vl_embed> *&v, unsigned len CXX_MEM_STAT_INFO)
 template<typename T>
 inline void
 vec_safe_grow_cleared (vec<T, va_heap, vl_ptr> *&v,
-                      unsigned len CXX_MEM_STAT_INFO)
+                      unsigned len, bool exact CXX_MEM_STAT_INFO)
 {
-  v->safe_grow_cleared (len PASS_MEM_STAT);
+  v->safe_grow_cleared (len, exact PASS_MEM_STAT);
 }
 
 /* If V does not have space for NELEMS elements, call
@@ -1465,8 +1467,8 @@ public:
   T *safe_push (const T &CXX_MEM_STAT_INFO);
   T &pop (void);
   void truncate (unsigned);
-  void safe_grow (unsigned CXX_MEM_STAT_INFO);
-  void safe_grow_cleared (unsigned CXX_MEM_STAT_INFO);
+  void safe_grow (unsigned, bool CXX_MEM_STAT_INFO);
+  void safe_grow_cleared (unsigned, bool CXX_MEM_STAT_INFO);
   void quick_grow (unsigned);
   void quick_grow_cleared (unsigned);
   void quick_insert (unsigned, const T &);
@@ -1892,11 +1894,11 @@ vec<T, va_heap, vl_ptr>::truncate (unsigned size)
 
 template<typename T>
 inline void
-vec<T, va_heap, vl_ptr>::safe_grow (unsigned len MEM_STAT_DECL)
+vec<T, va_heap, vl_ptr>::safe_grow (unsigned len, bool exact MEM_STAT_DECL)
 {
   unsigned oldlen = length ();
   gcc_checking_assert (oldlen <= len);
-  reserve_exact (len - oldlen PASS_MEM_STAT);
+  reserve (len - oldlen, exact PASS_MEM_STAT);
   if (m_vec)
     m_vec->quick_grow (len);
   else
@@ -1910,11 +1912,12 @@ vec<T, va_heap, vl_ptr>::safe_grow (unsigned len MEM_STAT_DECL)
 
 template<typename T>
 inline void
-vec<T, va_heap, vl_ptr>::safe_grow_cleared (unsigned len MEM_STAT_DECL)
+vec<T, va_heap, vl_ptr>::safe_grow_cleared (unsigned len, bool exact
+                                           MEM_STAT_DECL)
 {
   unsigned oldlen = length ();
   size_t growby = len - oldlen;
-  safe_grow (len PASS_MEM_STAT);
+  safe_grow (len, exact PASS_MEM_STAT);
   if (growby != 0)
     vec_default_construct (address () + oldlen, growby);
 }