@@ -233,6 +233,6 @@ uses_jv_markobj_p (tree dtable)
this function is only used with flag_reduced_reflection. No
point in asserting unless we hit the bad case. */
gcc_assert (!flag_reduced_reflection || TARGET_VTABLE_USES_DESCRIPTORS == 0);
- v = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (dtable), 3).value;
+ v = (*CONSTRUCTOR_ELTS (dtable))[3].value;
return (PROCEDURE_OBJECT_DESCRIPTOR == TREE_INT_CST_LOW (v));
}
@@ -40,7 +40,6 @@ The Free Software Foundation is independent of Sun Microsystems, Inc. */
#include "ggc.h"
#include "cgraph.h"
#include "tree-iterator.h"
-#include "vecprim.h"
#include "target.h"
static tree make_method_value (tree);
@@ -98,7 +97,7 @@ static GTY(()) tree class_roots[4];
#define class_list class_roots[2]
#define class_dtable_decl class_roots[3]
-static GTY(()) VEC(tree,gc) *registered_class;
+static GTY(()) vec<tree, va_gc> *registered_class;
/* A tree that returns the address of the class$ of the class
currently being compiled. */
@@ -106,7 +105,7 @@ static GTY(()) tree this_classdollar;
/* A list of static class fields. This is to emit proper debug
info for them. */
-VEC(tree,gc) *pending_static_fields;
+vec<tree, va_gc> *pending_static_fields;
/* Return the node that most closely represents the class whose name
is IDENT. Start the search from NODE (followed by its siblings).
@@ -878,7 +877,7 @@ add_field (tree klass, tree name, tree field_type, int flags)
object file. */
DECL_EXTERNAL (field) = (is_compiled_class (klass) != 2);
if (!DECL_EXTERNAL (field))
- VEC_safe_push (tree, gc, pending_static_fields, field);
+ vec_safe_push (pending_static_fields, field);
}
return field;
@@ -941,7 +940,7 @@ build_utf8_ref (tree name)
int name_hash;
tree ref = IDENTIFIER_UTF8_REF (name);
tree decl;
- VEC(constructor_elt,gc) *v = NULL;
+ vec<constructor_elt, va_gc> *v = NULL;
if (ref != NULL_TREE)
return ref;
@@ -1422,7 +1421,7 @@ make_field_value (tree fdecl)
int flags;
tree type = TREE_TYPE (fdecl);
int resolved = is_compiled_class (type) && ! flag_indirect_dispatch;
- VEC(constructor_elt,gc) *v = NULL;
+ vec<constructor_elt, va_gc> *v = NULL;
START_RECORD_CONSTRUCTOR (v, field_type_node);
PUSH_FIELD_VALUE (v, "name", build_utf8_ref (DECL_NAME (fdecl)));
@@ -1480,7 +1479,7 @@ make_method_value (tree mdecl)
tree class_decl;
#define ACC_TRANSLATED 0x4000
int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED;
- VEC(constructor_elt,gc) *v = NULL;
+ vec<constructor_elt, va_gc> *v = NULL;
class_decl = DECL_CONTEXT (mdecl);
/* For interfaces, the index field contains the dispatch index. */
@@ -1520,29 +1519,29 @@ make_method_value (tree mdecl)
/* Compute the `throws' information for the method. */
tree table = null_pointer_node;
- if (!VEC_empty (tree, DECL_FUNCTION_THROWS (mdecl)))
+ if (!vec_safe_is_empty (DECL_FUNCTION_THROWS (mdecl)))
{
- int length = 1 + VEC_length (tree, DECL_FUNCTION_THROWS (mdecl));
+ int length = 1 + DECL_FUNCTION_THROWS (mdecl)->length ();
tree t, type, array;
char buf[60];
- VEC(constructor_elt,gc) *v = NULL;
+ vec<constructor_elt, va_gc> *v = NULL;
int idx = length - 1;
unsigned ix;
constructor_elt *e;
- v = VEC_alloc (constructor_elt, gc, length);
- VEC_safe_grow_cleared (constructor_elt, gc, v, length);
+ vec_alloc (v, length);
+ v->quick_grow_cleared (length);
- e = &VEC_index (constructor_elt, v, idx--);
+ e = &(*v)[idx--];
e->value = null_pointer_node;
- FOR_EACH_VEC_ELT (tree, DECL_FUNCTION_THROWS (mdecl), ix, t)
+ FOR_EACH_VEC_SAFE_ELT (DECL_FUNCTION_THROWS (mdecl), ix, t)
{
tree sig = DECL_NAME (TYPE_NAME (t));
tree utf8
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
- IDENTIFIER_LENGTH (sig)));
- e = &VEC_index (constructor_elt, v, idx--);
+ IDENTIFIER_LENGTH (sig)));
+ e = &(*v)[idx--];
e->value = utf8;
}
gcc_assert (idx == -1);
@@ -1611,7 +1610,7 @@ get_dispatch_table (tree type, tree this_class_addr)
int nvirtuals = TREE_VEC_LENGTH (vtable);
int arraysize;
tree gc_descr;
- VEC(constructor_elt,gc) *v = NULL;
+ vec<constructor_elt, va_gc> *v = NULL;
constructor_elt *e;
tree arraytype;
@@ -1620,8 +1619,8 @@ get_dispatch_table (tree type, tree this_class_addr)
arraysize *= TARGET_VTABLE_USES_DESCRIPTORS;
arraysize += 2;
- VEC_safe_grow_cleared (constructor_elt, gc, v, arraysize);
- e = &VEC_index (constructor_elt, v, arraysize - 1);
+ vec_safe_grow_cleared (v, arraysize);
+ e = &(*v)[arraysize - 1];
#define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E--
for (i = nvirtuals; --i >= 0; )
@@ -1674,7 +1673,7 @@ get_dispatch_table (tree type, tree this_class_addr)
/** Pointer to type_info object (to be implemented), according to g++ ABI. */
CONSTRUCTOR_PREPEND_VALUE (e, null_pointer_node);
/** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
- gcc_assert (e == VEC_address (constructor_elt, v));
+ gcc_assert (e == v->address ());
e->index = integer_zero_node;
e->value = null_pointer_node;
#undef CONSTRUCTOR_PREPEND_VALUE
@@ -1737,8 +1736,8 @@ supers_all_compiled (tree type)
}
static void
-add_table_and_syms (VEC(constructor_elt,gc) **v,
- VEC(method_entry,gc) *methods,
+add_table_and_syms (vec<constructor_elt, va_gc> **v,
+ vec<method_entry, va_gc> *methods,
const char *table_name, tree table_slot, tree table_type,
const char *syms_name, tree syms_slot)
{
@@ -1785,13 +1784,13 @@ make_class_data (tree type)
/** Offset from start of virtual function table declaration
to where objects actually point at, following new g++ ABI. */
tree dtable_start_offset = size_int (2 * POINTER_SIZE / BITS_PER_UNIT);
- VEC(int, heap) *field_indexes;
+ vec<int> field_indexes;
tree first_real_field;
- VEC(constructor_elt,gc) *v1 = NULL, *v2 = NULL;
+ vec<constructor_elt, va_gc> *v1 = NULL, *v2 = NULL;
tree reflection_data;
- VEC(constructor_elt,gc) *static_fields = NULL;
- VEC(constructor_elt,gc) *instance_fields = NULL;
- VEC(constructor_elt,gc) *methods = NULL;
+ vec<constructor_elt, va_gc> *static_fields = NULL;
+ vec<constructor_elt, va_gc> *instance_fields = NULL;
+ vec<constructor_elt, va_gc> *methods = NULL;
this_class_addr = build_static_class_ref (type);
decl = TREE_OPERAND (this_class_addr, 0);
@@ -1850,7 +1849,7 @@ make_class_data (tree type)
}
}
field_count = static_field_count + instance_field_count;
- field_indexes = VEC_alloc (int, heap, field_count);
+ field_indexes.create (field_count);
/* gcj sorts fields so that static fields come first, followed by
instance fields. Unfortunately, by the time this takes place we
@@ -1879,7 +1878,7 @@ make_class_data (tree type)
field_index = instance_count++;
else
continue;
- VEC_quick_push (int, field_indexes, field_index);
+ field_indexes.quick_push (field_index);
}
}
}
@@ -1912,14 +1911,12 @@ make_class_data (tree type)
}
}
- gcc_assert (static_field_count
- == (int) VEC_length (constructor_elt, static_fields));
- gcc_assert (instance_field_count
- == (int) VEC_length (constructor_elt, instance_fields));
+ gcc_assert (static_field_count == (int) vec_safe_length (static_fields));
+ gcc_assert (instance_field_count == (int) vec_safe_length (instance_fields));
if (field_count > 0)
{
- VEC_safe_splice (constructor_elt, gc, static_fields, instance_fields);
+ vec_safe_splice (static_fields, instance_fields);
field_array_type = build_prim_array_type (field_type_node, field_count);
fields_decl = build_decl (input_location,
VAR_DECL, mangled_classname ("_FL_", type),
@@ -2021,8 +2018,8 @@ make_class_data (tree type)
{
int i;
tree interface_array_type, idecl;
- VEC(constructor_elt,gc) *init = VEC_alloc (constructor_elt, gc,
- interface_len);
+ vec<constructor_elt, va_gc> *init;
+ vec_alloc (init, interface_len);
interface_array_type
= build_prim_array_type (class_ptr_type, interface_len);
idecl = build_decl (input_location,
@@ -2143,7 +2140,7 @@ make_class_data (tree type)
"itable_syms", TYPE_ITABLE_SYMS_DECL (type));
PUSH_FIELD_VALUE (v2, "catch_classes",
- build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type)));
+ build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type)));
PUSH_FIELD_VALUE (v2, "interfaces", interfaces);
PUSH_FIELD_VALUE (v2, "loader", null_pointer_node);
PUSH_FIELD_VALUE (v2, "interface_count",
@@ -2180,8 +2177,8 @@ make_class_data (tree type)
{
int i;
int count = TYPE_REFLECTION_DATASIZE (current_class);
- VEC (constructor_elt, gc) *v
- = VEC_alloc (constructor_elt, gc, count);
+ vec<constructor_elt, va_gc> *v;
+ vec_alloc (v, count);
unsigned char *data = TYPE_REFLECTION_DATA (current_class);
tree max_index = build_int_cst (sizetype, count);
tree index = build_index_type (max_index);
@@ -2194,14 +2191,14 @@ make_class_data (tree type)
array = build_decl (input_location,
VAR_DECL, get_identifier (buf), type);
- rewrite_reflection_indexes (field_indexes);
+ rewrite_reflection_indexes (&field_indexes);
for (i = 0; i < count; 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);
+ v->quick_push (elt);
}
DECL_INITIAL (array) = build_constructor (type, v);
@@ -2727,13 +2724,13 @@ register_class (void)
tree node;
if (!registered_class)
- registered_class = VEC_alloc (tree, gc, 8);
+ vec_alloc (registered_class, 8);
if (flag_indirect_classes)
node = current_class;
else
node = TREE_OPERAND (build_class_ref (current_class), 0);
- VEC_safe_push (tree, gc, registered_class, node);
+ vec_safe_push (registered_class, node);
}
/* Emit a function that calls _Jv_RegisterNewClasses with a list of
@@ -2745,15 +2742,16 @@ emit_indirect_register_classes (tree *list_p)
tree klass, t, register_class_fn;
int i;
- int size = VEC_length (tree, registered_class) * 2 + 1;
- VEC(constructor_elt,gc) *init = VEC_alloc (constructor_elt, gc, size);
+ int size = vec_safe_length (registered_class) * 2 + 1;
+ vec<constructor_elt, va_gc> *init;
+ vec_alloc (init, size);
tree class_array_type
= build_prim_array_type (ptr_type_node, size);
tree cdecl = build_decl (input_location,
VAR_DECL, get_identifier ("_Jv_CLS"),
class_array_type);
tree reg_class_list;
- FOR_EACH_VEC_ELT (tree, registered_class, i, klass)
+ FOR_EACH_VEC_SAFE_ELT (registered_class, i, klass)
{
t = fold_convert (ptr_type_node, build_static_class_ref (klass));
CONSTRUCTOR_APPEND_ELT (init, NULL_TREE, t);
@@ -2792,10 +2790,11 @@ emit_register_classes_in_jcr_section (void)
#ifdef JCR_SECTION_NAME
tree klass, cdecl, class_array_type;
int i;
- int size = VEC_length (tree, registered_class);
- VEC(constructor_elt,gc) *init = VEC_alloc (constructor_elt, gc, size);
+ int size = vec_safe_length (registered_class);
+ vec<constructor_elt, va_gc> *init;
+ vec_alloc (init, size);
- FOR_EACH_VEC_ELT (tree, registered_class, i, klass)
+ FOR_EACH_VEC_SAFE_ELT (registered_class, i, klass)
CONSTRUCTOR_APPEND_ELT (init, NULL_TREE, build_fold_addr_expr (klass));
/* ??? I would like to use tree_output_constant_def() but there is no way
@@ -2844,7 +2843,7 @@ emit_Jv_RegisterClass_calls (tree *list_p)
DECL_EXTERNAL (t) = 1;
register_class_fn = t;
- FOR_EACH_VEC_ELT (tree, registered_class, i, klass)
+ FOR_EACH_VEC_SAFE_ELT (registered_class, i, klass)
{
t = build_fold_addr_expr (klass);
t = build_call_expr (register_class_fn, 1, t);
@@ -2890,7 +2889,7 @@ static tree
build_symbol_table_entry (tree clname, tree name, tree signature)
{
tree symbol;
- VEC(constructor_elt,gc) *v = NULL;
+ vec<constructor_elt, va_gc> *v = NULL;
START_RECORD_CONSTRUCTOR (v, symbol_type);
PUSH_FIELD_VALUE (v, "clname", clname);
@@ -2935,22 +2934,22 @@ build_symbol_entry (tree decl, tree special)
tree
emit_symbol_table (tree name, tree the_table,
- VEC(method_entry,gc) *decl_table,
+ vec<method_entry, va_gc> *decl_table,
tree the_syms_decl, tree the_array_element_type,
int element_size)
{
tree table, null_symbol, table_size, the_array_type;
unsigned index;
method_entry *e;
- VEC(constructor_elt,gc) *v = NULL;
+ vec<constructor_elt, va_gc> *v = NULL;
/* Only emit a table if this translation unit actually made any
references via it. */
- if (decl_table == NULL)
+ if (!decl_table)
return the_table;
/* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
- FOR_EACH_VEC_ELT (method_entry, decl_table, index, e)
+ FOR_EACH_VEC_ELT (*decl_table, index, e)
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
build_symbol_entry (e->method, e->special));
@@ -2990,7 +2989,7 @@ make_catch_class_record (tree catch_class, tree classname)
{
tree entry;
tree type = TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class)));
- VEC(constructor_elt,gc) *v = NULL;
+ vec<constructor_elt, va_gc> *v = NULL;
START_RECORD_CONSTRUCTOR (v, type);
PUSH_FIELD_VALUE (v, "address", catch_class);
PUSH_FIELD_VALUE (v, "classname", classname);
@@ -3008,13 +3007,12 @@ emit_catch_table (tree this_class)
int n_catch_classes;
constructor_elt *e;
/* Fill in the dummy entry that make_class created. */
- e = &VEC_index (constructor_elt, TYPE_CATCH_CLASSES (this_class), 0);
+ e = &(*TYPE_CATCH_CLASSES (this_class))[0];
e->value = make_catch_class_record (null_pointer_node, null_pointer_node);
CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (this_class), NULL_TREE,
make_catch_class_record (null_pointer_node,
null_pointer_node));
- n_catch_classes = VEC_length (constructor_elt,
- TYPE_CATCH_CLASSES (this_class));
+ n_catch_classes = TYPE_CATCH_CLASSES (this_class)->length ();
table_size = build_index_type (build_int_cst (NULL_TREE, n_catch_classes));
array_type
= build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class))),
@@ -3052,7 +3050,7 @@ build_signature_for_libgcj (tree type)
static tree
build_assertion_table_entry (tree code, tree op1, tree op2)
{
- VEC(constructor_elt,gc) *v = NULL;
+ vec<constructor_elt, va_gc> *v = NULL;
tree entry;
START_RECORD_CONSTRUCTOR (v, assertion_entry_type);
@@ -3072,7 +3070,8 @@ add_assertion_table_entry (void **htab_entry, void *ptr)
{
tree entry;
tree code_val, op1_utf8, op2_utf8;
- VEC(constructor_elt,gc) **v = (VEC(constructor_elt,gc) **) ptr;
+ vec<constructor_elt, va_gc> **v
+ = ((vec<constructor_elt, va_gc> **) ptr);
type_assertion *as = (type_assertion *) *htab_entry;
code_val = build_int_cst (NULL_TREE, as->assertion_code);
@@ -3100,7 +3099,7 @@ emit_assertion_table (tree klass)
{
tree null_entry, ctor, table_decl;
htab_t assertions_htab = TYPE_ASSERTIONS (klass);
- VEC(constructor_elt,gc) *v = NULL;
+ vec<constructor_elt, va_gc> *v = NULL;
/* Iterate through the hash table. */
htab_traverse (assertions_htab, add_assertion_table_entry, &v);
@@ -3266,11 +3265,11 @@ in_same_package (tree name1, tree name2)
void
java_write_globals (void)
{
- tree *vec = VEC_address (tree, pending_static_fields);
- int len = VEC_length (tree, pending_static_fields);
+ tree *vec = vec_safe_address (pending_static_fields);
+ int len = vec_safe_length (pending_static_fields);
write_global_declarations ();
emit_debug_global_declarations (vec, len);
- VEC_free (tree, gc, pending_static_fields);
+ vec_free (pending_static_fields);
}
#include "gt-java-class.h"
@@ -502,20 +502,20 @@ build_constants_constructor (void)
CPool *outgoing_cpool = cpool_for_class (current_class);
tree tags_value, data_value;
tree cons;
- VEC(constructor_elt,gc) *v = NULL;
+ vec<constructor_elt, va_gc> *v = NULL;
int i;
- VEC(constructor_elt,gc) *tags = NULL;
- VEC(constructor_elt,gc) *data = NULL;
+ vec<constructor_elt, va_gc> *tags = NULL;
+ vec<constructor_elt, va_gc> *data = NULL;
constructor_elt *t = NULL;
constructor_elt *d = NULL;
if (outgoing_cpool->count > 0)
{
int c = outgoing_cpool->count;
- VEC_safe_grow_cleared (constructor_elt, gc, tags, c);
- VEC_safe_grow_cleared (constructor_elt, gc, data, c);
- t = &VEC_index (constructor_elt, tags, c-1);
- d = &VEC_index (constructor_elt, data, c-1);
+ vec_safe_grow_cleared (tags, c);
+ vec_safe_grow_cleared (data, c);
+ t = &(*tags)[c-1];
+ d = &(*data)[c-1];
}
#define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E--
@@ -569,8 +569,8 @@ build_constants_constructor (void)
tree tem;
/* Add dummy 0'th element of constant pool. */
- gcc_assert (t == VEC_address (constructor_elt, tags));
- gcc_assert (d == VEC_address (constructor_elt, data));
+ gcc_assert (t == tags->address ());
+ gcc_assert (d == data->address ());
t->value = get_tag_node (0);
d->value = null_pointer_node;
@@ -1953,7 +1953,7 @@ java_mark_class_local (tree klass)
if (FIELD_STATIC (t))
{
if (DECL_EXTERNAL (t))
- VEC_safe_push (tree, gc, pending_static_fields, t);
+ vec_safe_push (pending_static_fields, t);
java_mark_decl_local (t);
}
@@ -74,7 +74,7 @@ static void expand_cond (enum tree_code, tree, int);
static void expand_java_goto (int);
static tree expand_java_switch (tree, int);
static void expand_java_add_case (tree, int, int);
-static VEC(tree,gc) *pop_arguments (tree);
+static vec<tree, va_gc> *pop_arguments (tree);
static void expand_invoke (int, int, int);
static void expand_java_field_op (int, int, int);
static void java_push_constant_from_pool (struct JCF *, int);
@@ -96,7 +96,7 @@ tree dtable_ident = NULL_TREE;
int always_initialize_class_p = 0;
/* We store the stack state in two places:
- Within a basic block, we use the quick_stack, which is a VEC of expression
+ Within a basic block, we use the quick_stack, which is a vec of expression
nodes.
This is the top part of the stack; below that we use find_stack_slot.
At the end of a basic block, the quick_stack must be flushed
@@ -122,7 +122,7 @@ int always_initialize_class_p = 0;
So dup cannot just add an extra element to the quick_stack, but iadd can.
*/
-static GTY(()) VEC(tree,gc) *quick_stack;
+static GTY(()) vec<tree, va_gc> *quick_stack;
/* The physical memory page size used in this computer. See
build_field_ref(). */
@@ -222,10 +222,10 @@ flush_quick_stack (void)
tree t;
/* Count the number of slots the quick stack is holding. */
- for (ix = 0; VEC_iterate(tree, quick_stack, ix, t); ix++)
+ for (ix = 0; vec_safe_iterate (quick_stack, ix, &t); ix++)
stack_index -= 1 + TYPE_IS_WIDE (TREE_TYPE (t));
- for (ix = 0; VEC_iterate(tree, quick_stack, ix, t); ix++)
+ for (ix = 0; vec_safe_iterate (quick_stack, ix, &t); ix++)
{
tree decl, type = TREE_TYPE (t);
@@ -235,7 +235,7 @@ flush_quick_stack (void)
stack_index += 1 + TYPE_IS_WIDE (type);
}
- VEC_truncate (tree, quick_stack, 0);
+ vec_safe_truncate (quick_stack, 0);
}
/* Push TYPE on the type stack.
@@ -276,7 +276,7 @@ push_value (tree value)
value = convert (type, value);
}
push_type (type);
- VEC_safe_push (tree, gc, quick_stack, value);
+ vec_safe_push (quick_stack, value);
/* If the value has a side effect, then we need to evaluate it
whether or not the result is used. If the value ends up on the
@@ -590,8 +590,8 @@ static tree
pop_value (tree type)
{
type = pop_type (type);
- if (VEC_length (tree, quick_stack) != 0)
- return VEC_pop (tree, quick_stack);
+ if (vec_safe_length (quick_stack) != 0)
+ return quick_stack->pop ();
else
return find_stack_slot (stack_pointer, promote_type (type));
}
@@ -1100,17 +1100,17 @@ static void
expand_java_multianewarray (tree class_type, int ndim)
{
int i;
- VEC(tree,gc) *args = NULL;
+ vec<tree, va_gc> *args = NULL;
- VEC_safe_grow (tree, gc, args, 3 + ndim);
+ vec_safe_grow (args, 3 + ndim);
- VEC_replace (tree, args, 0, build_class_ref (class_type));
- VEC_replace (tree, args, 1, build_int_cst (NULL_TREE, ndim));
+ (*args)[0] = build_class_ref (class_type);
+ (*args)[1] = build_int_cst (NULL_TREE, ndim);
for(i = ndim - 1; i >= 0; i-- )
- VEC_replace (tree, args, (unsigned)(2 + i), pop_value (int_type_node));
+ (*args)[(unsigned)(2 + i)] = pop_value (int_type_node);
- VEC_replace (tree, args, 2 + ndim, null_pointer_node);
+ (*args)[2 + ndim] = null_pointer_node;
push_value (build_call_vec (promote_type (class_type),
build_address_of (soft_multianewarray_node),
@@ -1808,7 +1808,7 @@ char *instruction_bits;
indexed by PC. Each element is a tree vector holding the type
state at that PC. We only note type states at basic block
boundaries. */
-VEC(tree, gc) *type_states;
+vec<tree, va_gc> *type_states;
static void
note_label (int current_pc ATTRIBUTE_UNUSED, int target_pc)
@@ -1901,12 +1901,12 @@ expand_java_add_case (tree switch_expr, int match, int target_pc)
append_to_statement_list (x, &SWITCH_BODY (switch_expr));
}
-static VEC(tree,gc) *
+static vec<tree, va_gc> *
pop_arguments (tree method_type)
{
function_args_iterator fnai;
tree type;
- VEC(tree,gc) *args = NULL;
+ vec<tree, va_gc> *args = NULL;
int arity;
FOREACH_FUNCTION_ARGS (method_type, type, fnai)
@@ -1915,14 +1915,14 @@ pop_arguments (tree method_type)
if (type == void_type_node)
break;
- VEC_safe_push (tree, gc, args, type);
+ vec_safe_push (args, type);
}
- arity = VEC_length (tree, args);
+ arity = vec_safe_length (args);
while (arity--)
{
- tree arg = pop_value (VEC_index (tree, args, arity));
+ tree arg = pop_value ((*args)[arity]);
/* We simply cast each argument to its proper type. This is
needed since we lose type information coming out of the
@@ -1935,7 +1935,7 @@ pop_arguments (tree method_type)
&& INTEGRAL_TYPE_P (type))
arg = convert (integer_type_node, arg);
- VEC_replace (tree, args, arity, arg);
+ (*args)[arity] = arg;
}
return args;
@@ -2063,14 +2063,14 @@ typedef struct
const char *new_classname;
const char *new_signature;
int flags;
- void (*rewrite_arglist) (VEC(tree,gc) **);
+ void (*rewrite_arglist) (vec<tree, va_gc> **);
} rewrite_rule;
/* Add __builtin_return_address(0) to the end of an arglist. */
static void
-rewrite_arglist_getcaller (VEC(tree,gc) **arglist)
+rewrite_arglist_getcaller (vec<tree, va_gc> **arglist)
{
tree retaddr
= build_call_expr (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS),
@@ -2078,15 +2078,15 @@ rewrite_arglist_getcaller (VEC(tree,gc) **arglist)
DECL_UNINLINABLE (current_function_decl) = 1;
- VEC_safe_push (tree, gc, *arglist, retaddr);
+ vec_safe_push (*arglist, retaddr);
}
/* Add this.class to the end of an arglist. */
static void
-rewrite_arglist_getclass (VEC(tree,gc) **arglist)
+rewrite_arglist_getclass (vec<tree, va_gc> **arglist)
{
- VEC_safe_push (tree, gc, *arglist, build_class_ref (output_class));
+ vec_safe_push (*arglist, build_class_ref (output_class));
}
static rewrite_rule rules[] =
@@ -2137,7 +2137,7 @@ special_method_p (tree candidate_method)
method, update SPECIAL.*/
void
-maybe_rewrite_invocation (tree *method_p, VEC(tree,gc) **arg_list_p,
+maybe_rewrite_invocation (tree *method_p, vec<tree, va_gc> **arg_list_p,
tree *method_signature_p, tree *special)
{
tree context = DECL_NAME (TYPE_NAME (DECL_CONTEXT (*method_p)));
@@ -2185,7 +2185,7 @@ maybe_rewrite_invocation (tree *method_p, VEC(tree,gc) **arg_list_p,
tree
build_known_method_ref (tree method, tree method_type ATTRIBUTE_UNUSED,
tree self_type, tree method_signature ATTRIBUTE_UNUSED,
- VEC(tree,gc) *arg_list ATTRIBUTE_UNUSED, tree special)
+ vec<tree, va_gc> *arg_list ATTRIBUTE_UNUSED, tree special)
{
tree func;
if (is_compiled_class (self_type))
@@ -2261,12 +2261,12 @@ build_known_method_ref (tree method, tree method_type ATTRIBUTE_UNUSED,
}
tree
-invoke_build_dtable (int is_invoke_interface, VEC(tree,gc) *arg_list)
+invoke_build_dtable (int is_invoke_interface, vec<tree, va_gc> *arg_list)
{
tree dtable, objectref;
- tree saved = save_expr (VEC_index (tree, arg_list, 0));
+ tree saved = save_expr ((*arg_list)[0]);
- VEC_replace (tree, arg_list, 0, saved);
+ (*arg_list)[0] = saved;
/* If we're dealing with interfaces and if the objectref
argument is an array then get the dispatch table of the class
@@ -2292,17 +2292,17 @@ invoke_build_dtable (int is_invoke_interface, VEC(tree,gc) *arg_list)
int
get_symbol_table_index (tree t, tree special,
- VEC(method_entry,gc) **symbol_table)
+ vec<method_entry, va_gc> **symbol_table)
{
method_entry *e;
unsigned i;
method_entry elem = {t, special};
- FOR_EACH_VEC_ELT (method_entry, *symbol_table, i, e)
+ FOR_EACH_VEC_SAFE_ELT (*symbol_table, i, e)
if (t == e->method && special == e->special)
goto done;
- VEC_safe_push (method_entry, gc, *symbol_table, elem);
+ vec_safe_push (*symbol_table, elem);
done:
return i + 1;
@@ -2428,7 +2428,7 @@ expand_invoke (int opcode, int method_ref_index, int nargs ATTRIBUTE_UNUSED)
const char *const self_name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (self_type)));
tree call, func, method, method_type;
- VEC(tree,gc) *arg_list;
+ vec<tree, va_gc> *arg_list;
tree check = NULL_TREE;
tree special = NULL_TREE;
@@ -2569,8 +2569,8 @@ expand_invoke (int opcode, int method_ref_index, int nargs ATTRIBUTE_UNUSED)
We do omit the check if we're calling <init>. */
/* We use a SAVE_EXPR here to make sure we only evaluate
the new `self' expression once. */
- tree save_arg = save_expr (VEC_index (tree, arg_list, 0));
- VEC_replace (tree, arg_list, 0, save_arg);
+ tree save_arg = save_expr ((*arg_list)[0]);
+ (*arg_list)[0] = save_arg;
check = java_check_reference (save_arg, ! DECL_INIT_P (method));
func = build_known_method_ref (method, method_type, self_type,
method_signature, arg_list, special);
@@ -2622,7 +2622,7 @@ build_jni_stub (tree method)
tree method_args;
tree meth_var;
tree bind;
- VEC(tree,gc) *args = NULL;
+ vec<tree, va_gc> *args = NULL;
int args_size = 0;
tree klass = DECL_CONTEXT (method);
@@ -2657,7 +2657,7 @@ build_jni_stub (tree method)
/* The JNIEnv structure is the first argument to the JNI function. */
args_size += int_size_in_bytes (TREE_TYPE (env_var));
- VEC_safe_push (tree, gc, args, env_var);
+ vec_safe_push (args, env_var);
/* For a static method the second argument is the class. For a
non-static method the second argument is `this'; that is already
@@ -2665,7 +2665,7 @@ build_jni_stub (tree method)
if (METHOD_STATIC (method))
{
args_size += int_size_in_bytes (TREE_TYPE (klass));
- VEC_safe_push (tree, gc, args, klass);
+ vec_safe_push (args, klass);
}
/* All the arguments to this method become arguments to the
@@ -2680,7 +2680,7 @@ build_jni_stub (tree method)
#endif
args_size += (arg_bits / BITS_PER_UNIT);
- VEC_safe_push (tree, gc, args, tem);
+ vec_safe_push (args, tem);
}
arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
@@ -2967,7 +2967,7 @@ static void
load_type_state (int pc)
{
int i;
- tree vec = VEC_index (tree, type_states, pc);
+ tree vec = (*type_states)[pc];
int cur_length = TREE_VEC_LENGTH (vec);
stack_pointer = cur_length - DECL_MAX_LOCALS(current_function_decl);
for (i = 0; i < cur_length; i++)
@@ -3010,8 +3010,8 @@ note_instructions (JCF *jcf, tree method)
byte_ops = jcf->read_ptr;
instruction_bits = XRESIZEVAR (char, instruction_bits, length + 1);
memset (instruction_bits, 0, length + 1);
- type_states = VEC_alloc (tree, gc, length + 1);
- VEC_safe_grow_cleared (tree, gc, type_states, length + 1);
+ vec_alloc (type_states, length + 1);
+ type_states->quick_grow_cleared (length + 1);
/* This pass figures out which PC can be the targets of jumps. */
for (PC = 0; PC < length;)
@@ -724,7 +724,7 @@ struct GTY(()) lang_decl_func {
int max_stack;
int arg_slot_count;
source_location last_line; /* End line number for a function decl */
- VEC(tree,gc) *throws_list; /* Exception specified by `throws' */
+ vec<tree, va_gc> *throws_list; /* Exception specified by `throws' */
tree exc_obj; /* Decl holding the exception object. */
/* Class initialization test variables */
@@ -869,8 +869,6 @@ typedef struct GTY(()) method_entry_d {
tree special;
} method_entry;
-DEF_VEC_O(method_entry);
-DEF_VEC_ALLOC_O(method_entry,gc);
/* FIXME: the variable_size annotation here is needed because these types are
variable-sized in some other frontends. Due to gengtype deficiency the GTY
@@ -882,24 +880,24 @@ struct GTY((variable_size)) lang_type {
tree cpool_data_ref; /* Cached */
tree package_list; /* List of package names, progressive */
- VEC(method_entry,gc) *otable_methods; /* List of static decls referred
+ vec<method_entry, va_gc> *otable_methods; /* List of static decls referred
to by this class. */
tree otable_decl; /* The static address table. */
tree otable_syms_decl;
- VEC(method_entry,gc) *atable_methods; /* List of abstract methods
+ vec<method_entry, va_gc> *atable_methods; /* List of abstract methods
referred to by this class. */
tree atable_decl; /* The static address table. */
tree atable_syms_decl;
- VEC(method_entry,gc) *itable_methods; /* List of interface methods
+ vec<method_entry, va_gc> *itable_methods; /* List of interface methods
referred to by this class. */
tree itable_decl; /* The interfaces table. */
tree itable_syms_decl;
tree ctable_decl; /* The table of classes for the runtime
type matcher. */
- VEC(constructor_elt,gc) *catch_classes;
+ vec<constructor_elt, va_gc> *catch_classes;
htab_t GTY ((param_is (struct treetreehash_entry))) type_to_runtime_map;
/* The mapping of classes to exception region
@@ -1016,14 +1014,16 @@ extern void initialize_builtins (void);
extern tree lookup_name (tree);
extern bool special_method_p (tree);
-extern void maybe_rewrite_invocation (tree *, VEC(tree,gc) **, tree *, tree *);
-extern tree build_known_method_ref (tree, tree, tree, tree, VEC(tree,gc) *, tree);
+extern void maybe_rewrite_invocation (tree *, vec<tree, va_gc> **, tree *,
+ tree *);
+extern tree build_known_method_ref (tree, tree, tree, tree, vec<tree, va_gc> *,
+ tree);
extern tree build_class_init (tree, tree);
extern int attach_init_test_initialization_flags (void **, void *);
extern tree build_invokevirtual (tree, tree, tree);
extern tree build_invokeinterface (tree, tree);
extern tree build_jni_stub (tree);
-extern tree invoke_build_dtable (int, VEC(tree,gc) *);
+extern tree invoke_build_dtable (int, vec<tree, va_gc> *);
extern tree build_field_ref (tree, tree, tree);
extern tree java_modify_addr_for_volatile (tree);
extern void pushdecl_force_head (tree);
@@ -1062,7 +1062,7 @@ extern void make_class_data (tree);
extern int alloc_name_constant (int, tree);
extern int alloc_constant_fieldref (tree, tree);
extern void emit_register_classes (tree *);
-extern tree emit_symbol_table (tree, tree, VEC(method_entry,gc) *,
+extern tree emit_symbol_table (tree, tree, vec<method_entry, va_gc> *,
tree, tree, int);
extern void lang_init_source (int);
extern void write_classfile (tree);
@@ -1165,7 +1165,7 @@ extern void register_exception_range(struct eh_range *, int, int);
extern void finish_method (tree);
extern void java_expand_body (tree);
-extern int get_symbol_table_index (tree, tree, VEC(method_entry,gc) **);
+extern int get_symbol_table_index (tree, tree, vec<method_entry, va_gc> **);
extern tree make_catch_class_record (tree, tree);
extern tree emit_catch_table (tree);
@@ -1180,7 +1180,7 @@ extern void rewrite_reflection_indexes (void *);
int cxx_keyword_p (const char *name, int length);
-extern GTY(()) VEC(tree,gc) *pending_static_fields;
+extern GTY(()) vec<tree, va_gc> *pending_static_fields;
extern void java_write_globals (void);
@@ -1268,7 +1268,7 @@ extern void java_write_globals (void);
#define CLASS_COMPLETE_P(DECL) DECL_LANG_FLAG_2 (DECL)
/* A vector used to track type states for the current method. */
-extern VEC(tree, gc) *type_states;
+extern vec<tree, va_gc> *type_states;
/* This maps a bytecode offset (PC) to various flags,
listed below (starting with BCODE_). */
@@ -1419,7 +1419,7 @@ extern tree *type_map;
#define START_RECORD_CONSTRUCTOR(V, CTYPE) \
do \
{ \
- V = VEC_alloc (constructor_elt, gc, 0); \
+ vec_alloc (V, 0); \
CONSTRUCTOR_APPEND_ELT (V, TYPE_FIELDS (CTYPE), NULL); \
} \
while (0)
@@ -1430,7 +1430,7 @@ extern tree *type_map;
#define PUSH_SUPER_VALUE(V, VALUE) \
do \
{ \
- constructor_elt *_elt___ = &VEC_last (constructor_elt, V); \
+ constructor_elt *_elt___ = &(V)->last (); \
tree _next___ = DECL_CHAIN (_elt___->index); \
gcc_assert (!DECL_NAME (_elt___->index)); \
_elt___->value = VALUE; \
@@ -1444,7 +1444,7 @@ extern tree *type_map;
#define PUSH_FIELD_VALUE(V, NAME, VALUE) \
do \
{ \
- constructor_elt *_elt___ = &VEC_last (constructor_elt, V); \
+ constructor_elt *_elt___ = &(V)->last (); \
tree _next___ = DECL_CHAIN (_elt___->index); \
gcc_assert (strcmp (IDENTIFIER_POINTER (DECL_NAME (_elt___->index)), \
NAME) == 0); \
@@ -1457,7 +1457,7 @@ extern tree *type_map;
#define FINISH_RECORD_CONSTRUCTOR(CONS, V, CTYPE) \
do \
{ \
- VEC_pop (constructor_elt, V); \
+ V->pop (); \
CONS = build_constructor (CTYPE, V); \
TREE_CONSTANT (CONS) = 0; \
} \
@@ -39,7 +39,6 @@ The Free Software Foundation is independent of Sun Microsystems, Inc. */
#include "ggc.h"
#include "debug.h"
#include "cgraph.h"
-#include "vecprim.h"
#include "bitmap.h"
#include "target.h"
@@ -86,7 +85,7 @@ static location_t file_start_location;
static GTY(()) struct JCF * main_jcf;
/* A list of all the class DECLs seen so far. */
-static GTY(()) VEC(tree,gc) *all_class_list;
+static GTY(()) vec<tree, va_gc> *all_class_list;
/* The number of source files passed to us by -fsource-filename and an
array of pointers to each name. Used by find_sourcefile(). */
@@ -744,7 +743,7 @@ rewrite_reflection_indexes (void *arg)
{
bitmap_iterator bi;
unsigned int offset;
- VEC(int, heap) *map = (VEC(int, heap) *) arg;
+ vec<int> *map = (vec<int> *) arg;
unsigned char *data = TYPE_REFLECTION_DATA (current_class);
if (map)
@@ -753,7 +752,7 @@ rewrite_reflection_indexes (void *arg)
{
uint16 index = annotation_read_short (data + offset);
annotation_rewrite_short
- (VEC_index (int, map, index), data + offset);
+ ((*map)[index], data + offset);
}
}
}
@@ -933,12 +932,13 @@ handle_signature_attribute (int member_index, JCF *jcf,
#define HANDLE_EXCEPTIONS_ATTRIBUTE(COUNT) \
{ \
int n = COUNT; \
- VEC (tree,gc) *v = VEC_alloc (tree, gc, n); \
- gcc_assert (DECL_FUNCTION_THROWS (current_method) == NULL); \
+ vec<tree, va_gc> *v; \
+ vec_alloc (v, n); \
+ gcc_assert (!DECL_FUNCTION_THROWS (current_method)); \
while (--n >= 0) \
{ \
tree thrown_class = get_class_constant (jcf, JCF_readu2 (jcf)); \
- VEC_quick_push (tree, v, thrown_class); \
+ v->quick_push (thrown_class); \
} \
DECL_FUNCTION_THROWS (current_method) = v; \
}
@@ -1480,7 +1480,7 @@ jcf_parse (JCF* jcf)
if (current_class == object_type_node)
layout_class_methods (object_type_node);
else
- VEC_safe_push (tree, gc, all_class_list, TYPE_NAME (current_class));
+ vec_safe_push (all_class_list, TYPE_NAME (current_class));
}
/* If we came across inner classes, load them now. */
@@ -1512,7 +1512,7 @@ static void
java_layout_seen_class_methods (void)
{
unsigned start = 0;
- unsigned end = VEC_length (tree, all_class_list);
+ unsigned end = vec_safe_length (all_class_list);
while (1)
{
@@ -1521,7 +1521,7 @@ java_layout_seen_class_methods (void)
for (ix = start; ix != end; ix++)
{
- tree decl = VEC_index (tree, all_class_list, ix);
+ tree decl = (*all_class_list)[ix];
tree cls = TREE_TYPE (decl);
input_location = DECL_SOURCE_LOCATION (decl);
@@ -1534,7 +1534,7 @@ java_layout_seen_class_methods (void)
/* Note that new classes might have been added while laying out
methods, changing the value of all_class_list. */
- new_length = VEC_length (tree, all_class_list);
+ new_length = vec_safe_length (all_class_list);
if (end != new_length)
{
start = end;
@@ -1665,12 +1665,12 @@ parse_class_file (void)
input_location = save_location;
}
-static VEC(tree,gc) *predefined_filenames;
+static vec<tree, va_gc> *predefined_filenames;
void
add_predefined_file (tree name)
{
- VEC_safe_push (tree, gc, predefined_filenames, name);
+ vec_safe_push (predefined_filenames, name);
}
int
@@ -1679,7 +1679,7 @@ predefined_filename_p (tree node)
unsigned ix;
tree f;
- FOR_EACH_VEC_ELT (tree, predefined_filenames, ix, f)
+ FOR_EACH_VEC_SAFE_ELT (predefined_filenames, ix, f)
if (f == node)
return 1;
@@ -1853,18 +1853,17 @@ java_parse_file (void)
const char *resource_filename;
/* Only one resource file may be compiled at a time. */
- gcc_assert (VEC_length (tree, all_translation_units) == 1);
+ gcc_assert (all_translation_units->length () == 1);
resource_filename
- = IDENTIFIER_POINTER
- (DECL_NAME (VEC_index (tree, all_translation_units, 0)));
+ = IDENTIFIER_POINTER (DECL_NAME ((*all_translation_units)[0]));
compile_resource_file (resource_name, resource_filename);
goto finish;
}
current_jcf = main_jcf;
- FOR_EACH_VEC_ELT (tree, all_translation_units, ix, node)
+ FOR_EACH_VEC_ELT (*all_translation_units, ix, node)
{
unsigned char magic_string[4];
char *real_path;
@@ -1951,7 +1950,7 @@ java_parse_file (void)
}
}
- FOR_EACH_VEC_ELT (tree, all_translation_units, ix, node)
+ FOR_EACH_VEC_ELT (*all_translation_units, ix, node)
{
input_location = DECL_SOURCE_LOCATION (node);
if (CLASS_FILE_P (node))
@@ -37,13 +37,13 @@ The Free Software Foundation is independent of Sun Microsystems, Inc. */
#include "cgraph.h"
/* A list of all the resources files. */
-static GTY(()) VEC(tree,gc) *resources;
+static GTY(()) vec<tree, va_gc> *resources;
void
compile_resource_data (const char *name, const char *buffer, int length)
{
tree rtype, field = NULL_TREE, data_type, rinit, data, decl;
- VEC(constructor_elt,gc) *v = NULL;
+ vec<constructor_elt, va_gc> *v = NULL;
data_type = build_prim_array_type (unsigned_byte_type_node,
strlen (name) + length);
@@ -80,7 +80,7 @@ compile_resource_data (const char *name, const char *buffer, int length)
rest_of_decl_compilation (decl, global_bindings_p (), 0);
varpool_finalize_decl (decl);
- VEC_safe_push (tree, gc, resources, decl);
+ vec_safe_push (resources, decl);
}
void
@@ -100,7 +100,7 @@ write_resource_constructor (tree *list_p)
register_resource_fn = t;
/* Write out entries in the same order in which they were defined. */
- FOR_EACH_VEC_ELT (tree, resources, ix, decl)
+ FOR_EACH_VEC_ELT (*resources, ix, decl)
{
t = build_fold_addr_expr (decl);
t = build_call_expr (register_resource_fn, 1, t);
@@ -394,7 +394,7 @@ void
vfy_note_stack_depth (vfy_method *method, int pc, int depth)
{
tree val = make_tree_vec (method->max_locals + depth);
- VEC_replace (tree, type_states, pc, val);
+ (*type_states)[pc] = val;
/* Called for side effects. */
lookup_label (pc);
}
@@ -409,7 +409,7 @@ vfy_note_stack_type (vfy_method *method, int pc, int slot, vfy_jclass type)
if (type == object_type_node)
type = object_ptr_type_node;
- vec = VEC_index (tree, type_states, pc);
+ vec = (*type_states)[pc];
TREE_VEC_ELT (vec, slot) = type;
/* Called for side effects. */
lookup_label (pc);
@@ -424,7 +424,7 @@ vfy_note_local_type (vfy_method *method ATTRIBUTE_UNUSED, int pc, int slot,
if (type == object_type_node)
type = object_ptr_type_node;
- vec = VEC_index (tree, type_states, pc);
+ vec = (*type_states)[pc];
TREE_VEC_ELT (vec, slot) = type;
/* Called for side effects. */
lookup_label (pc);