+2012-09-10 Diego Novillo <dnovillo@google.com>
+
+ * vec.h (vec_t::quick_push): Remove overload that accepts 'T *'.
+ Update all users.
+ (vec_t::safe_push): Likewise.
+ (vec_t::quick_insert): Likewise.
+ (vec_t::lower_bound): Likewise.
+ (vec_t::safe_insert): Likewise.
+ (vec_t::replace): Change second argument to 'T &'.
+
2012-09-10 Maciej W. Rozycki <macro@codesourcery.com>
* config/rs6000/rs6000.md: Move a splitter next to its insn.
(Node (gnat_value), gnat_subtype,
get_entity_name (gnat_discrim),
definition, true, false));
- subst_pair *s = VEC_safe_push (subst_pair, heap, gnu_list, NULL);
- s->discriminant = gnu_field;
- s->replacement = replacement;
+ subst_pair s = {gnu_field, replacement};
+ VEC_safe_push (subst_pair, heap, gnu_list, s);
}
return gnu_list;
still be accessed. */
if (!integer_zerop (qual))
{
- variant_desc *v;
tree variant_type = TREE_TYPE (gnu_field), variant_subpart;
+ variant_desc v = {variant_type, gnu_field, qual, NULL_TREE};
- v = VEC_safe_push (variant_desc, heap, gnu_list, NULL);
- v->type = variant_type;
- v->field = gnu_field;
- v->qual = qual;
- v->new_type = NULL_TREE;
+ VEC_safe_push (variant_desc, heap, gnu_list, v);
/* Recurse on the variant subpart of the variant, if any. */
variant_subpart = get_variant_part (variant_type);
FOR_EACH_CONSTRUCTOR_ELT(e, idx, index, value)
{
- constructor_elt *elt;
/* We expect only simple constructors. */
if (!SAME_FIELD_P (index, efield))
break;
/* The field must be the same. */
if (!SAME_FIELD_P (efield, field))
break;
- elt = VEC_quick_push (constructor_elt, v, NULL);
- elt->index = field;
- elt->value = convert (TREE_TYPE (field), value);
+ constructor_elt elt = {field, convert (TREE_TYPE (field), value)};
+ VEC_quick_push (constructor_elt, v, elt);
/* If packing has made this field a bitfield and the input
value couldn't be emitted statically any more, we need to
v = VEC_alloc (constructor_elt, gc, len);
FOR_EACH_CONSTRUCTOR_VALUE (e, ix, value)
{
- constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
- elt->index = NULL_TREE;
- elt->value = value;
+ constructor_elt elt = {NULL_TREE, value};
+ VEC_quick_push (constructor_elt, v, elt);
}
expr = copy_node (expr);
TREE_TYPE (expr) = type;
if (flag_strict_aliasing)
{
if (alias_sets == 0)
- VEC_safe_push (alias_set_entry, gc, alias_sets, (alias_set_entry) 0);
- VEC_safe_push (alias_set_entry, gc, alias_sets, (alias_set_entry) 0);
+ VEC_safe_push (alias_set_entry, gc, alias_sets, 0);
+ VEC_safe_push (alias_set_entry, gc, alias_sets, 0);
return VEC_length (alias_set_entry, alias_sets) - 1;
}
else
/* Build up argv vector. Just in case the string is stored away, use garbage
collected strings. */
VEC_truncate (const_char_p, optimize_args, 0);
- VEC_safe_push (const_char_p, gc, optimize_args, (const_char_p)NULL);
+ VEC_safe_push (const_char_p, gc, optimize_args, NULL);
for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
{
}
else
{
- pending_weak *pe;
- pe = VEC_safe_push (pending_weak, gc, pending_weaks, NULL);
- pe->name = name;
- pe->value = value;
+ pending_weak pe = {name, value};
+ VEC_safe_push (pending_weak, gc, pending_weaks, pe);
}
}
return;
}
- p = VEC_safe_push (pending_redefinition, gc, pending_redefine_extname, NULL);
- p->oldname = oldname;
- p->newname = newname;
+ pending_redefinition e = {oldname, newname};
+ VEC_safe_push (pending_redefinition, gc, pending_redefine_extname, e);
}
/* The current prefix set by #pragma extern_prefix. */
ns_name.space = space;
ns_name.name = name;
- VEC_safe_push (pragma_ns_name, heap, registered_pp_pragmas, &ns_name);
+ VEC_safe_push (pragma_ns_name, heap, registered_pp_pragmas, ns_name);
id = VEC_length (pragma_ns_name, registered_pp_pragmas);
id += PRAGMA_FIRST_EXTERNAL - 1;
}
else
{
VEC_safe_push (internal_pragma_handler, heap, registered_pragmas,
- &ihandler);
+ ihandler);
id = VEC_length (internal_pragma_handler, registered_pragmas);
id += PRAGMA_FIRST_EXTERNAL - 1;
{
tree decl = b->decl;
tree type = TREE_TYPE (decl);
- c_arg_tag *tag;
+ c_arg_tag tag;
const char *keyword;
switch (TREE_CODE (decl))
}
}
- tag = VEC_safe_push (c_arg_tag, gc, tags, NULL);
- tag->id = b->id;
- tag->type = decl;
+ tag.id = b->id;
+ tag.type = decl;
+ VEC_safe_push (c_arg_tag, gc, tags, tag);
break;
case CONST_DECL:
/* Append a new c_expr_t element to V. */
#define C_EXPR_APPEND(V, ELEM) \
do { \
- c_expr_t *__elem_p = VEC_safe_push (c_expr_t, gc, V, NULL); \
- *__elem_p = (ELEM); \
+ c_expr_t __elem = (ELEM); \
+ VEC_safe_push (c_expr_t, gc, V, __elem); \
} while (0)
/* A kind of type specifier. Note that this information is currently
struct obstack * braced_init_obstack)
{
tree semantic_type = NULL_TREE;
- constructor_elt *celt;
bool maybe_const = true;
bool npc;
/* Otherwise, output this element either to
constructor_elements or to the assembler file. */
- celt = VEC_safe_push (constructor_elt, gc, constructor_elements, NULL);
- celt->index = field;
- celt->value = value;
+ constructor_elt celt = {field, value};
+ VEC_safe_push (constructor_elt, gc, constructor_elements, celt);
/* Advance the variable that indicates sequential elements output. */
if (TREE_CODE (constructor_type) == ARRAY_TYPE)
static struct mips_multi_member *
mips_multi_add (void)
{
- return VEC_safe_push (mips_multi_member, heap, mips_multi_members,
- (struct mips_multi_member *) 0);
+ mips_multi_member empty;
+ return VEC_safe_push (mips_multi_member, heap, mips_multi_members, empty);
}
/* Add a normal insn with the given asm format to the current multi-insn
void
pa_hpux_asm_output_external (FILE *file, tree decl, const char *name)
{
- extern_symbol * p = VEC_safe_push (extern_symbol, gc, extern_symbols, NULL);
-
gcc_assert (file == asm_out_file);
- p->decl = decl;
- p->name = name;
+ extern_symbol p = {decl, name};
+ VEC_safe_push (extern_symbol, gc, extern_symbols, p);
}
/* Output text required at the end of an assembler file.
vec = VEC_alloc (constructor_elt, gc, size);
for(i = 0; i < size; i++)
{
- constructor_elt *elt;
-
- elt = VEC_quick_push (constructor_elt, vec, NULL);
- elt->index = NULL_TREE;
- elt->value = arg;
+ constructor_elt elt = {NULL_TREE, arg};
+ VEC_quick_push (constructor_elt, vec, elt);
}
return build_constructor (type, vec);
}
add_compiler_branch_island (tree label_name, tree function_name,
int line_number)
{
- branch_island *bi = VEC_safe_push (branch_island, gc, branch_islands, NULL);
-
- bi->function_name = function_name;
- bi->label_name = label_name;
- bi->line_number = line_number;
+ branch_island bi = {function_name, label_name, line_number};
+ VEC_safe_push (branch_island, gc, branch_islands, bi);
}
/* Generate far-jump branch islands for everything recorded in
offset. */
if (vid->binfo == TYPE_BINFO (vid->derived))
{
- tree_pair_p elt = VEC_safe_push (tree_pair_s, gc,
- CLASSTYPE_VCALL_INDICES (vid->derived),
- NULL);
- elt->purpose = orig_fn;
- elt->value = vid->index;
+ tree_pair_s elt = {orig_fn, vid->index};
+ VEC_safe_push (tree_pair_s, gc, CLASSTYPE_VCALL_INDICES (vid->derived),
+ elt);
}
/* The next vcall offset will be found at a more negative
declare_local_label (tree id)
{
tree decl;
- cp_label_binding *bind;
+ cp_label_binding bind;
/* Add a new entry to the SHADOWED_LABELS list so that when we leave
this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
- bind = VEC_safe_push (cp_label_binding, gc,
- current_binding_level->shadowed_labels, NULL);
- bind->prev_value = IDENTIFIER_LABEL_VALUE (id);
+ bind.prev_value = IDENTIFIER_LABEL_VALUE (id);
decl = make_label_decl (id, /*local_p=*/1);
- bind->label = decl;
+ bind.label = decl;
+ VEC_safe_push (cp_label_binding, gc, current_binding_level->shadowed_labels,
+ bind);
return decl;
}
|| (TYPE_LANG_SPECIFIC (inner_type)
&& TYPE_BEING_DEFINED (inner_type)))
{
- incomplete_var *iv
- = VEC_safe_push (incomplete_var, gc, incomplete_vars, NULL);
- iv->decl = var;
- iv->incomplete_type = inner_type;
+ incomplete_var iv = {var, inner_type};
+ VEC_safe_push (incomplete_var, gc, incomplete_vars, iv);
}
}
}
if (!DECL_INITIAL (fn))
{
/* Not defined yet; check again at EOF. */
- pending_noexcept *p
- = VEC_safe_push (pending_noexcept, gc,
- pending_noexcept_checks, NULL);
- p->fn = fn;
- p->loc = input_location;
+ pending_noexcept p = {fn, input_location};
+ VEC_safe_push (pending_noexcept, gc, pending_noexcept_checks, p);
}
else
maybe_noexcept_warning (fn);
have an upper bound of -1. */
if (!tree_int_cst_equal (max_index, integer_minus_one_node))
{
- constructor_elt *ce;
+ constructor_elt ce;
v = VEC_alloc (constructor_elt, gc, 1);
- ce = VEC_quick_push (constructor_elt, v, NULL);
/* If this is a one element array, we just use a regular init. */
if (tree_int_cst_equal (size_zero_node, max_index))
- ce->index = size_zero_node;
+ ce.index = size_zero_node;
else
- ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
+ ce.index = build2 (RANGE_EXPR, sizetype, size_zero_node,
max_index);
- ce->value = build_zero_init_1 (TREE_TYPE (type),
+ ce.value = build_zero_init_1 (TREE_TYPE (type),
/*nelts=*/NULL_TREE,
static_storage_p, NULL_TREE);
+ VEC_quick_push (constructor_elt, v, ce);
}
/* Build a constructor to contain the initializations. */
have an upper bound of -1. */
if (!tree_int_cst_equal (max_index, integer_minus_one_node))
{
- constructor_elt *ce;
+ constructor_elt ce;
v = VEC_alloc (constructor_elt, gc, 1);
- ce = VEC_quick_push (constructor_elt, v, NULL);
/* If this is a one element array, we just use a regular init. */
if (tree_int_cst_equal (size_zero_node, max_index))
- ce->index = size_zero_node;
+ ce.index = size_zero_node;
else
- ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
- max_index);
+ ce.index = build2 (RANGE_EXPR, sizetype, size_zero_node, max_index);
- ce->value = build_value_init (TREE_TYPE (type), complain);
+ ce.value = build_value_init (TREE_TYPE (type), complain);
+ VEC_quick_push (constructor_elt, v, ce);
- if (ce->value == error_mark_node)
+ if (ce.value == error_mark_node)
return error_mark_node;
/* We shouldn't have gotten here for anything that would need
non-trivial initialization, and gimplify_init_ctor_preeval
would need to be fixed to allow it. */
- gcc_assert (TREE_CODE (ce->value) != TARGET_EXPR
- && TREE_CODE (ce->value) != AGGR_INIT_EXPR);
+ gcc_assert (TREE_CODE (ce.value) != TARGET_EXPR
+ && TREE_CODE (ce.value) != AGGR_INIT_EXPR);
}
/* Build a constructor to contain the initializations. */
static cxx_binding *
new_class_binding (tree name, tree value, tree type, cp_binding_level *scope)
{
- cp_class_binding *cb;
- cxx_binding *binding;
-
- cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
-
- cb->identifier = name;
- cb->base = binding = cxx_binding_make (value, type);
+ cp_class_binding cb = {cxx_binding_make (value, type), name};
+ cxx_binding *binding = cb.base;
+ VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, cb);
binding->scope = scope;
return binding;
}
static void
store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
{
- cxx_saved_binding *saved;
+ cxx_saved_binding saved;
gcc_checking_assert (store_binding_p (id));
IDENTIFIER_MARKED (id) = 1;
- saved = VEC_quick_push (cxx_saved_binding, *old_bindings, NULL);
- saved->identifier = id;
- saved->binding = IDENTIFIER_BINDING (id);
- saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
+ saved.identifier = id;
+ saved.binding = IDENTIFIER_BINDING (id);
+ saved.real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
+ VEC_quick_push (cxx_saved_binding, *old_bindings, saved);
IDENTIFIER_BINDING (id) = NULL;
}
lexer = cp_lexer_alloc ();
/* Put the first token in the buffer. */
- VEC_quick_push (cp_token, lexer->buffer, &token);
+ VEC_quick_push (cp_token, lexer->buffer, token);
/* Get the remaining tokens from the preprocessor. */
while (token.type != CPP_EOF)
{
cp_lexer_get_preprocessor_token (lexer, &token);
- VEC_safe_push (cp_token, gc, lexer->buffer, &token);
+ VEC_safe_push (cp_token, gc, lexer->buffer, token);
}
lexer->last_token = VEC_address (cp_token, lexer->buffer)
static void
push_unparsed_function_queues (cp_parser *parser)
{
- VEC_safe_push (cp_unparsed_functions_entry, gc,
- parser->unparsed_queues, NULL);
- unparsed_funs_with_default_args = NULL;
- unparsed_funs_with_definitions = make_tree_vector ();
- unparsed_nsdmis = NULL;
+ cp_unparsed_functions_entry e = {NULL, make_tree_vector (), NULL};
+ VEC_safe_push (cp_unparsed_functions_entry, gc, parser->unparsed_queues, e);
}
static void
decl = current_function_decl;
ti.t = lambda_scope;
ti.i = lambda_count;
- VEC_safe_push (tree_int, gc, lambda_scope_stack, &ti);
+ VEC_safe_push (tree_int, gc, lambda_scope_stack, ti);
if (lambda_scope != decl)
{
/* Don't reset the count if we're still in the same function. */
probe = TREE_CHAIN (probe))
if (TREE_PURPOSE (probe))
{
- cp_default_arg_entry *entry
- = VEC_safe_push (cp_default_arg_entry, gc,
- unparsed_funs_with_default_args, NULL);
- entry->class_type = current_class_type;
- entry->decl = decl;
+ cp_default_arg_entry entry = {current_class_type, decl};
+ VEC_safe_push (cp_default_arg_entry, gc,
+ unparsed_funs_with_default_args, entry);
break;
}
}
VEC_safe_push (qualified_typedef_usage_t, gc,
TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti),
- &typedef_usage);
+ typedef_usage);
}
/* Append TYPE_DECL to the template TEMPL.
deferred_access_no_check++;
else
{
- deferred_access *ptr;
-
- ptr = VEC_safe_push (deferred_access, gc, deferred_access_stack, NULL);
- ptr->deferred_access_checks = NULL;
- ptr->deferring_access_checks_kind = deferring;
+ deferred_access e = {NULL, deferring};
+ VEC_safe_push (deferred_access, gc, deferred_access_stack, e);
}
}
}
/* Insert into parent's checks. */
VEC_safe_push (deferred_access_check, gc,
- ptr->deferred_access_checks, chk);
+ ptr->deferred_access_checks, *chk);
found:;
}
}
int i;
deferred_access *ptr;
deferred_access_check *chk;
- deferred_access_check *new_access;
/* Exit if we are in a context that no access checking is performed.
}
}
/* If not, record the check. */
- new_access =
- VEC_safe_push (deferred_access_check, gc,
- ptr->deferred_access_checks, 0);
- new_access->binfo = binfo;
- new_access->decl = decl;
- new_access->diag_decl = diag_decl;
- new_access->loc = input_location;
+ deferred_access_check new_access = {binfo, decl, diag_decl, input_location};
+ VEC_safe_push (deferred_access_check, gc, ptr->deferred_access_checks,
+ new_access);
return true;
}
if (dest == NULL)
return;
- elt = VEC_safe_push (reg_saved_in_data, heap,
- cur_trace->regs_saved_in_regs, NULL);
- elt->orig_reg = src;
- elt->saved_in_reg = dest;
+ reg_saved_in_data e = {src, dest};
+ VEC_safe_push (reg_saved_in_data, heap, cur_trace->regs_saved_in_regs, e);
}
/* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
queue_reg_save (rtx reg, rtx sreg, HOST_WIDE_INT offset)
{
queued_reg_save *q;
+ queued_reg_save e = {reg, sreg, offset};
size_t i;
/* Duplicates waste space, but it's also necessary to remove them
for correctness, since the queue gets output in reverse order. */
FOR_EACH_VEC_ELT (queued_reg_save, queued_reg_saves, i, q)
if (compare_reg_or_pc (q->reg, reg))
- goto found;
-
- q = VEC_safe_push (queued_reg_save, heap, queued_reg_saves, NULL);
+ {
+ *q = e;
+ return;
+ }
- found:
- q->reg = reg;
- q->saved_reg = sreg;
- q->cfa_offset = offset;
+ VEC_safe_push (queued_reg_save, heap, queued_reg_saves, e);
}
/* Output all the entries in QUEUED_REG_SAVES. */
create_pseudo_cfg (void)
{
bool saw_barrier, switch_sections;
- dw_trace_info *ti;
+ dw_trace_info ti;
rtx insn;
unsigned i;
/* The first trace begins at the start of the function,
and begins with the CIE row state. */
trace_info = VEC_alloc (dw_trace_info, heap, 16);
- ti = VEC_quick_push (dw_trace_info, trace_info, NULL);
+ memset (&ti, 0, sizeof (ti));
+ ti.head = get_insns ();
+ ti.beg_row = cie_cfi_row;
+ ti.cfa_store = cie_cfi_row->cfa;
+ ti.cfa_temp.reg = INVALID_REGNUM;
+ VEC_quick_push (dw_trace_info, trace_info, ti);
- memset (ti, 0, sizeof (*ti));
- ti->head = get_insns ();
- ti->beg_row = cie_cfi_row;
- ti->cfa_store = cie_cfi_row->cfa;
- ti->cfa_temp.reg = INVALID_REGNUM;
if (cie_return_save)
VEC_safe_push (reg_saved_in_data, heap,
- ti->regs_saved_in_regs, cie_return_save);
+ ti.regs_saved_in_regs, *cie_return_save);
/* Walk all the insns, collecting start of trace locations. */
saw_barrier = false;
else if (save_point_p (insn)
&& (LABEL_P (insn) || !saw_barrier))
{
- ti = VEC_safe_push (dw_trace_info, heap, trace_info, NULL);
- memset (ti, 0, sizeof (*ti));
- ti->head = insn;
- ti->switch_sections = switch_sections;
- ti->id = VEC_length (dw_trace_info, trace_info) - 1;
+ memset (&ti, 0, sizeof (ti));
+ ti.head = insn;
+ ti.switch_sections = switch_sections;
+ ti.id = VEC_length (dw_trace_info, trace_info) - 1;
+ VEC_safe_push (dw_trace_info, heap, trace_info, ti);
saw_barrier = false;
switch_sections = false;
avoiding stale pointer problems due to reallocation. */
trace_index = htab_create (VEC_length (dw_trace_info, trace_info),
dw_trace_info_hash, dw_trace_info_eq, NULL);
- FOR_EACH_VEC_ELT (dw_trace_info, trace_info, i, ti)
+ dw_trace_info *tp;
+ FOR_EACH_VEC_ELT (dw_trace_info, trace_info, i, tp)
{
void **slot;
if (dump_file)
fprintf (dump_file, "Creating trace %u : start at %s %d%s\n", i,
- rtx_name[(int) GET_CODE (ti->head)], INSN_UID (ti->head),
- ti->switch_sections ? " (section switch)" : "");
+ rtx_name[(int) GET_CODE (tp->head)], INSN_UID (tp->head),
+ tp->switch_sections ? " (section switch)" : "");
- slot = htab_find_slot_with_hash (trace_index, ti,
- INSN_UID (ti->head), INSERT);
+ slot = htab_find_slot_with_hash (trace_index, tp,
+ INSN_UID (tp->head), INSERT);
gcc_assert (*slot == NULL);
- *slot = (void *) ti;
+ *slot = (void *) tp;
}
}
if (die->die_attr == NULL)
die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
- VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
+ VEC_safe_push (dw_attr_node, gc, die->die_attr, *attr);
}
static inline enum dw_val_class
e.die = die;
e.name = xstrdup (str);
- VEC_safe_push (pubname_entry, gc, pubname_table, &e);
+ VEC_safe_push (pubname_entry, gc, pubname_table, e);
}
static void
gcc_assert (scope_name);
e.name = concat (scope_name, get_AT_string (die, DW_AT_name), NULL);
e.die = die;
- VEC_safe_push (pubname_entry, gc, pubname_table, &e);
+ VEC_safe_push (pubname_entry, gc, pubname_table, e);
}
/* Add a new entry to .debug_pubtypes if appropriate. */
{
e.die = die;
e.name = concat (scope_name, name, NULL);
- VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
+ VEC_safe_push (pubname_entry, gc, pubtype_table, e);
}
/* Although it might be more consistent to add the pubinfo for the
deferred_locations entry;
entry.variable = variable;
entry.die = die;
- VEC_safe_push (deferred_locations, gc, deferred_locations_list, &entry);
+ VEC_safe_push (deferred_locations, gc, deferred_locations_list, entry);
}
/* Helper function for tree_add_const_value_attribute. Natively encode
entry.arg = arg;
VEC_safe_push (die_arg_entry, gc,
tmpl_value_parm_die_table,
- &entry);
+ entry);
}
/* Return TRUE if T is an instance of generic type, FALSE
dw_line_info_entry e;
e.opcode = opcode;
e.val = val;
- VEC_safe_push (dw_line_info_entry, gc, table->entries, &e);
+ VEC_safe_push (dw_line_info_entry, gc, table->entries, e);
}
/* Output a label to mark the beginning of a source code line entry
e.code = DW_MACINFO_start_file;
e.lineno = lineno;
e.info = ggc_strdup (filename);
- VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
+ VEC_safe_push (macinfo_entry, gc, macinfo_table, e);
}
}
e.code = DW_MACINFO_end_file;
e.lineno = lineno;
e.info = NULL;
- VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
+ VEC_safe_push (macinfo_entry, gc, macinfo_table, e);
}
}
e.code = 0;
e.lineno = 0;
e.info = NULL;
- VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
+ VEC_safe_push (macinfo_entry, gc, macinfo_table, e);
}
e.code = DW_MACINFO_define;
e.lineno = lineno;
e.info = ggc_strdup (buffer);
- VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
+ VEC_safe_push (macinfo_entry, gc, macinfo_table, e);
}
}
e.code = 0;
e.lineno = 0;
e.info = NULL;
- VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
+ VEC_safe_push (macinfo_entry, gc, macinfo_table, e);
}
e.code = DW_MACINFO_undef;
e.lineno = lineno;
e.info = ggc_strdup (buffer);
- VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
+ VEC_safe_push (macinfo_entry, gc, macinfo_table, e);
}
}
switch (ref->code)
{
case DW_MACINFO_start_file:
- VEC_safe_push (macinfo_entry, gc, files, ref);
+ VEC_safe_push (macinfo_entry, gc, files, *ref);
break;
case DW_MACINFO_end_file:
if (!VEC_empty (macinfo_entry, files))
if (ix != VEC_length (dw_attr_node, die->die_attr) - 1)
{
VEC_pop (dw_attr_node, die->die_attr);
- VEC_quick_insert (dw_attr_node, die->die_attr, ix, &linkage);
+ VEC_quick_insert (dw_attr_node, die->die_attr, ix, linkage);
}
}
{
curr_rtl_loc++;
VEC_safe_push (int, heap, locations_locators_locs, curr_rtl_loc);
- VEC_safe_push (location_t, heap, locations_locators_vals, &curr_location);
+ VEC_safe_push (location_t, heap, locations_locators_vals, curr_location);
last_location = curr_location;
}
return curr_rtl_loc;
cfun->eh = ggc_alloc_cleared_eh_status ();
/* Make sure zero'th entries are used. */
- VEC_safe_push (eh_region, gc, cfun->eh->region_array, (eh_region) NULL);
- VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, (eh_landing_pad) NULL);
+ VEC_safe_push (eh_region, gc, cfun->eh->region_array, NULL);
+ VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, NULL);
}
\f
/* Routines to generate the exception tree somewhat directly.
if (targetm.arm_eabi_unwinder)
VEC_safe_push (tree, gc, cfun->eh->ehspec_data.arm_eabi, NULL_TREE);
else
- VEC_safe_push (uchar, gc, cfun->eh->ehspec_data.other, (uchar) 0);
+ VEC_safe_push (uchar, gc, cfun->eh->ehspec_data.other, 0);
}
return n->filter;
/* Initialize DOVAR. */
tmp = fold_build2_loc (input_location, MULT_EXPR, type, count, step);
tmp = fold_build2_loc (input_location, PLUS_EXPR, type, from, tmp);
- di = VEC_safe_push (dovar_init, heap, inits, NULL);
- di->var = dovar;
- di->init = tmp;
+ dovar_init e = {dovar, tmp};
+ VEC_safe_push (dovar_init, heap, inits, e);
}
if (!dovar_found)
bitmap_copy (local_lr, &lr_bb_info->in);
/* Push a marker for the leave_block callback. */
- VEC_safe_push (df_ref, heap, reg_defs_stack, (df_ref) NULL);
+ VEC_safe_push (df_ref, heap, reg_defs_stack, NULL);
process_uses (df_get_artificial_uses (bb_index), DF_REF_AT_TOP);
process_defs (df_get_artificial_defs (bb_index), DF_REF_AT_TOP);
and record info about each one.
Also search for the programs that are to be run. */
- VEC_safe_push (const_char_p, heap, argbuf, (const_char_p)0);
+ VEC_safe_push (const_char_p, heap, argbuf, 0);
commands[0].prog = VEC_index (const_char_p, argbuf, 0); /* first command. */
commands[0].argv = VEC_address (const_char_p, argbuf);
{
rtx dest_addr, insn;
int bb;
- modify_pair *pair;
+ modify_pair pair;
while (GET_CODE (dest) == SUBREG
|| GET_CODE (dest) == ZERO_EXTRACT
insn = (rtx) v_insn;
bb = BLOCK_FOR_INSN (insn)->index;
- pair = VEC_safe_push (modify_pair, heap, canon_modify_mem_list[bb], NULL);
- pair->dest = dest;
- pair->dest_addr = dest_addr;
+ pair.dest = dest;
+ pair.dest_addr = dest_addr;
+ VEC_safe_push (modify_pair, heap, canon_modify_mem_list[bb], pair);
}
/* Record memory modification information for INSN. We do not actually care
= VEC_alloc (vect_el_t, heap, compressed_min_issue_delay_len);
for (i = 0; i < compressed_min_issue_delay_len; i++)
- VEC_quick_push (vect_el_t, compressed_min_issue_delay_vect,
- (vect_el_t) 0);
+ VEC_quick_push (vect_el_t, compressed_min_issue_delay_vect, 0);
for (i = 0; i < min_issue_delay_len; i++)
{
reserved_units_table = VEC_alloc (vect_el_t, heap, reserved_units_size);
for (i = 0; i < reserved_units_size; i++)
- VEC_quick_push (vect_el_t, reserved_units_table, (vect_el_t) 0);
+ VEC_quick_push (vect_el_t, reserved_units_table, 0);
for (n = 0; n < VEC_length (state_t, output_states_vect); n++)
{
state_t s = VEC_index (state_t, output_states_vect, n);
else
{
while (ix > VEC_length (locstr, *vp))
- VEC_safe_push (locstr, heap, *vp, (locstr) NULL);
+ VEC_safe_push (locstr, heap, *vp, NULL);
VEC_safe_push (locstr, heap, *vp, str);
}
}
{
p.op = optabs[pindex].op;
p.sort_num = (p.op << 16) | (p.m2 << 8) | p.m1;
- VEC_safe_push (pattern, heap, patterns, &p);
+ VEC_safe_push (pattern, heap, patterns, p);
return;
}
}
/* Not found. Create a new label and record the return statement. */
tmp_rs.label = create_artificial_label (cfun->function_end_locus);
tmp_rs.stmt = stmt;
- VEC_safe_push (return_statements_t, heap, data->return_statements, &tmp_rs);
+ VEC_safe_push (return_statements_t, heap, data->return_statements, tmp_rs);
/* Generate a goto statement and remove the return statement. */
found:
VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
- constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ constructor_elt empty = {NULL, NULL};
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, empty);
tree field = TYPE_FIELDS(lhs_type_tree);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
"__values") == 0);
elt->index = field;
elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
- elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt = VEC_quick_push(constructor_elt, init, empty);
field = DECL_CHAIN(field);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
"__count") == 0);
elt->index = field;
elt->value = fold_convert(TREE_TYPE(field), integer_zero_node);
- elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt = VEC_quick_push(constructor_elt, init, empty);
field = DECL_CHAIN(field);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
"__capacity") == 0);
VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
- constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ constructor_elt empty = {NULL, NULL};
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, empty);
tree field = TYPE_FIELDS(lhs_type_tree);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
(lhs_is_empty ? "__type_descriptor" : "__methods")) == 0);
elt->value = fold_convert_loc(location.gcc_location(), TREE_TYPE(field),
first_field_value);
- elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt = VEC_quick_push(constructor_elt, init, empty);
field = DECL_CHAIN(field);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__object") == 0);
elt->index = field;
VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
- constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ constructor_elt empty = {NULL, NULL};
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, empty);
tree field = TYPE_FIELDS(lhs_type_tree);
elt->index = field;
// The second field is simply the object pointer.
- elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt = VEC_quick_push(constructor_elt, init, empty);
field = DECL_CHAIN(field);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__object") == 0);
elt->index = field;
VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
- constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ constructor_elt empty = {NULL, NULL};
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, empty);
tree field = TYPE_FIELDS(struct_tree);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
elt->index = field;
elt->value = value_pointer;
- elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt = VEC_quick_push(constructor_elt, init, empty);
field = DECL_CHAIN(field);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
elt->index = field;
elt->value = fold_convert_loc(loc.gcc_location(), TREE_TYPE(field),
result_length_tree);
- elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt = VEC_quick_push(constructor_elt, init, empty);
field = DECL_CHAIN(field);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__capacity") == 0);
elt->index = field;
if (val == error_mark_node || TREE_TYPE(val) == error_mark_node)
return error_mark_node;
- constructor_elt* elt = VEC_quick_push(constructor_elt, elts, NULL);
+ constructor_elt empty = {NULL, NULL};
+ constructor_elt* elt = VEC_quick_push(constructor_elt, elts, empty);
elt->index = field;
elt->value = val;
if (!TREE_CONSTANT(val))
{
if (this->indexes_ != NULL)
go_assert(pi != this->indexes_->end());
- constructor_elt* elt = VEC_quick_push(constructor_elt, values, NULL);
+ constructor_elt empty = {NULL, NULL};
+ constructor_elt* elt = VEC_quick_push(constructor_elt, values, empty);
if (this->indexes_ == NULL)
elt->index = size_int(i);
if (constructor_type == error_mark_node)
return error_mark_node;
VEC(constructor_elt,gc)* vec = VEC_alloc(constructor_elt, gc, 1);
- constructor_elt* elt = VEC_quick_push(constructor_elt, vec, NULL);
+ constructor_elt empty = {NULL, NULL};
+ constructor_elt* elt = VEC_quick_push(constructor_elt, vec, empty);
elt->index = size_int(0);
Gogo* gogo = context->gogo();
Btype* btype = element_type->get_backend(gogo);
VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
- constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ constructor_elt empty = {NULL, NULL};
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, empty);
tree field = TYPE_FIELDS(type_tree);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
elt->index = field;
elt->value = fold_convert(TREE_TYPE(field), space);
- elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt = VEC_quick_push(constructor_elt, init, empty);
field = DECL_CHAIN(field);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
elt->index = field;
elt->value = fold_convert(TREE_TYPE(field), length_tree);
- elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt = VEC_quick_push(constructor_elt, init, empty);
field = DECL_CHAIN(field);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),"__capacity") == 0);
elt->index = field;
VEC(constructor_elt,gc)* one = VEC_alloc(constructor_elt, gc, 2);
- constructor_elt* elt = VEC_quick_push(constructor_elt, one, NULL);
+ constructor_elt empty = {NULL, NULL};
+ constructor_elt* elt = VEC_quick_push(constructor_elt, one, empty);
elt->index = key_field;
tree val_tree = (*pv)->get_tree(context);
elt->value = Expression::convert_for_assignment(context, key_type,
++pv;
- elt = VEC_quick_push(constructor_elt, one, NULL);
+ elt = VEC_quick_push(constructor_elt, one, empty);
elt->index = val_field;
val_tree = (*pv)->get_tree(context);
elt->value = Expression::convert_for_assignment(context, val_type,
if (!TREE_CONSTANT(elt->value))
one_is_constant = false;
- elt = VEC_quick_push(constructor_elt, values, NULL);
+ elt = VEC_quick_push(constructor_elt, values, empty);
elt->index = size_int(i);
elt->value = build_constructor(struct_type, one);
if (one_is_constant)
{
VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
- constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ constructor_elt empty = {NULL, NULL};
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, empty);
tree field = TYPE_FIELDS(root_type);
elt->index = field;
Bvariable* bvar = (*p)->get_backend_variable(this, NULL);
go_assert(TREE_CODE(decl) == VAR_DECL);
elt->value = build_fold_addr_expr(decl);
- elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt = VEC_quick_push(constructor_elt, init, empty);
field = DECL_CHAIN(field);
elt->index = field;
elt->value = DECL_SIZE_UNIT(decl);
- elt = VEC_quick_push(constructor_elt, roots_init, NULL);
+ elt = VEC_quick_push(constructor_elt, roots_init, empty);
elt->index = size_int(i);
elt->value = build_constructor(root_type, init);
}
VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
- constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ constructor_elt empty = {NULL, NULL};
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, empty);
tree field = TYPE_FIELDS(root_type);
elt->index = field;
elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
- elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt = VEC_quick_push(constructor_elt, init, empty);
field = DECL_CHAIN(field);
elt->index = field;
elt->value = size_zero_node;
- elt = VEC_quick_push(constructor_elt, roots_init, NULL);
+ elt = VEC_quick_push(constructor_elt, roots_init, empty);
elt->index = size_int(i);
elt->value = build_constructor(root_type, init);
VEC(constructor_elt,gc)* root_list_init = VEC_alloc(constructor_elt, gc, 2);
- elt = VEC_quick_push(constructor_elt, root_list_init, NULL);
+ elt = VEC_quick_push(constructor_elt, root_list_init, empty);
field = TYPE_FIELDS(root_list_type);
elt->index = field;
elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
- elt = VEC_quick_push(constructor_elt, root_list_init, NULL);
+ elt = VEC_quick_push(constructor_elt, root_list_init, empty);
field = DECL_CHAIN(field);
elt->index = field;
elt->value = build_constructor(array_type, roots_init);
VEC(constructor_elt, gc)* init = VEC_alloc(constructor_elt, gc, 2);
- constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ constructor_elt empty = {NULL, NULL};
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, empty);
tree field = TYPE_FIELDS(string_type);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__data") == 0);
elt->index = field;
elt->value = fold_convert(TREE_TYPE(field),
build_fold_addr_expr(str));
- elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt = VEC_quick_push(constructor_elt, init, empty);
field = DECL_CHAIN(field);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__length") == 0);
elt->index = field;
tree field = TYPE_FIELDS(slice_type_tree);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
- constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ constructor_elt empty = {NULL, NULL};
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, empty);
elt->index = field;
go_assert(TYPE_MAIN_VARIANT(TREE_TYPE(field))
== TYPE_MAIN_VARIANT(TREE_TYPE(values)));
field = DECL_CHAIN(field);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
- elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt = VEC_quick_push(constructor_elt, init, empty);
elt->index = field;
elt->value = fold_convert(TREE_TYPE(field), count);
field = DECL_CHAIN(field);
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__capacity") == 0);
- elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt = VEC_quick_push(constructor_elt, init, empty);
elt->index = field;
elt->value = fold_convert(TREE_TYPE(field), capacity);
count + 1);
// The first element is the type descriptor.
- constructor_elt* elt = VEC_quick_push(constructor_elt, pointers, NULL);
+ constructor_elt empty = {NULL, NULL};
+ constructor_elt* elt = VEC_quick_push(constructor_elt, pointers, empty);
elt->index = size_zero_node;
Type* td_type;
if (!is_pointer)
go_unreachable();
fndecl = build_fold_addr_expr(fndecl);
- elt = VEC_quick_push(constructor_elt, pointers, NULL);
+ elt = VEC_quick_push(constructor_elt, pointers, empty);
elt->index = size_int(i);
elt->value = fold_convert(const_ptr_type_node, fndecl);
}
if (e->flags & EDGE_TRUE_VALUE)
VEC_safe_push (gimple, heap, *cases, stmt);
else
- VEC_safe_push (gimple, heap, *cases, (gimple) NULL);
+ VEC_safe_push (gimple, heap, *cases, NULL);
}
gbb = gbb_from_bb (bb);
new_cond.agg_contents = agg_contents;
new_cond.by_ref = by_ref;
new_cond.offset = offset;
- VEC_safe_push (condition, gc, summary->conds, &new_cond);
+ VEC_safe_push (condition, gc, summary->conds, new_cond);
return single_cond_predicate (i + predicate_first_dynamic_condition);
}
new_entry.size = size;
new_entry.time = time;
new_entry.predicate = *pred;
- VEC_safe_push (size_time_entry, gc, summary->entry, &new_entry);
+ VEC_safe_push (size_time_entry, gc, summary->entry, new_entry);
}
else
{
c.by_ref = bp_unpack_value (&bp, 1);
if (c.agg_contents)
c.offset = streamer_read_uhwi (&ib);
- VEC_safe_push (condition, gc, info->conds, &c);
+ VEC_safe_push (condition, gc, info->conds, c);
}
count2 = streamer_read_uhwi (&ib);
gcc_assert (!info->entry);
e.time = streamer_read_uhwi (&ib);
e.predicate = read_predicate (&ib);
- VEC_safe_push (size_time_entry, gc, info->entry, &e);
+ VEC_safe_push (size_time_entry, gc, info->entry, e);
}
p = read_predicate (&ib);
{
if (list->constant)
{
- struct ipa_agg_jf_item *item;
- item = VEC_quick_push (ipa_agg_jf_item_t,
- jfunc->agg.items, NULL);
- item->offset = list->offset - arg_offset;
- item->value = list->constant;
+ struct ipa_agg_jf_item item;
+ item.offset = list->offset - arg_offset;
+ item.value = list->constant;
+ VEC_quick_push (ipa_agg_jf_item_t, jfunc->agg.items, item);
}
list = list->next;
}
if (n->remove_param)
removals++;
else
- VEC_quick_push (ipa_parm_adjustment_t, tmp, n);
+ VEC_quick_push (ipa_parm_adjustment_t, tmp, *n);
}
adjustments = VEC_alloc (ipa_parm_adjustment_t, heap, outlen + removals);
for (i = 0; i < outlen; i++)
{
- struct ipa_parm_adjustment *r;
+ struct ipa_parm_adjustment r;
struct ipa_parm_adjustment *out = &VEC_index (ipa_parm_adjustment_t,
outer, i);
struct ipa_parm_adjustment *in = &VEC_index (ipa_parm_adjustment_t, tmp,
out->base_index);
+ memset (&r, 0, sizeof (r));
gcc_assert (!in->remove_param);
if (out->remove_param)
{
if (!index_in_adjustments_multiple_times_p (in->base_index, tmp))
{
- r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
- memset (r, 0, sizeof (*r));
- r->remove_param = true;
+ r.remove_param = true;
+ VEC_quick_push (ipa_parm_adjustment_t, adjustments, r);
}
continue;
}
- r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
- memset (r, 0, sizeof (*r));
- r->base_index = in->base_index;
- r->type = out->type;
+ r.base_index = in->base_index;
+ r.type = out->type;
/* FIXME: Create nonlocal value too. */
if (in->copy_param && out->copy_param)
- r->copy_param = true;
+ r.copy_param = true;
else if (in->copy_param)
- r->offset = out->offset;
+ r.offset = out->offset;
else if (out->copy_param)
- r->offset = in->offset;
+ r.offset = in->offset;
else
- r->offset = in->offset + out->offset;
+ r.offset = in->offset + out->offset;
+ VEC_quick_push (ipa_parm_adjustment_t, adjustments, r);
}
for (i = 0; i < inlen; i++)
inner, i);
if (n->remove_param)
- VEC_quick_push (ipa_parm_adjustment_t, adjustments, n);
+ VEC_quick_push (ipa_parm_adjustment_t, adjustments, *n);
}
VEC_free (ipa_parm_adjustment_t, heap, tmp);
}
for (i = 0; i < count; i++)
{
- struct ipa_agg_jf_item *item = VEC_quick_push (ipa_agg_jf_item_t,
- jump_func->agg.items, NULL);
-
- item->offset = streamer_read_uhwi (ib);
- item->value = stream_read_tree (ib, data_in);
+ struct ipa_agg_jf_item item;
+ item.offset = streamer_read_uhwi (ib);
+ item.value = stream_read_tree (ib, data_in);
+ VEC_quick_push (ipa_agg_jf_item_t, jump_func->agg.items, item);
}
}
first.set_ssa_names = 0;
first.used_ssa_names = 0;
first.bbs_visited = 0;
- VEC_safe_push (stack_entry, heap, stack, &first);
+ VEC_safe_push (stack_entry, heap, stack, first);
ENTRY_BLOCK_PTR->aux = (void *)(intptr_t)-1;
while (!VEC_empty (stack_entry, stack))
new_entry.non_ssa_vars = BITMAP_ALLOC (NULL);
new_entry.can_split = true;
bitmap_set_bit (new_entry.bbs_visited, dest->index);
- VEC_safe_push (stack_entry, heap, stack, &new_entry);
+ VEC_safe_push (stack_entry, heap, stack, new_entry);
dest->aux = (void *)(intptr_t)VEC_length (stack_entry, stack);
}
/* Back edge found, record the earliest point. */
for (i = 0; i < count; i++)
{
- constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
- elt->index = build_int_cst (sizetype, i);
- elt->value = build_int_cstu (byte_type_node, data[i]);
+ constructor_elt elt;
+ elt.index = build_int_cst (sizetype, i);
+ elt.value = build_int_cstu (byte_type_node, data[i]);
+ VEC_quick_push (constructor_elt, v, elt);
}
DECL_INITIAL (array) = build_constructor (type, v);
{
method_entry *e;
unsigned i;
+ method_entry elem = {t, special};
FOR_EACH_VEC_ELT (method_entry, *symbol_table, i, e)
if (t == e->method && special == e->special)
goto done;
- e = VEC_safe_push (method_entry, gc, *symbol_table, NULL);
- e->method = t;
- e->special = special;
+ VEC_safe_push (method_entry, gc, *symbol_table, elem);
done:
return i + 1;
if (!slot)
slot = pointer_map_insert (encoder->map, node);
*slot = (void *) (intptr_t) (ref + 1);
- VEC_safe_push (lto_encoder_entry, heap, encoder->nodes, &entry);
+ VEC_safe_push (lto_encoder_entry, heap, encoder->nodes, entry);
}
else
ref = (size_t) *slot - 1;
decl = build_v2_class_reference_decl (ident);
e.ident = ident;
e.data = decl;
- VEC_safe_push (ident_data_tuple, gc, classrefs, &e);
+ VEC_safe_push (ident_data_tuple, gc, classrefs, e);
return decl;
}
e.func = message_func_decl;
e.selname = sel_name;
e.refdecl = decl;
- VEC_safe_push (msgref_entry, gc, msgrefs, &e);
+ VEC_safe_push (msgref_entry, gc, msgrefs, e);
return decl;
}
decl = build_v2_protocollist_ref_decl (ident);
e.id = ident;
e.refdecl = decl;
- VEC_safe_push (prot_list_entry, gc, protrefs, &e);
+ VEC_safe_push (prot_list_entry, gc, protrefs, e);
return decl;
}
decl = build_v2_superclass_ref_decl (id, inst_meth);
e.ident = id;
e.data = decl;
- VEC_safe_push (ident_data_tuple, gc, list, &e);
+ VEC_safe_push (ident_data_tuple, gc, list, e);
return decl;
}
protlist = VEC_alloc (prot_list_entry, gc, 32);
e.id = protocol_interface_decl;
e.refdecl = protocol_decl;
- VEC_safe_push (prot_list_entry, gc, protlist, &e);
+ VEC_safe_push (prot_list_entry, gc, protlist, e);
}
/* Build the __protocol_list section table containing address of all
e.decl = decl;
e.offset = byte_position (field_decl);
- VEC_safe_push (ivarref_entry, gc, ivar_offset_refs, &e);
+ VEC_safe_push (ivarref_entry, gc, ivar_offset_refs, e);
return decl;
}
/* Not found, or new list. */
e.ident = name;
e.data = NULL_TREE;
- VEC_safe_push (ident_data_tuple, gc, ehtype_list, &e);
+ VEC_safe_push (ident_data_tuple, gc, ehtype_list, e);
}
static void
{
VEC(cl_deferred_option,heap) *vec
= (VEC(cl_deferred_option,heap) *) *(void **) flag_var;
- cl_deferred_option *p;
-
- p = VEC_safe_push (cl_deferred_option, heap, vec, NULL);
- p->opt_index = opt_index;
- p->arg = arg;
- p->value = value;
+ cl_deferred_option p = {opt_index, arg, value};
+ VEC_safe_push (cl_deferred_option, heap, vec, p);
*(void **) flag_var = vec;
if (set_flag_var)
*(void **) set_flag_var = vec;
static void
record_iterator_use (struct mapping *iterator, void *ptr)
{
- struct iterator_use *iuse;
-
- iuse = VEC_safe_push (iterator_use, heap, iterator_uses, NULL);
- iuse->iterator = iterator;
- iuse->ptr = ptr;
+ struct iterator_use iuse = {iterator, ptr};
+ VEC_safe_push (iterator_use, heap, iterator_uses, iuse);
}
/* Record that PTR uses attribute VALUE, which must match a built-in
record_attribute_use (struct iterator_group *group, void *ptr,
const char *value)
{
- struct attribute_use *ause;
-
- ause = VEC_safe_push (attribute_use, heap, attribute_uses, NULL);
- ause->group = group;
- ause->value = value;
- ause->ptr = ptr;
+ struct attribute_use ause = {group, value, ptr};
+ VEC_safe_push (attribute_use, heap, attribute_uses, ause);
}
/* Interpret NAME as either a built-in value, iterator or attribute
/* Then add the candidate to the list and insert the reaching definitions
into the definition map. */
- cand = VEC_safe_push (ext_cand, heap, *insn_list, NULL);
- cand->expr = expr;
- cand->code = code;
- cand->mode = mode;
- cand->insn = insn;
+ ext_cand e = {expr, code, mode, insn};
+ VEC_safe_push (ext_cand, heap, *insn_list, e);
idx = VEC_length (ext_cand, *insn_list);
for (def = defs; def; def = def->next)
int old_size = VEC_length (reg_equivs_t, reg_equivs);
int max_regno = max_reg_num ();
int i;
+ reg_equivs_t ze;
+ memset (&ze, 0, sizeof (reg_equivs_t));
VEC_reserve (reg_equivs_t, gc, reg_equivs, max_regno);
for (i = old_size; i < max_regno; i++)
- {
- VEC_quick_insert (reg_equivs_t, reg_equivs, i, 0);
- memset (&VEC_index (reg_equivs_t, reg_equivs, i), 0,
- sizeof (reg_equivs_t));
- }
-
+ VEC_quick_insert (reg_equivs_t, reg_equivs, i, ze);
}
\f
vinsn_attach (old_expr_vinsn);
vinsn_attach (new_expr_vinsn);
- VEC_safe_insert (expr_history_def, heap, vect, ind, &temp);
+ VEC_safe_insert (expr_history_def, heap, vect, ind, temp);
*pvect = vect;
}
{
/* Now push a separator. */
if (domain.has_lb)
- VEC_quick_push (gimple, conds, (gimple)NULL);
+ VEC_quick_push (gimple, conds, NULL);
gen_one_condition (arg, domain.ub,
(domain.is_ub_inclusive
type is integer. */
/* Push a separator. */
- VEC_quick_push (gimple, conds, (gimple)NULL);
+ VEC_quick_push (gimple, conds, NULL);
temp = create_tmp_var (int_type, "DCE_COND1");
cst0 = build_int_cst (int_type, 0);
get_references_in_stmt (gimple stmt, VEC (data_ref_loc, heap) **references)
{
bool clobbers_memory = false;
- data_ref_loc *ref;
+ data_ref_loc ref;
tree *op0, *op1;
enum gimple_code stmt_code = gimple_code (stmt);
&& (base = get_base_address (*op1))
&& TREE_CODE (base) != SSA_NAME))
{
- ref = VEC_safe_push (data_ref_loc, heap, *references, NULL);
- ref->pos = op1;
- ref->is_read = true;
+ ref.pos = op1;
+ ref.is_read = true;
+ VEC_safe_push (data_ref_loc, heap, *references, ref);
}
}
else if (stmt_code == GIMPLE_CALL)
if (DECL_P (*op1)
|| (REFERENCE_CLASS_P (*op1) && get_base_address (*op1)))
{
- ref = VEC_safe_push (data_ref_loc, heap, *references, NULL);
- ref->pos = op1;
- ref->is_read = true;
+ ref.pos = op1;
+ ref.is_read = true;
+ VEC_safe_push (data_ref_loc, heap, *references, ref);
}
}
}
&& (DECL_P (*op0)
|| (REFERENCE_CLASS_P (*op0) && get_base_address (*op0))))
{
- ref = VEC_safe_push (data_ref_loc, heap, *references, NULL);
- ref->pos = op0;
- ref->is_read = false;
+ ref.pos = op0;
+ ref.is_read = false;
+ VEC_safe_push (data_ref_loc, heap, *references, ref);
}
return clobbers_memory;
}
return NULL_TREE;
nt.t = *tp;
nt.num = VEC_length (numbered_tree, *list);
- VEC_safe_push (numbered_tree, heap, *list, &nt);
+ VEC_safe_push (numbered_tree, heap, *list, nt);
*walk_subtrees = 0;
return NULL_TREE;
}
loc.where = where;
loc.map = map;
- VEC_safe_push (loc_map_pair, heap, loc_vec, &loc);
+ VEC_safe_push (loc_map_pair, heap, loc_vec, loc);
/* WHERE is the location of a token inside the expansion of a
macro. MAP is the map holding the locations of that macro
default_emutls_var_init (tree to, tree decl, tree proxy)
{
VEC(constructor_elt,gc) *v = VEC_alloc (constructor_elt, gc, 4);
- constructor_elt *elt;
+ constructor_elt elt;
tree type = TREE_TYPE (to);
tree field = TYPE_FIELDS (type);
- elt = VEC_quick_push (constructor_elt, v, NULL);
- elt->index = field;
- elt->value = fold_convert (TREE_TYPE (field), DECL_SIZE_UNIT (decl));
+ elt.index = field;
+ elt.value = fold_convert (TREE_TYPE (field), DECL_SIZE_UNIT (decl));
+ VEC_quick_push (constructor_elt, v, elt);
- elt = VEC_quick_push (constructor_elt, v, NULL);
field = DECL_CHAIN (field);
- elt->index = field;
- elt->value = build_int_cst (TREE_TYPE (field),
- DECL_ALIGN_UNIT (decl));
+ elt.index = field;
+ elt.value = build_int_cst (TREE_TYPE (field),
+ DECL_ALIGN_UNIT (decl));
+ VEC_quick_push (constructor_elt, v, elt);
- elt = VEC_quick_push (constructor_elt, v, NULL);
field = DECL_CHAIN (field);
- elt->index = field;
- elt->value = null_pointer_node;
+ elt.index = field;
+ elt.value = null_pointer_node;
+ VEC_quick_push (constructor_elt, v, elt);
- elt = VEC_quick_push (constructor_elt, v, NULL);
field = DECL_CHAIN (field);
- elt->index = field;
- elt->value = proxy;
+ elt.index = field;
+ elt.value = proxy;
+ VEC_quick_push (constructor_elt, v, elt);
return build_constructor (type, v);
}
result = UNUSED_PARAMS;
}
else
- VEC_quick_push (access_p, *representatives, (access_p) NULL);
+ VEC_quick_push (access_p, *representatives, NULL);
}
if (result == NO_GOOD_ACCESS)
if (!repr || no_accesses_p (repr))
{
- struct ipa_parm_adjustment *adj;
+ struct ipa_parm_adjustment adj;
- adj = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
- memset (adj, 0, sizeof (*adj));
- adj->base_index = get_param_index (parm, parms);
- adj->base = parm;
+ memset (&adj, 0, sizeof (adj));
+ adj.base_index = get_param_index (parm, parms);
+ adj.base = parm;
if (!repr)
- adj->copy_param = 1;
+ adj.copy_param = 1;
else
- adj->remove_param = 1;
+ adj.remove_param = 1;
+ VEC_quick_push (ipa_parm_adjustment_t, adjustments, adj);
}
else
{
- struct ipa_parm_adjustment *adj;
+ struct ipa_parm_adjustment adj;
int index = get_param_index (parm, parms);
for (; repr; repr = repr->next_grp)
{
- adj = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
- memset (adj, 0, sizeof (*adj));
+ memset (&adj, 0, sizeof (adj));
gcc_assert (repr->base == parm);
- adj->base_index = index;
- adj->base = repr->base;
- adj->type = repr->type;
- adj->alias_ptr_type = reference_alias_ptr_type (repr->expr);
- adj->offset = repr->offset;
- adj->by_ref = (POINTER_TYPE_P (TREE_TYPE (repr->base))
- && (repr->grp_maybe_modified
- || repr->grp_not_necessarilly_dereferenced));
-
+ adj.base_index = index;
+ adj.base = repr->base;
+ adj.type = repr->type;
+ adj.alias_ptr_type = reference_alias_ptr_type (repr->expr);
+ adj.offset = repr->offset;
+ adj.by_ref = (POINTER_TYPE_P (TREE_TYPE (repr->base))
+ && (repr->grp_maybe_modified
+ || repr->grp_not_necessarilly_dereferenced));
+ VEC_quick_push (ipa_parm_adjustment_t, adjustments, adj);
}
}
}
cond->ops.binary.opnd1 = op1;
c.value = boolean_true_node;
- VEC_safe_push (cond_equivalence, heap, *p, &c);
+ VEC_safe_push (cond_equivalence, heap, *p, c);
}
/* Record that COND is true and INVERTED is false into the edge information
two slots. */
initialize_expr_from_cond (cond, &c.cond);
c.value = boolean_true_node;
- VEC_safe_push (cond_equivalence, heap, edge_info->cond_equivalences, &c);
+ VEC_safe_push (cond_equivalence, heap, edge_info->cond_equivalences, c);
/* It is possible for INVERTED to be the negation of a comparison,
and not a valid RHS or GIMPLE_COND condition. This happens because
obey the trichotomy law. */
initialize_expr_from_cond (inverted, &c.cond);
c.value = boolean_false_node;
- VEC_safe_push (cond_equivalence, heap, edge_info->cond_equivalences, &c);
+ VEC_safe_push (cond_equivalence, heap, edge_info->cond_equivalences, c);
}
/* A helper function for record_const_or_copy and record_equality.
next_expression_id = 1;
expressions = NULL;
- VEC_safe_push (pre_expr, heap, expressions, (pre_expr)NULL);
+ VEC_safe_push (pre_expr, heap, expressions, NULL);
value_expressions = VEC_alloc (bitmap, heap, get_max_value_id () + 1);
VEC_safe_grow_cleared (bitmap, heap, value_expressions,
get_max_value_id() + 1);
c.cnt = 1;
c.id = next_oecount_id++;
c.op = oe1->op;
- VEC_safe_push (oecount, heap, cvec, &c);
+ VEC_safe_push (oecount, heap, cvec, c);
idx = VEC_length (oecount, cvec) + 41;
slot = htab_find_slot (ctable, (void *)idx, INSERT);
if (!*slot)
rfnew.rank = oe->rank;
rfnew.count = oe->count;
rfnew.repr = NULL_TREE;
- VEC_safe_push (repeat_factor, heap, repeat_factor_vec, &rfnew);
+ VEC_safe_push (repeat_factor, heap, repeat_factor_vec, rfnew);
}
}
}
temp.op1 = TMR_STEP (ref);
temp.op2 = TMR_OFFSET (ref);
temp.off = -1;
- VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
+ VEC_safe_push (vn_reference_op_s, heap, *result, temp);
memset (&temp, 0, sizeof (temp));
temp.type = NULL_TREE;
temp.opcode = ERROR_MARK;
temp.op0 = TMR_INDEX2 (ref);
temp.off = -1;
- VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
+ VEC_safe_push (vn_reference_op_s, heap, *result, temp);
memset (&temp, 0, sizeof (temp));
temp.type = NULL_TREE;
temp.opcode = TREE_CODE (TMR_BASE (ref));
temp.op0 = TMR_BASE (ref);
temp.off = -1;
- VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
+ VEC_safe_push (vn_reference_op_s, heap, *result, temp);
return;
}
temp.opcode = MEM_REF;
temp.op0 = build_int_cst (build_pointer_type (TREE_TYPE (ref)), 0);
temp.off = 0;
- VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
+ VEC_safe_push (vn_reference_op_s, heap, *result, temp);
temp.opcode = ADDR_EXPR;
temp.op0 = build_fold_addr_expr (ref);
temp.type = TREE_TYPE (temp.op0);
default:
gcc_unreachable ();
}
- VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
+ VEC_safe_push (vn_reference_op_s, heap, *result, temp);
if (REFERENCE_CLASS_P (ref)
|| TREE_CODE (ref) == MODIFY_EXPR
temp.type = TREE_TYPE (lhs);
temp.op0 = lhs;
temp.off = -1;
- VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
+ VEC_safe_push (vn_reference_op_s, heap, *result, temp);
}
/* Copy the type, opcode, function being called and static chain. */
temp.op0 = gimple_call_fn (call);
temp.op1 = gimple_call_chain (call);
temp.off = -1;
- VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
+ VEC_safe_push (vn_reference_op_s, heap, *result, temp);
/* Copy the call arguments. As they can be references as well,
just chain them together. */
{
/* Recurse by pushing the current use walking state on
the stack and starting over. */
- VEC_safe_push(ssa_op_iter, heap, itervec, &iter);
+ VEC_safe_push(ssa_op_iter, heap, itervec, iter);
VEC_safe_push(tree, heap, namevec, name);
name = use;
goto start_over;
arbitrary, but consistent, in order to give them an ordering. */
static bool
-constraint_less (const constraint_t a, const constraint_t b)
+constraint_less (const constraint_t &a, const constraint_t &b)
{
if (constraint_expr_less (a->lhs, b->lhs))
return true;
for (; vi; vi = vi->next)
{
cexpr.var = vi->id;
- VEC_safe_push (ce_s, heap, *results, &cexpr);
+ VEC_safe_push (ce_s, heap, *results, cexpr);
}
return;
}
- VEC_safe_push (ce_s, heap, *results, &cexpr);
+ VEC_safe_push (ce_s, heap, *results, cexpr);
}
/* Process constraint T, performing various simplifications and then
c2.type = ADDRESSOF;
c2.offset = 0;
if (c2.var != c.var)
- VEC_safe_push (ce_s, heap, *results, &c2);
+ VEC_safe_push (ce_s, heap, *results, c2);
temp = temp->next;
}
while (temp);
c2.var = temp->next->id;
c2.type = ADDRESSOF;
c2.offset = 0;
- VEC_safe_push (ce_s, heap, *results, &c2);
+ VEC_safe_push (ce_s, heap, *results, c2);
}
c.var = temp->id;
c.offset = 0;
temp.offset = 0;
temp.var = integer_id;
temp.type = SCALAR;
- VEC_safe_push (ce_s, heap, *results, &temp);
+ VEC_safe_push (ce_s, heap, *results, temp);
return;
}
temp.offset = 0;
temp.var = anything_id;
temp.type = ADDRESSOF;
- VEC_safe_push (ce_s, heap, *results, &temp);
+ VEC_safe_push (ce_s, heap, *results, temp);
return;
}
}
bitpos, bitmaxsize))
{
cexpr.var = curr->id;
- VEC_safe_push (ce_s, heap, *results, &cexpr);
+ VEC_safe_push (ce_s, heap, *results, cexpr);
if (address_p)
break;
}
while (curr->next != NULL)
curr = curr->next;
cexpr.var = curr->id;
- VEC_safe_push (ce_s, heap, *results, &cexpr);
+ VEC_safe_push (ce_s, heap, *results, cexpr);
}
else if (VEC_length (ce_s, *results) == 0)
/* Assert that we found *some* field there. The user couldn't be
cexpr.type = SCALAR;
cexpr.var = anything_id;
cexpr.offset = 0;
- VEC_safe_push (ce_s, heap, *results, &cexpr);
+ VEC_safe_push (ce_s, heap, *results, cexpr);
}
}
else if (bitmaxsize == 0)
temp.var = nonlocal_id;
temp.type = ADDRESSOF;
temp.offset = 0;
- VEC_safe_push (ce_s, heap, *results, &temp);
+ VEC_safe_push (ce_s, heap, *results, temp);
return;
}
temp.var = readonly_id;
temp.type = SCALAR;
temp.offset = 0;
- VEC_safe_push (ce_s, heap, *results, &temp);
+ VEC_safe_push (ce_s, heap, *results, temp);
return;
}
if (curr->offset - vi->offset < size)
{
cs.var = curr->id;
- VEC_safe_push (ce_s, heap, *results, &cs);
+ VEC_safe_push (ce_s, heap, *results, cs);
}
else
break;
unsigned j;
get_constraint_for_1 (val, &tmp, address_p, lhs_p);
FOR_EACH_VEC_ELT (ce_s, tmp, j, rhsp)
- VEC_safe_push (ce_s, heap, *results, rhsp);
+ VEC_safe_push (ce_s, heap, *results, *rhsp);
VEC_truncate (ce_s, tmp, 0);
}
VEC_free (ce_s, heap, tmp);
temp.type = ADDRESSOF;
temp.var = nonlocal_id;
temp.offset = 0;
- VEC_safe_push (ce_s, heap, *results, &temp);
+ VEC_safe_push (ce_s, heap, *results, temp);
return;
}
default:;
temp.type = ADDRESSOF;
temp.var = anything_id;
temp.offset = 0;
- VEC_safe_push (ce_s, heap, *results, &temp);
+ VEC_safe_push (ce_s, heap, *results, temp);
}
/* Given a gimple tree T, return the constraint expression vector for it. */
rhsc.var = get_call_use_vi (stmt)->id;
rhsc.offset = 0;
rhsc.type = SCALAR;
- VEC_safe_push (ce_s, heap, *results, &rhsc);
+ VEC_safe_push (ce_s, heap, *results, rhsc);
}
/* The static chain escapes as well. */
rhsc.var = nonlocal_id;
rhsc.offset = 0;
rhsc.type = SCALAR;
- VEC_safe_push (ce_s, heap, *results, &rhsc);
+ VEC_safe_push (ce_s, heap, *results, rhsc);
}
/* For non-IPA mode, generate constraints necessary for a call
tmpc.var = escaped_id;
tmpc.offset = 0;
tmpc.type = SCALAR;
- VEC_safe_push (ce_s, heap, lhsc, &tmpc);
+ VEC_safe_push (ce_s, heap, lhsc, tmpc);
}
/* If the call returns an argument unmodified override the rhs
tmpc.var = vi->id;
tmpc.offset = 0;
tmpc.type = ADDRESSOF;
- VEC_safe_push (ce_s, heap, rhsc, &tmpc);
+ VEC_safe_push (ce_s, heap, rhsc, tmpc);
process_all_all_constraints (lhsc, rhsc);
VEC_free (ce_s, heap, rhsc);
}
rhsc.var = uses->id;
rhsc.offset = 0;
rhsc.type = SCALAR;
- VEC_safe_push (ce_s, heap, *results, &rhsc);
+ VEC_safe_push (ce_s, heap, *results, rhsc);
}
/* May return arguments. */
struct constraint_expr *argp;
get_constraint_for_rhs (arg, &argc);
FOR_EACH_VEC_ELT (ce_s, argc, i, argp)
- VEC_safe_push (ce_s, heap, *results, argp);
+ VEC_safe_push (ce_s, heap, *results, *argp);
VEC_free(ce_s, heap, argc);
}
rhsc.var = nonlocal_id;
rhsc.offset = 0;
rhsc.type = ADDRESSOF;
- VEC_safe_push (ce_s, heap, *results, &rhsc);
+ VEC_safe_push (ce_s, heap, *results, rhsc);
}
/* For non-IPA mode, generate constraints necessary for a call to a
rhsc.var = uses->id;
rhsc.offset = 0;
rhsc.type = SCALAR;
- VEC_safe_push (ce_s, heap, *results, &rhsc);
+ VEC_safe_push (ce_s, heap, *results, rhsc);
}
rhsc.var = nonlocal_id;
rhsc.offset = 0;
rhsc.type = SCALAR;
- VEC_safe_push (ce_s, heap, *results, &rhsc);
+ VEC_safe_push (ce_s, heap, *results, rhsc);
}
&& DECL_BY_REFERENCE (DECL_RESULT (fndecl)))
{
VEC(ce_s, heap) *tem = NULL;
- VEC_safe_push (ce_s, heap, tem, &rhs);
+ VEC_safe_push (ce_s, heap, tem, rhs);
do_deref (&tem);
rhs = VEC_index (ce_s, tem, 0);
VEC_free(ce_s, heap, tem);
get_constraint_for_rhs (gimple_assign_rhs2 (t), &rhsc);
get_constraint_for_rhs (gimple_assign_rhs3 (t), &tmp);
FOR_EACH_VEC_ELT (ce_s, tmp, i, rhsp)
- VEC_safe_push (ce_s, heap, rhsc, rhsp);
+ VEC_safe_push (ce_s, heap, rhsc, *rhsp);
VEC_free (ce_s, heap, tmp);
}
else if (truth_value_p (code))
{
get_constraint_for_rhs (gimple_op (t, i), &tmp);
FOR_EACH_VEC_ELT (ce_s, tmp, j, rhsp)
- VEC_safe_push (ce_s, heap, rhsc, rhsp);
+ VEC_safe_push (ce_s, heap, rhsc, *rhsp);
VEC_truncate (ce_s, tmp, 0);
}
VEC_free (ce_s, heap, tmp);
if (!pair
&& offset + foff != 0)
{
- pair = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
- pair->offset = 0;
- pair->size = offset + foff;
- pair->has_unknown_size = false;
- pair->must_have_pointers = false;
- pair->may_have_pointers = false;
- pair->only_restrict_pointers = false;
+ fieldoff_s e = {0, offset + foff, false, false, false, false};
+ pair = VEC_safe_push (fieldoff_s, heap, *fieldstack, e);
}
if (!DECL_SIZE (field)
}
else
{
- pair = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
- pair->offset = offset + foff;
- pair->has_unknown_size = has_unknown_size;
+ fieldoff_s e;
+ e.offset = offset + foff;
+ e.has_unknown_size = has_unknown_size;
if (!has_unknown_size)
- pair->size = TREE_INT_CST_LOW (DECL_SIZE (field));
+ e.size = TREE_INT_CST_LOW (DECL_SIZE (field));
else
- pair->size = -1;
- pair->must_have_pointers = must_have_pointers_p;
- pair->may_have_pointers = true;
- pair->only_restrict_pointers
+ e.size = -1;
+ e.must_have_pointers = must_have_pointers_p;
+ e.may_have_pointers = true;
+ e.only_restrict_pointers
= (!has_unknown_size
&& POINTER_TYPE_P (TREE_TYPE (field))
&& TYPE_RESTRICT (TREE_TYPE (field)));
+ VEC_safe_push (fieldoff_s, heap, *fieldstack, e);
}
}
new_node.result = result;
new_node.locus = locus;
- VEC_safe_push (edge_var_map, heap, head, &new_node);
+ VEC_safe_push (edge_var_map, heap, head, new_node);
if (old_head != head)
{
/* The push did some reallocation. Update the pointer map. */
int k;
for (k = 0; k < info->phi_count; k++)
{
- constructor_elt *elt;
+ constructor_elt elt;
- elt = VEC_quick_push (constructor_elt,
- info->constructors[k], NULL);
- elt->index = int_const_binop (MINUS_EXPR, pos,
- info->range_min);
- elt->value = info->default_values[k];
+ elt.index = int_const_binop (MINUS_EXPR, pos, info->range_min);
+ elt.value = info->default_values[k];
+ VEC_quick_push (constructor_elt, info->constructors[k], elt);
}
pos = int_const_binop (PLUS_EXPR, pos, integer_one_node);
do
{
- constructor_elt *elt;
+ constructor_elt elt;
- elt = VEC_quick_push (constructor_elt,
- info->constructors[j], NULL);
- elt->index = int_const_binop (MINUS_EXPR, pos, info->range_min);
- elt->value = val;
+ elt.index = int_const_binop (MINUS_EXPR, pos, info->range_min);
+ elt.value = val;
+ VEC_quick_push (constructor_elt, info->constructors[j], elt);
pos = int_const_binop (PLUS_EXPR, pos, integer_one_node);
} while (!tree_int_cst_lt (high, pos)
i += delta, index = int_const_binop (PLUS_EXPR, index, part_width))
{
tree result = f (gsi, inner_type, a, b, index, part_width, code);
- constructor_elt *ce = VEC_quick_push (constructor_elt, v, NULL);
- ce->index = NULL_TREE;
- ce->value = result;
+ constructor_elt ce = {NULL_TREE, result};
+ VEC_quick_push (constructor_elt, v, ce);
}
return build_constructor (type, v);
ai.bb = bb;
if (adjust_vec)
- VEC_safe_push (adjust_info, stack, adjust_vec, &ai);
+ VEC_safe_push (adjust_info, stack, adjust_vec, ai);
else
adjust_debug_stmts_now (&ai);
}
tmp_stmts = VEC_alloc (gimple, heap, group_size);
for (i = 0; i < group_size; i++)
- VEC_safe_push (gimple, heap, tmp_stmts, (gimple)NULL);
+ VEC_safe_push (gimple, heap, tmp_stmts, NULL);
FOR_EACH_VEC_ELT (gimple, SLP_TREE_SCALAR_STMTS (node), i, stmt)
{
stmts later. */
for (i = VEC_length (gimple, SLP_TREE_VEC_STMTS (node));
i < (int) SLP_TREE_NUMBER_OF_VEC_STMTS (node); i++)
- VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (node), (gimple)NULL);
+ VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (node), NULL);
perm_dest = vect_create_destination_var (gimple_assign_lhs (stmt), vectype);
for (i = 0; i < ncopies; i++)
si.kind = kind;
si.stmt = stmt;
si.misalign = misalign;
- VEC_safe_push (stmt_info_for_cost, heap, *stmt_cost_vec, &si);
+ VEC_safe_push (stmt_info_for_cost, heap, *stmt_cost_vec, si);
}
/************************************************************************
/* And queue an update for the stmt. */
su.stmt = stmt;
su.vec = vec2;
- VEC_safe_push (switch_update, heap, to_update_switch_stmts, &su);
+ VEC_safe_push (switch_update, heap, to_update_switch_stmts, su);
return false;
}
build_constructor_single (tree type, tree index, tree value)
{
VEC(constructor_elt,gc) *v;
- constructor_elt *elt;
+ constructor_elt elt = {index, value};
v = VEC_alloc (constructor_elt, gc, 1);
- elt = VEC_quick_push (constructor_elt, v, NULL);
- elt->index = index;
- elt->value = value;
+ VEC_quick_push (constructor_elt, v, elt);
return build_constructor (type, v);
}
/* Append a new constructor element to V, with the specified INDEX and VAL. */
#define CONSTRUCTOR_APPEND_ELT(V, INDEX, VALUE) \
do { \
- constructor_elt *_ce___ = VEC_safe_push (constructor_elt, gc, V, NULL); \
- _ce___->index = INDEX; \
- _ce___->value = VALUE; \
+ constructor_elt _ce___ = {INDEX, VALUE}; \
+ VEC_safe_push (constructor_elt, gc, V, _ce___); \
} while (0)
/* True if NODE, a FIELD_DECL, is to be processed as a bitfield for
if (dump_file && (dump_flags & TDF_DETAILS))
log_op_type (mo.u.loc, cui->bb, cui->insn, mo.type, dump_file);
- VEC_safe_push (micro_operation, heap, VTI (bb)->mos, &mo);
+ VEC_safe_push (micro_operation, heap, VTI (bb)->mos, mo);
}
return 0;
if (dump_file && (dump_flags & TDF_DETAILS))
log_op_type (moa.u.loc, cui->bb, cui->insn,
moa.type, dump_file);
- VEC_safe_push (micro_operation, heap, VTI (bb)->mos, &moa);
+ VEC_safe_push (micro_operation, heap, VTI (bb)->mos, moa);
}
resolve = false;
log_and_return:
if (dump_file && (dump_flags & TDF_DETAILS))
log_op_type (mo.u.loc, cui->bb, cui->insn, mo.type, dump_file);
- VEC_safe_push (micro_operation, heap, VTI (bb)->mos, &mo);
+ VEC_safe_push (micro_operation, heap, VTI (bb)->mos, mo);
}
/* Arguments to the call. */
if (dump_file && (dump_flags & TDF_DETAILS))
log_op_type (PATTERN (insn), bb, insn, mo.type, dump_file);
- VEC_safe_push (micro_operation, heap, VTI (bb)->mos, &mo);
+ VEC_safe_push (micro_operation, heap, VTI (bb)->mos, mo);
}
n1 = VEC_length (micro_operation, VTI (bb)->mos);
led = (loc_exp_dep *) pool_alloc (loc_exp_dep_pool);
else
{
- VEC_quick_push (loc_exp_dep, VAR_LOC_DEP_VEC (var), NULL);
+ loc_exp_dep empty;
+ memset (&empty, 0, sizeof (empty));
+ VEC_quick_push (loc_exp_dep, VAR_LOC_DEP_VEC (var), empty);
led = &VEC_last (loc_exp_dep, VAR_LOC_DEP_VEC (var));
}
led->dv = var->dv;
log_op_type (PATTERN (insn), bb, insn,
MO_ADJUST, dump_file);
VEC_safe_push (micro_operation, heap, VTI (bb)->mos,
- &mo);
+ mo);
VTI (bb)->out.stack_adjust += pre;
}
}
log_op_type (PATTERN (insn), bb, insn,
MO_ADJUST, dump_file);
VEC_safe_push (micro_operation, heap, VTI (bb)->mos,
- &mo);
+ mo);
VTI (bb)->out.stack_adjust += post;
}
CONSTRUCTOR_ELTS (exp)));
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (exp), idx, purpose, value)
{
- constructor_elt *ce = VEC_quick_push (constructor_elt, v, NULL);
- ce->index = purpose;
- ce->value = copy_constant (value);
+ constructor_elt ce = {purpose, copy_constant (value)};
+ VEC_quick_push (constructor_elt, v, ce);
}
CONSTRUCTOR_ELTS (copy) = v;
return copy;
do_assemble_alias (decl, target);
else
{
- alias_pair *p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
- p->decl = decl;
- p->target = target;
+ alias_pair p = {decl, target};
+ VEC_safe_push (alias_pair, gc, alias_pairs, p);
}
}
dump_tm_clone_to_vec (void **slot, void *info)
{
struct tree_map *map = (struct tree_map *) *slot;
- VEC(tm_alias_pair,heap) **tm_alias_pairs
- = (VEC(tm_alias_pair, heap) **) info;
- tm_alias_pair *p;
-
- p = VEC_safe_push (tm_alias_pair, heap, *tm_alias_pairs, NULL);
- p->from = map->base.from;
- p->to = map->to;
- p->uid = DECL_UID (p->from);
+ VEC(tm_alias_pair,heap) **tm_alias_pairs = (VEC(tm_alias_pair, heap) **) info;
+ tm_alias_pair p = {DECL_UID (map->base.from), map->base.from, map->to};
+ VEC_safe_push (tm_alias_pair, heap, *tm_alias_pairs, p);
return 1;
}
bool space (int VEC_CHECK_DECL);
void splice (vec_t<T> * VEC_CHECK_DECL);
- T &quick_push (T VEC_CHECK_DECL);
- T *quick_push (const T * VEC_CHECK_DECL);
+ T *quick_push (const T & VEC_CHECK_DECL);
T &pop (ALONE_VEC_CHECK_DECL);
void truncate (unsigned VEC_CHECK_DECL);
- void replace (unsigned, T VEC_CHECK_DECL);
- void quick_insert (unsigned, T VEC_CHECK_DECL);
- void quick_insert (unsigned, const T * VEC_CHECK_DECL);
+ void replace (unsigned, const T & VEC_CHECK_DECL);
+ void quick_insert (unsigned, const T & VEC_CHECK_DECL);
void ordered_remove (unsigned VEC_CHECK_DECL);
void unordered_remove (unsigned VEC_CHECK_DECL);
void block_remove (unsigned, unsigned VEC_CHECK_DECL);
-
- unsigned lower_bound (T, bool (*)(T, T)) const;
- unsigned lower_bound (const T *, bool (*)(const T *, const T *)) const;
+ unsigned lower_bound (T, bool (*)(const T &, const T &)) const;
/* Class-static member functions. Some of these will become member
functions of a future handler class wrapping vec_t. */
MEM_STAT_DECL);
template<enum vec_allocation_t A>
- static T &safe_push (vec_t<T> **, T VEC_CHECK_DECL MEM_STAT_DECL);
-
- template<enum vec_allocation_t A>
- static T *safe_push (vec_t<T> **, const T * VEC_CHECK_DECL MEM_STAT_DECL);
+ static T *safe_push (vec_t<T> **, const T & VEC_CHECK_DECL MEM_STAT_DECL);
template<enum vec_allocation_t A>
static void safe_grow (vec_t<T> **, int VEC_CHECK_DECL MEM_STAT_DECL);
static void safe_grow_cleared (vec_t<T> **, int VEC_CHECK_DECL MEM_STAT_DECL);
template<enum vec_allocation_t A>
- static void safe_insert (vec_t<T> **, unsigned, T * VEC_CHECK_DECL
- MEM_STAT_DECL);
-
- template<enum vec_allocation_t A>
- static void safe_insert (vec_t<T> **, unsigned, T obj VEC_CHECK_DECL
+ static void safe_insert (vec_t<T> **, unsigned, const T & VEC_CHECK_DECL
MEM_STAT_DECL);
static bool iterate (const vec_t<T> *, unsigned, T *);
}
-/* Push OBJ (a new element) onto the end, returns a reference to the slot
- filled in. There must be sufficient space in the vector. */
-
-template<typename T>
-T &
-vec_t<T>::quick_push (T obj VEC_CHECK_DECL)
-{
- VEC_ASSERT (prefix_.num_ < prefix_.alloc_, "push", T, base);
- vec_[prefix_.num_] = obj;
- T &val = vec_[prefix_.num_];
- prefix_.num_++;
- return val;
-}
+/* Push OBJ (a new element) onto the end of the vector. There must be
+ sufficient space in the vector. Return a pointer to the slot
+ where OBJ was inserted. */
-/* Push PTR (a new pointer to an element) onto the end, returns a
- pointer to the slot filled in. The new value can be NULL, in which
- case NO initialization is performed. There must be sufficient
- space in the vector. */
-
template<typename T>
T *
-vec_t<T>::quick_push (const T *ptr VEC_CHECK_DECL)
+vec_t<T>::quick_push (const T &obj VEC_CHECK_DECL)
{
VEC_ASSERT (prefix_.num_ < prefix_.alloc_, "push", T, base);
T *slot = &vec_[prefix_.num_++];
- if (ptr)
- *slot = *ptr;
+ *slot = obj;
return slot;
}
-/* Push a new element OBJ onto the end of VEC. Returns a reference to
- the slot filled in. Reallocates V, if needed. */
-
-template<typename T>
-template<enum vec_allocation_t A>
-T &
-vec_t<T>::safe_push (vec_t<T> **vec, T obj VEC_CHECK_DECL MEM_STAT_DECL)
-{
- reserve<A> (vec, 1 VEC_CHECK_PASS PASS_MEM_STAT);
- return (*vec)->quick_push (obj VEC_CHECK_PASS);
-}
-
-
-/* Push a pointer PTR to a new element onto the end of VEC. Returns a
- pointer to the slot filled in. For object vectors, the new value
- can be NULL, in which case NO initialization is performed.
- Reallocates VEC, if needed. */
+/* Push a new element OBJ onto the end of VEC. Reallocates VEC, if
+ needed. Return a pointer to the slot where OBJ was inserted. */
template<typename T>
template<enum vec_allocation_t A>
T *
-vec_t<T>::safe_push (vec_t<T> **vec, const T *ptr VEC_CHECK_DECL MEM_STAT_DECL)
+vec_t<T>::safe_push (vec_t<T> **vec, const T &obj VEC_CHECK_DECL MEM_STAT_DECL)
{
reserve<A> (vec, 1 VEC_CHECK_PASS PASS_MEM_STAT);
- return (*vec)->quick_push (ptr VEC_CHECK_PASS);
+ return (*vec)->quick_push (obj VEC_CHECK_PASS);
}
template<typename T>
void
-vec_t<T>::replace (unsigned ix, T obj VEC_CHECK_DECL)
+vec_t<T>::replace (unsigned ix, const T &obj VEC_CHECK_DECL)
{
VEC_ASSERT (ix < prefix_.num_, "replace", T, base);
vec_[ix] = obj;
template<typename T>
void
-vec_t<T>::quick_insert (unsigned ix, T obj VEC_CHECK_DECL)
+vec_t<T>::quick_insert (unsigned ix, const T &obj VEC_CHECK_DECL)
{
VEC_ASSERT (prefix_.num_ < prefix_.alloc_, "insert", T, base);
VEC_ASSERT (ix <= prefix_.num_, "insert", T, base);
}
-/* Insert an element, *PTR, at the IXth position of V. The new value
- can be NULL, in which case no initialization of the inserted slot
- takes place. There must be sufficient space. */
-
-template<typename T>
-void
-vec_t<T>::quick_insert (unsigned ix, const T *ptr VEC_CHECK_DECL)
-{
- VEC_ASSERT (prefix_.num_ < prefix_.alloc_, "insert", T, base);
- VEC_ASSERT (ix <= prefix_.num_, "insert", T, base);
- T *slot = &vec_[ix];
- memmove (slot + 1, slot, (prefix_.num_++ - ix) * sizeof (T));
- if (ptr)
- *slot = *ptr;
-}
-
-
-/* Insert an element, VAL, at the IXth position of VEC. Reallocate
+/* Insert an element, OBJ, at the IXth position of VEC. Reallocate
VEC, if necessary. */
template<typename T>
template<enum vec_allocation_t A>
void
-vec_t<T>::safe_insert (vec_t<T> **vec, unsigned ix, T obj VEC_CHECK_DECL
+vec_t<T>::safe_insert (vec_t<T> **vec, unsigned ix, const T &obj VEC_CHECK_DECL
MEM_STAT_DECL)
{
reserve<A> (vec, 1 VEC_CHECK_PASS PASS_MEM_STAT);
}
-/* Insert an element, *PTR, at the IXth position of VEC. Return a pointer
- to the slot created. For vectors of object, the new value can be
- NULL, in which case no initialization of the inserted slot takes
- place. Reallocate V, if necessary. */
-
-template<typename T>
-template<enum vec_allocation_t A>
-void
-vec_t<T>::safe_insert (vec_t<T> **vec, unsigned ix, T *ptr VEC_CHECK_DECL
- MEM_STAT_DECL)
-{
- reserve<A> (vec, 1 VEC_CHECK_PASS PASS_MEM_STAT);
- (*vec)->quick_insert (ix, ptr VEC_CHECK_PASS);
-}
-
-
/* Remove an element from the IXth position of this vector. Ordering of
remaining elements is preserved. This is an O(N) operation due to
a memmove. */
template<typename T>
unsigned
-vec_t<T>::lower_bound (T obj, bool (*lessthan)(T, T)) const
+vec_t<T>::lower_bound (T obj, bool (*lessthan)(const T &, const T &)) const
{
unsigned int len = VEC_length (T, this);
unsigned int half, middle;
unsigned int first = 0;
while (len > 0)
{
- half = len >> 1;
+ half = len / 2;
middle = first;
middle += half;
T middle_elem = (*this)[middle];
}
-/* Find and return the first position in which *PTR could be inserted
- without changing the ordering of this vector. LESSTHAN is a
- function that returns true if the first argument is strictly less
- than the second. */
-
-template<typename T>
-unsigned
-vec_t<T>::lower_bound (const T *ptr,
- bool (*lessthan)(const T *, const T *)) const
-{
- unsigned int len = VEC_length (T, this);
- unsigned int half, middle;
- unsigned int first = 0;
- while (len > 0)
- {
- half = len >> 1;
- middle = first;
- middle += half;
- const T *middle_elem = &(*this)[middle];
- if (lessthan (middle_elem, ptr))
- {
- first = middle;
- ++first;
- len = len - half - 1;
- }
- else
- len = half;
- }
- return first;
-}
-
-
void *vec_heap_o_reserve_1 (void *, int, size_t, size_t, bool MEM_STAT_DECL);
void *vec_gc_o_reserve_1 (void *, int, size_t, size_t, bool MEM_STAT_DECL);
projects / thirdparty / gcc.git / commitdiff
