+2009-05-15 Ian Lance Taylor <iant@google.com>
+
+ * alias.c (struct alias_set_entry_d): Rename from struct
+ alias_set_entry. Change all uses.
+ * except.c (struct call_site_record_d): Rename from struct
+ call_site_record. Change all uses.
+ * except.h (struct eh_region_d): Rename from struct eh_region.
+ Change all uses.
+ * gcse.c (struct hash_table_d): Rename from struct hash_table.
+ Change all uses.
+ * graphite.c (struct ivtype_map_elt_d): Rename fromstruct
+ ivtype_map_elt. Change all uses.
+ (struct rename_map_elt_d): Rename fromstruct rename_map_elt.
+ Change all uses.
+ (struct ifsese_d): Rename fromstruct ifsese. Change all uses.
+ * graphite.h (struct name_tree_d): Rename from struct name_tree.
+ Change all uses.
+ (struct sese_d): Rename from struct sese. Change all uses.
+ * omega.h (struct eqn_d): Rename from struct eqn. Change all
+ uses.
+ (struct omega_pb_d): Rename from struct omega_pb. Change all
+ uses.
+ * optabs.h (struct optab_d): Rename from struct optab. Change all
+ uses.
+ (struct convert_optab_d): Rename from struct convert_optab.
+ Change all uses.
+ * tree-pass.h (struct ipa_opt_pass_d): Rename fromstruct
+ ipa_opt_pass. Change all uses.
+ * tree-predcom.c (struct dref_d): Rename from struct dref. Change
+ all uses.
+
+ * c-decl.c (pushtag): If -Wc++-compat, warn if the tag is already
+ defined as a typedef.
+ (grokdeclarator): If -Wc++-compat, warn if a typedef is already
+ defined as a tag.
+
2009-05-15 Manuel López-Ibáñez <manu@gcc.gnu.org>
PR 16302
However, this is no actual entry for alias set zero. It is an
error to attempt to explicitly construct a subset of zero. */
-struct GTY(()) alias_set_entry {
+struct GTY(()) alias_set_entry_d {
/* The alias set number, as stored in MEM_ALIAS_SET. */
alias_set_type alias_set;
`int', `double', `float', and `struct S'. */
splay_tree GTY((param1_is (int), param2_is (int))) children;
};
-typedef struct alias_set_entry *alias_set_entry;
+typedef struct alias_set_entry_d *alias_set_entry;
static int rtx_equal_for_memref_p (const_rtx, const_rtx);
static int memrefs_conflict_p (int, rtx, int, rtx, HOST_WIDE_INT);
{
/* Create an entry for the SUPERSET, so that we have a place to
attach the SUBSET. */
- superset_entry = GGC_NEW (struct alias_set_entry);
+ superset_entry = GGC_NEW (struct alias_set_entry_d);
superset_entry->alias_set = superset;
superset_entry->children
= splay_tree_new_ggc (splay_tree_compare_ints);
/* An approximation for now, so we can tell this is a function-scope tag.
This will be updated in pop_scope. */
TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
+
+ if (warn_cxx_compat && name != NULL_TREE)
+ {
+ struct c_binding *b = I_SYMBOL_BINDING (name);
+
+ if (b != NULL
+ && b->decl != NULL_TREE
+ && TREE_CODE (b->decl) == TYPE_DECL
+ && (B_IN_CURRENT_SCOPE (b)
+ || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
+ && (TYPE_MAIN_VARIANT (TREE_TYPE (b->decl))
+ != TYPE_MAIN_VARIANT (type)))
+ {
+ warning_at (loc, OPT_Wc___compat,
+ ("using %qD as both a typedef and a tag is "
+ "invalid in C++"),
+ b->decl);
+ if (b->locus != UNKNOWN_LOCATION)
+ inform (b->locus, "originally defined here");
+ }
+ }
}
\f
/* Subroutine of compare_decls. Allow harmless mismatches in return
C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
if (declspecs->inline_p)
pedwarn (input_location, 0,"typedef %q+D declared %<inline%>", decl);
+
+ if (warn_cxx_compat && declarator->u.id != NULL_TREE)
+ {
+ struct c_binding *b = I_TAG_BINDING (declarator->u.id);
+
+ if (b != NULL
+ && b->decl != NULL_TREE
+ && (B_IN_CURRENT_SCOPE (b)
+ || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
+ && TYPE_MAIN_VARIANT (b->decl) != TYPE_MAIN_VARIANT (type))
+ {
+ warning_at (declarator->id_loc, OPT_Wc___compat,
+ ("using %qD as both a typedef and a tag is "
+ "invalid in C++"),
+ decl);
+ if (b->locus != UNKNOWN_LOCATION)
+ inform (b->locus, "originally defined here");
+ }
+ }
+
return decl;
}
+2009-05-15 Ian Lance Taylor <iant@google.com>
+
+ * cp-tree.h (enum cp_lvalue_kind_flags): Rename from
+ cp_lvalue_kind. Change all uses.
+ (enum base_access_flags): Rename from enum base_access. Change
+ all uses.
+ * parser.c (enum cp_parser_flags): Remove enum tag.
+
2009-05-15 Manuel López-Ibáñez <manu@gcc.gnu.org>
PR 16302
};
/* The various kinds of lvalues we distinguish. */
-enum cp_lvalue_kind {
+enum cp_lvalue_kind_flags {
clk_none = 0, /* Things that are not an lvalue. */
clk_ordinary = 1, /* An ordinary lvalue. */
clk_class = 2, /* An rvalue of class-type. */
};
/* This type is used for parameters and variables which hold
- combinations of the flags in enum cp_lvalue_kind. */
+ combinations of the flags in enum cp_lvalue_kind_flags. */
typedef int cp_lvalue_kind;
/* Various kinds of template specialization, instantiation, etc. */
typedef int tsubst_flags_t;
/* The kind of checking we can do looking in a class hierarchy. */
-enum base_access {
+enum base_access_flags {
ba_any = 0, /* Do not check access, allow an ambiguous base,
prefer a non-virtual base */
ba_unique = 1 << 0, /* Must be a unique base. */
};
/* This type is used for parameters and variables which hold
- combinations of the flags in enum base_access. */
+ combinations of the flags in enum base_access_flags. */
typedef int base_access;
/* The various kinds of access check during parsing. */
/* Flags that are passed to some parsing functions. These values can
be bitwise-ored together. */
-enum cp_parser_flags
+enum
{
/* No flags. */
CP_PARSER_FLAGS_NONE = 0x0,
};
/* This type is used for parameters and variables which hold
- combinations of the flags in enum cp_parser_flags. */
+ combinations of the above flags. */
typedef int cp_parser_flags;
/* The different kinds of declarators we want to parse. */
struct GTY(()) ehl_map_entry {
rtx label;
- struct eh_region *region;
+ struct eh_region_d *region;
};
static GTY(()) int call_site_base;
static int sjlj_fc_jbuf_ofs;
\f
-struct GTY(()) call_site_record
+struct GTY(()) call_site_record_d
{
rtx landing_pad;
int action;
static void sjlj_emit_dispatch_table (rtx, struct sjlj_lp_info *);
static void sjlj_build_landing_pads (void);
-static void remove_eh_handler (struct eh_region *);
-static void remove_eh_handler_and_replace (struct eh_region *,
- struct eh_region *, bool);
+static void remove_eh_handler (struct eh_region_d *);
+static void remove_eh_handler_and_replace (struct eh_region_d *,
+ struct eh_region_d *, bool);
/* The return value of reachable_next_level. */
enum reachable_code
};
struct reachable_info;
-static enum reachable_code reachable_next_level (struct eh_region *, tree,
+static enum reachable_code reachable_next_level (struct eh_region_d *, tree,
struct reachable_info *, bool);
static int action_record_eq (const void *, const void *);
static hashval_t action_record_hash (const void *);
static int add_action_record (htab_t, int, int);
-static int collect_one_action_chain (htab_t, struct eh_region *);
+static int collect_one_action_chain (htab_t, struct eh_region_d *);
static int add_call_site (rtx, int);
static void push_uleb128 (varray_type *, unsigned int);
These are used from tree-eh.c when processing exception related
nodes during tree optimization. */
-static struct eh_region *
-gen_eh_region (enum eh_region_type type, struct eh_region *outer)
+static struct eh_region_d *
+gen_eh_region (enum eh_region_type type, struct eh_region_d *outer)
{
- struct eh_region *new_eh;
+ struct eh_region_d *new_eh;
#ifdef ENABLE_CHECKING
gcc_assert (doing_eh (0));
#endif
/* Insert a new blank region as a leaf in the tree. */
- new_eh = GGC_CNEW (struct eh_region);
+ new_eh = GGC_CNEW (struct eh_region_d);
new_eh->type = type;
new_eh->outer = outer;
if (outer)
return new_eh;
}
-struct eh_region *
-gen_eh_region_cleanup (struct eh_region *outer)
+struct eh_region_d *
+gen_eh_region_cleanup (struct eh_region_d *outer)
{
- struct eh_region *cleanup = gen_eh_region (ERT_CLEANUP, outer);
+ struct eh_region_d *cleanup = gen_eh_region (ERT_CLEANUP, outer);
return cleanup;
}
-struct eh_region *
-gen_eh_region_try (struct eh_region *outer)
+struct eh_region_d *
+gen_eh_region_try (struct eh_region_d *outer)
{
return gen_eh_region (ERT_TRY, outer);
}
-struct eh_region *
-gen_eh_region_catch (struct eh_region *t, tree type_or_list)
+struct eh_region_d *
+gen_eh_region_catch (struct eh_region_d *t, tree type_or_list)
{
- struct eh_region *c, *l;
+ struct eh_region_d *c, *l;
tree type_list, type_node;
/* Ensure to always end up with a type list to normalize further
return c;
}
-struct eh_region *
-gen_eh_region_allowed (struct eh_region *outer, tree allowed)
+struct eh_region_d *
+gen_eh_region_allowed (struct eh_region_d *outer, tree allowed)
{
- struct eh_region *region = gen_eh_region (ERT_ALLOWED_EXCEPTIONS, outer);
+ struct eh_region_d *region = gen_eh_region (ERT_ALLOWED_EXCEPTIONS, outer);
region->u.allowed.type_list = allowed;
for (; allowed ; allowed = TREE_CHAIN (allowed))
return region;
}
-struct eh_region *
-gen_eh_region_must_not_throw (struct eh_region *outer)
+struct eh_region_d *
+gen_eh_region_must_not_throw (struct eh_region_d *outer)
{
return gen_eh_region (ERT_MUST_NOT_THROW, outer);
}
int
-get_eh_region_number (struct eh_region *region)
+get_eh_region_number (struct eh_region_d *region)
{
return region->region_number;
}
bool
-get_eh_region_may_contain_throw (struct eh_region *region)
+get_eh_region_may_contain_throw (struct eh_region_d *region)
{
return region->may_contain_throw;
}
tree
-get_eh_region_tree_label (struct eh_region *region)
+get_eh_region_tree_label (struct eh_region_d *region)
{
return region->tree_label;
}
}
void
-set_eh_region_tree_label (struct eh_region *region, tree lab)
+set_eh_region_tree_label (struct eh_region_d *region, tree lab)
{
region->tree_label = lab;
}
expand_resx_expr (tree exp)
{
int region_nr = TREE_INT_CST_LOW (TREE_OPERAND (exp, 0));
- struct eh_region *reg = VEC_index (eh_region,
- cfun->eh->region_array, region_nr);
+ struct eh_region_d *reg = VEC_index (eh_region,
+ cfun->eh->region_array, region_nr);
gcc_assert (!reg->resume);
do_pending_stack_adjust ();
call to a function which itself may contain a throw. */
void
-note_eh_region_may_contain_throw (struct eh_region *region)
+note_eh_region_may_contain_throw (struct eh_region_d *region)
{
while (region && !region->may_contain_throw)
{
void
collect_eh_region_array (void)
{
- struct eh_region *i;
+ struct eh_region_d *i;
i = cfun->eh->region_tree;
if (! i)
a problem. */
static bool
-can_be_reached_by_runtime (sbitmap contains_stmt, struct eh_region *r)
+can_be_reached_by_runtime (sbitmap contains_stmt, struct eh_region_d *r)
{
- struct eh_region *i = r->inner;
+ struct eh_region_d *i = r->inner;
unsigned n;
bitmap_iterator bi;
firest place. */
if (found)
{
- struct eh_region *i1 = i;
+ struct eh_region_d *i1 = i;
tree type_thrown = NULL_TREE;
if (i1->type == ERT_THROW)
/* Bring region R to the root of tree. */
static void
-bring_to_root (struct eh_region *r)
+bring_to_root (struct eh_region_d *r)
{
- struct eh_region **pp;
- struct eh_region *outer = r->outer;
+ struct eh_region_d **pp;
+ struct eh_region_d *outer = r->outer;
if (!r->outer)
return;
for (pp = &outer->inner; *pp != r; pp = &(*pp)->next_peer)
/* Return true if region R2 can be replaced by R1. */
static bool
-eh_region_replaceable_by_p (const struct eh_region *r1,
- const struct eh_region *r2)
+eh_region_replaceable_by_p (const struct eh_region_d *r1,
+ const struct eh_region_d *r2)
{
/* Regions are semantically same if they are of same type,
have same label and type. */
break;
case ERT_TRY:
{
- struct eh_region *c1, *c2;
+ struct eh_region_d *c1, *c2;
for (c1 = r1->u.eh_try.eh_catch,
c2 = r2->u.eh_try.eh_catch;
c1 && c2;
/* Replace region R2 by R1. */
static void
-replace_region (struct eh_region *r1, struct eh_region *r2)
+replace_region (struct eh_region_d *r1, struct eh_region_d *r2)
{
- struct eh_region *next1 = r1->u.eh_try.eh_catch;
- struct eh_region *next2 = r2->u.eh_try.eh_catch;
+ struct eh_region_d *next1 = r1->u.eh_try.eh_catch;
+ struct eh_region_d *next2 = r2->u.eh_try.eh_catch;
bool is_try = r1->type == ERT_TRY;
gcc_assert (r1->type != ERT_CATCH);
static hashval_t
hash_eh_region (const void *r)
{
- const struct eh_region *region = (const struct eh_region *)r;
+ const struct eh_region_d *region = (const struct eh_region_d *) r;
hashval_t val = region->type;
if (region->tree_label)
break;
case ERT_TRY:
{
- struct eh_region *c;
+ struct eh_region_d *c;
for (c = region->u.eh_try.eh_catch;
c; c = c->u.eh_catch.next_catch)
val = iterative_hash_hashval_t (hash_eh_region (c), val);
static int
eh_regions_equal_p (const void *r1, const void *r2)
{
- return eh_region_replaceable_by_p ((const struct eh_region *)r1,
- (const struct eh_region *)r2);
+ return eh_region_replaceable_by_p ((const struct eh_region_d *) r1,
+ (const struct eh_region_d *) r2);
}
/* Walk all peers of REGION and try to merge those regions
recursively too. */
static bool
-merge_peers (struct eh_region *region)
+merge_peers (struct eh_region_d *region)
{
- struct eh_region *r1, *r2, *outer = NULL, *next;
+ struct eh_region_d *r1, *r2, *outer = NULL, *next;
bool merged = false;
int num_regions = 0;
if (region)
if (!*slot)
*slot = r1;
else
- replace_region ((struct eh_region *)*slot, r1);
+ replace_region ((struct eh_region_d *) *slot, r1);
}
htab_delete (hash);
}
remove_unreachable_regions (sbitmap reachable, sbitmap contains_stmt)
{
int i;
- struct eh_region *r;
+ struct eh_region_d *r;
VEC(eh_region,heap) *must_not_throws = VEC_alloc (eh_region, heap, 16);
- struct eh_region *local_must_not_throw = NULL;
- struct eh_region *first_must_not_throw = NULL;
+ struct eh_region_d *local_must_not_throw = NULL;
+ struct eh_region_d *first_must_not_throw = NULL;
for (i = cfun->eh->last_region_number; i > 0; --i)
{
{
/* TRY regions are reachable if any of its CATCH regions
are reachable. */
- struct eh_region *c;
+ struct eh_region_d *c;
for (c = r->u.eh_try.eh_catch; c;
c = c->u.eh_catch.next_catch)
if (TEST_BIT (reachable, c->region_number))
cfun->cfg->last_label_uid + 1);
for (i = cfun->eh->last_region_number; i > 0; --i)
{
- struct eh_region *r = VEC_index (eh_region, cfun->eh->region_array, i);
+ struct eh_region_d *r = VEC_index (eh_region, cfun->eh->region_array, i);
if (r && r->region_number == i
&& r->tree_label && LABEL_DECL_UID (r->tree_label) >= 0)
{
int
get_next_region_sharing_label (int region)
{
- struct eh_region *r;
+ struct eh_region_d *r;
if (!region)
return 0;
r = VEC_index (eh_region, cfun->eh->region_array, region);
we allocated earlier. */
for (i = 1; i <= n; ++i)
{
- struct eh_region *region;
+ struct eh_region_d *region;
region = VEC_index (eh_region, cfun->eh->region_array, i);
if (region && region->tree_label)
for (i = cfun->eh->last_region_number; i > 0; --i)
{
- struct eh_region *region;
+ struct eh_region_d *region;
rtx lab;
region = VEC_index (eh_region, cfun->eh->region_array, i);
for (i = cfun->eh->last_region_number; i > 0; --i)
{
- struct eh_region *region;
+ struct eh_region_d *region;
region = VEC_index (eh_region, cfun->eh->region_array, i);
if (region
{
eh_region ret, n;
- ret = n = GGC_NEW (struct eh_region);
+ ret = n = GGC_NEW (struct eh_region_d);
*n = *old;
n->outer = outer;
/* Look for first outer region of R (or R itself) that is
TRY region. Return NULL if none. */
-static struct eh_region *
-find_prev_try (struct eh_region * r)
+static struct eh_region_d *
+find_prev_try (struct eh_region_d * r)
{
for (; r && r->type != ERT_TRY; r = r->outer)
if (r->type == ERT_MUST_NOT_THROW
/* Return new copy of eh region OLD inside region NEW_OUTER.
Do not care about updating the tree otherwise. */
-static struct eh_region *
-copy_eh_region_1 (struct eh_region *old, struct eh_region *new_outer)
+static struct eh_region_d *
+copy_eh_region_1 (struct eh_region_d *old, struct eh_region_d *new_outer)
{
- struct eh_region *new_eh = gen_eh_region (old->type, new_outer);
+ struct eh_region_d *new_eh = gen_eh_region (old->type, new_outer);
new_eh->u = old->u;
new_eh->tree_label = old->tree_label;
new_eh->may_contain_throw = old->may_contain_throw;
Copy whole catch-try chain if neccesary. */
-static struct eh_region *
-copy_eh_region (struct eh_region *old, struct eh_region *new_outer)
+static struct eh_region_d *
+copy_eh_region (struct eh_region_d *old, struct eh_region_d *new_outer)
{
- struct eh_region *r, *n, *old_try, *new_try, *ret = NULL;
+ struct eh_region_d *r, *n, *old_try, *new_try, *ret = NULL;
VEC(eh_region,heap) *catch_list = NULL;
if (old->type != ERT_CATCH)
/* Callback for forach_reachable_handler that push REGION into single VECtor DATA. */
static void
-push_reachable_handler (struct eh_region *region, void *data)
+push_reachable_handler (struct eh_region_d *region, void *data)
{
VEC(eh_region,heap) **trace = (VEC(eh_region,heap) **) data;
VEC_safe_push (eh_region, heap, *trace, region);
IS_RESX, INLINABLE_CALL and REGION_NMUBER match the parameter of
foreach_reachable_handler. */
-struct eh_region *
+struct eh_region_d *
redirect_eh_edge_to_label (edge e, tree new_dest_label, bool is_resx,
bool inlinable_call, int region_number)
{
- struct eh_region *outer;
- struct eh_region *region;
+ struct eh_region_d *outer;
+ struct eh_region_d *region;
VEC (eh_region, heap) * trace = NULL;
int i;
int start_here = -1;
basic_block old_bb = e->dest;
- struct eh_region *old, *r = NULL;
+ struct eh_region_d *old, *r = NULL;
bool update_inplace = true;
edge_iterator ei;
edge e2;
int
eh_region_outermost (struct function *ifun, int region_a, int region_b)
{
- struct eh_region *rp_a, *rp_b;
+ struct eh_region_d *rp_a, *rp_b;
sbitmap b_outer;
gcc_assert (ifun->eh->last_region_number > 0);
for (i = cfun->eh->last_region_number; i > 0; --i)
{
- struct eh_region *r;
+ struct eh_region_d *r;
r = VEC_index (eh_region, cfun->eh->region_array, i);
for (i = cfun->eh->last_region_number; i > 0; --i)
{
- struct eh_region *region;
+ struct eh_region_d *region;
rtx seq;
region = VEC_index (eh_region, cfun->eh->region_array, i);
switch statement generation code in expand_end_case.
Rapid prototyping sez a sequence of ifs. */
{
- struct eh_region *c;
+ struct eh_region_d *c;
for (c = region->u.eh_try.eh_catch; c ; c = c->u.eh_catch.next_catch)
{
if (c->u.eh_catch.type_list == NULL)
for (i = cfun->eh->last_region_number; i > 0; --i)
{
- struct eh_region *region;
- struct eh_region *outer;
+ struct eh_region_d *region;
+ struct eh_region_d *outer;
rtx seq;
rtx barrier;
for (i = cfun->eh->last_region_number; i > 0; --i)
{
- struct eh_region *region;
+ struct eh_region_d *region;
rtx seq;
basic_block bb;
edge e;
for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
{
- struct eh_region *region;
+ struct eh_region_d *region;
enum reachable_code rc;
tree type_thrown;
rtx note;
for (i = cfun->eh->last_region_number; i > 0; --i)
if (lp_info[i].directly_reachable)
{
- struct eh_region *r = VEC_index (eh_region, cfun->eh->region_array, i);
+ struct eh_region_d *r =
+ VEC_index (eh_region, cfun->eh->region_array, i);
r->landing_pad = dispatch_label;
lp_info[i].action_index = collect_one_action_chain (ar_hash, r);
for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
{
- struct eh_region *region;
+ struct eh_region_d *region;
int this_call_site;
rtx note, before, p;
emit_cmp_and_jump_insns (dispatch, GEN_INT (lp_info[i].dispatch_index),
EQ, NULL_RTX, TYPE_MODE (integer_type_node), 0,
- ((struct eh_region *)VEC_index (eh_region, cfun->eh->region_array, i))
- ->post_landing_pad);
+ (((struct eh_region_d *)
+ VEC_index (eh_region,
+ cfun->eh->region_array, i))
+ ->post_landing_pad));
}
seq = get_insns ();
end_sequence ();
- before = (((struct eh_region *)VEC_index (eh_region, cfun->eh->region_array, first_reachable))
+ before = (((struct eh_region_d *)
+ VEC_index (eh_region, cfun->eh->region_array, first_reachable))
->post_landing_pad);
bb = emit_to_new_bb_before (seq, before);
region.*/
static void
-remove_eh_handler_and_replace (struct eh_region *region,
- struct eh_region *replace,
+remove_eh_handler_and_replace (struct eh_region_d *region,
+ struct eh_region_d *replace,
bool update_catch_try)
{
- struct eh_region **pp, **pp_start, *p, *outer, *inner;
+ struct eh_region_d **pp, **pp_start, *p, *outer, *inner;
rtx lab;
outer = region->outer;
if (region->type == ERT_CATCH
&& update_catch_try)
{
- struct eh_region *eh_try, *next, *prev;
+ struct eh_region_d *eh_try, *next, *prev;
for (eh_try = region->next_peer;
eh_try->type == ERT_CATCH;
etc. */
static void
-remove_eh_handler (struct eh_region *region)
+remove_eh_handler (struct eh_region_d *region)
{
remove_eh_handler_and_replace (region, region->outer, true);
}
void
remove_eh_region (int r)
{
- struct eh_region *region;
+ struct eh_region_d *region;
region = VEC_index (eh_region, cfun->eh->region_array, r);
remove_eh_handler (region);
void
remove_eh_region_and_replace_by_outer_of (int r, int r2)
{
- struct eh_region *region, *region2;
+ struct eh_region_d *region, *region2;
region = VEC_index (eh_region, cfun->eh->region_array, r);
region2 = VEC_index (eh_region, cfun->eh->region_array, r2);
int i;
for (i = 0; i < cfun->eh->last_region_number; i++)
{
- struct eh_region *r = VEC_index (eh_region, cfun->eh->region_array, i);
+ struct eh_region_d *r = VEC_index (eh_region, cfun->eh->region_array, i);
if (r && r->region_number == i && r->label
&& GET_CODE (r->label) == CODE_LABEL)
(*callback) (r->label);
/* Invoke CALLBACK for every exception region in the current function. */
void
-for_each_eh_region (void (*callback) (struct eh_region *))
+for_each_eh_region (void (*callback) (struct eh_region_d *))
{
int i, n = cfun->eh->last_region_number;
for (i = 1; i <= n; ++i)
{
- struct eh_region *region;
+ struct eh_region_d *region;
region = VEC_index (eh_region, cfun->eh->region_array, i);
if (region)
{
tree types_caught;
tree types_allowed;
- void (*callback) (struct eh_region *, void *);
+ void (*callback) (struct eh_region_d *, void *);
void *callback_data;
};
static void
add_reachable_handler (struct reachable_info *info,
- struct eh_region *lp_region, struct eh_region *region)
+ struct eh_region_d *lp_region,
+ struct eh_region_d *region)
{
if (! info)
return;
and caught/allowed type information between invocations. */
static enum reachable_code
-reachable_next_level (struct eh_region *region, tree type_thrown,
+reachable_next_level (struct eh_region_d *region, tree type_thrown,
struct reachable_info *info,
bool maybe_resx)
{
case ERT_TRY:
{
- struct eh_region *c;
+ struct eh_region_d *c;
enum reachable_code ret = RNL_NOT_CAUGHT;
for (c = region->u.eh_try.eh_catch; c ; c = c->u.eh_catch.next_catch)
void
foreach_reachable_handler (int region_number, bool is_resx, bool inlinable_call,
- void (*callback) (struct eh_region *, void *),
+ void (*callback) (struct eh_region_d *, void *),
void *callback_data)
{
struct reachable_info info;
- struct eh_region *region;
+ struct eh_region_d *region;
tree type_thrown;
memset (&info, 0, sizeof (info));
reached by a given insn. */
static void
-arh_to_landing_pad (struct eh_region *region, void *data)
+arh_to_landing_pad (struct eh_region_d *region, void *data)
{
rtx *p_handlers = (rtx *) data;
if (! *p_handlers)
}
static void
-arh_to_label (struct eh_region *region, void *data)
+arh_to_label (struct eh_region_d *region, void *data)
{
rtx *p_handlers = (rtx *) data;
*p_handlers = alloc_INSN_LIST (region->label, *p_handlers);
bool
can_throw_internal_1 (int region_number, bool is_resx, bool inlinable_call)
{
- struct eh_region *region;
+ struct eh_region_d *region;
tree type_thrown;
region = VEC_index (eh_region, cfun->eh->region_array, region_number);
bool
can_throw_external_1 (int region_number, bool is_resx, bool inlinable_call)
{
- struct eh_region *region;
+ struct eh_region_d *region;
tree type_thrown;
region = VEC_index (eh_region, cfun->eh->region_array, region_number);
}
static int
-collect_one_action_chain (htab_t ar_hash, struct eh_region *region)
+collect_one_action_chain (htab_t ar_hash, struct eh_region_d *region)
{
- struct eh_region *c;
+ struct eh_region_d *c;
int next;
/* If we've reached the top of the region chain, then we have
{
call_site_record record;
- record = GGC_NEW (struct call_site_record);
+ record = GGC_NEW (struct call_site_record_d);
record->landing_pad = landing_pad;
record->action = action;
for (iter = get_insns (); iter ; iter = NEXT_INSN (iter))
if (INSN_P (iter))
{
- struct eh_region *region;
+ struct eh_region_d *region;
int this_action;
rtx this_landing_pad;
landing pads. Collect the landing pad for this region. */
if (this_action >= 0)
{
- struct eh_region *o;
+ struct eh_region_d *o;
for (o = region; ! o->landing_pad ; o = o->outer)
continue;
this_landing_pad = o->landing_pad;
for (i = 0; i < n; ++i)
{
- struct call_site_record *cs = VEC_index (call_site_record, crtl->eh.call_site_record, i);
+ struct call_site_record_d *cs =
+ VEC_index (call_site_record, crtl->eh.call_site_record, i);
size += size_of_uleb128 (cs->action);
}
for (i = 0; i < n; ++i)
{
- struct call_site_record *cs = VEC_index (call_site_record, crtl->eh.call_site_record, i);
+ struct call_site_record_d *cs =
+ VEC_index (call_site_record, crtl->eh.call_site_record, i);
size += size_of_uleb128 (INTVAL (cs->landing_pad));
size += size_of_uleb128 (cs->action);
}
for (i = 0; i < n; ++i)
{
- struct call_site_record *cs = VEC_index (call_site_record, crtl->eh.call_site_record, i);
+ struct call_site_record_d *cs =
+ VEC_index (call_site_record, crtl->eh.call_site_record, i);
char reg_start_lab[32];
char reg_end_lab[32];
char landing_pad_lab[32];
for (i = 0; i < n; ++i)
{
- struct call_site_record *cs = VEC_index (call_site_record, crtl->eh.call_site_record, i);
+ struct call_site_record_d *cs =
+ VEC_index (call_site_record, crtl->eh.call_site_record, i);
dw2_asm_output_data_uleb128 (INTVAL (cs->landing_pad),
"region %d landing pad", i);
void
dump_eh_tree (FILE * out, struct function *fun)
{
- struct eh_region *i;
+ struct eh_region_d *i;
int depth = 0;
static const char *const type_name[] = { "unknown", "cleanup", "try", "catch",
"allowed_exceptions", "must_not_throw",
case ERT_TRY:
{
- struct eh_region *c;
+ struct eh_region_d *c;
fprintf (out, " catch regions:");
for (c = i->u.eh_try.eh_catch; c; c = c->u.eh_catch.next_catch)
fprintf (out, " %i", c->region_number);
/* Verify EH region invariants. */
static bool
-verify_eh_region (struct eh_region *region)
+verify_eh_region (struct eh_region_d *region)
{
bool found = false;
if (!region)
{
case ERT_TRY:
{
- struct eh_region *c, *prev = NULL;
+ struct eh_region_d *c, *prev = NULL;
if (region->u.eh_try.eh_catch->u.eh_catch.prev_catch)
{
error ("Try region %i has wrong rh_catch pointer to %i",
void
verify_eh_tree (struct function *fun)
{
- struct eh_region *i, *outer = NULL;
+ struct eh_region_d *i, *outer = NULL;
bool err = false;
int nvisited = 0;
int count = 0;
};
/* Describes one exception region. */
-struct GTY(()) eh_region
+struct GTY(()) eh_region_d
{
/* The immediately surrounding region. */
- struct eh_region *outer;
+ struct eh_region_d *outer;
/* The list of immediately contained regions. */
- struct eh_region *inner;
- struct eh_region *next_peer;
+ struct eh_region_d *inner;
+ struct eh_region_d *next_peer;
/* List of regions sharing label. */
- struct eh_region *next_region_sharing_label;
+ struct eh_region_d *next_region_sharing_label;
/* An identifier for this region. */
int region_number;
/* A list of catch blocks, a surrounding try block,
and the label for continuing after a catch. */
struct eh_region_u_try {
- struct eh_region *eh_catch;
- struct eh_region *last_catch;
+ struct eh_region_d *eh_catch;
+ struct eh_region_d *last_catch;
} GTY ((tag ("ERT_TRY"))) eh_try;
/* The list through the catch handlers, the list of type objects
matched, and the list of associated filters. */
struct eh_region_u_catch {
- struct eh_region *next_catch;
- struct eh_region *prev_catch;
+ struct eh_region_d *next_catch;
+ struct eh_region_d *prev_catch;
tree type_list;
tree filter_list;
} GTY ((tag ("ERT_CATCH"))) eh_catch;
unsigned may_contain_throw : 1;
};
-typedef struct eh_region *eh_region;
+typedef struct eh_region_d *eh_region;
DEF_VEC_P(eh_region);
DEF_VEC_ALLOC_P(eh_region, gc);
DEF_VEC_ALLOC_P(eh_region, heap);
struct GTY(()) eh_status
{
/* The tree of all regions for this function. */
- struct eh_region *region_tree;
+ struct eh_region_d *region_tree;
/* The same information as an indexable array. */
VEC(eh_region,gc) *region_array;
/* Note that the current EH region (if any) may contain a throw, or a
call to a function which itself may contain a throw. */
-extern void note_eh_region_may_contain_throw (struct eh_region *);
+extern void note_eh_region_may_contain_throw (struct eh_region_d *);
/* Invokes CALLBACK for every exception handler label. Only used by old
loop hackery; should not be used by new code. */
extern void for_each_eh_label (void (*) (rtx));
/* Invokes CALLBACK for every exception region in the current function. */
-extern void for_each_eh_region (void (*) (struct eh_region *));
+extern void for_each_eh_region (void (*) (struct eh_region_d *));
/* Determine if the given INSN can throw an exception. */
extern bool can_throw_internal_1 (int, bool, bool);
extern void sjlj_emit_function_exit_after (rtx);
extern void default_init_unwind_resume_libfunc (void);
-extern struct eh_region *gen_eh_region_cleanup (struct eh_region *);
-extern struct eh_region *gen_eh_region_try (struct eh_region *);
-extern struct eh_region *gen_eh_region_catch (struct eh_region *, tree);
-extern struct eh_region *gen_eh_region_allowed (struct eh_region *, tree);
-extern struct eh_region *gen_eh_region_must_not_throw (struct eh_region *);
-extern int get_eh_region_number (struct eh_region *);
-extern bool get_eh_region_may_contain_throw (struct eh_region *);
+extern struct eh_region_d *gen_eh_region_cleanup (struct eh_region_d *);
+extern struct eh_region_d *gen_eh_region_try (struct eh_region_d *);
+extern struct eh_region_d *gen_eh_region_catch (struct eh_region_d *, tree);
+extern struct eh_region_d *gen_eh_region_allowed (struct eh_region_d *, tree);
+extern struct eh_region_d *gen_eh_region_must_not_throw (struct eh_region_d *);
+extern int get_eh_region_number (struct eh_region_d *);
+extern bool get_eh_region_may_contain_throw (struct eh_region_d *);
extern tree get_eh_region_no_tree_label (int);
-extern tree get_eh_region_tree_label (struct eh_region *);
-extern void set_eh_region_tree_label (struct eh_region *, tree);
+extern tree get_eh_region_tree_label (struct eh_region_d *);
+extern void set_eh_region_tree_label (struct eh_region_d *, tree);
extern void foreach_reachable_handler (int, bool, bool,
- void (*) (struct eh_region *, void *),
+ void (*) (struct eh_region_d *, void *),
void *);
extern void collect_eh_region_array (void);
extern void remove_unreachable_regions (sbitmap, sbitmap);
extern VEC(int,heap) * label_to_region_map (void);
extern int num_eh_regions (void);
-extern struct eh_region *redirect_eh_edge_to_label (struct edge_def *, tree, bool, bool, int);
+extern struct eh_region_d *redirect_eh_edge_to_label (struct edge_def *, tree,
+ bool, bool, int);
extern int get_next_region_sharing_label (int);
rtx x_forced_labels;
};
-typedef struct call_site_record *call_site_record;
+typedef struct call_site_record_d *call_site_record;
DEF_VEC_P(call_site_record);
DEF_VEC_ALLOC_P(call_site_record, gc);
struct gimple_df;
struct temp_slot;
typedef struct temp_slot *temp_slot_p;
-struct call_site_record;
+struct call_site_record_d;
DEF_VEC_P(temp_slot_p);
DEF_VEC_ALLOC_P(temp_slot_p,gc);
-struct ipa_opt_pass;
-typedef struct ipa_opt_pass *ipa_opt_pass;
+struct ipa_opt_pass_d;
+typedef struct ipa_opt_pass_d *ipa_opt_pass;
DEF_VEC_P(ipa_opt_pass);
DEF_VEC_ALLOC_P(ipa_opt_pass,heap);
[one could build a mapping table without holes afterwards though].
Someday I'll perform the computation and figure it out. */
-struct hash_table
+struct hash_table_d
{
/* The table itself.
This is an array of `expr_hash_table_size' elements. */
};
/* Expression hash table. */
-static struct hash_table expr_hash_table;
+static struct hash_table_d expr_hash_table;
/* Copy propagation hash table. */
-static struct hash_table set_hash_table;
+static struct hash_table_d set_hash_table;
/* This is a list of expressions which are MEMs and will be used by load
or store motion.
static void *gcse_alloc (unsigned long);
static void alloc_gcse_mem (void);
static void free_gcse_mem (void);
-static void hash_scan_insn (rtx, struct hash_table *);
-static void hash_scan_set (rtx, rtx, struct hash_table *);
-static void hash_scan_clobber (rtx, rtx, struct hash_table *);
-static void hash_scan_call (rtx, rtx, struct hash_table *);
+static void hash_scan_insn (rtx, struct hash_table_d *);
+static void hash_scan_set (rtx, rtx, struct hash_table_d *);
+static void hash_scan_clobber (rtx, rtx, struct hash_table_d *);
+static void hash_scan_call (rtx, rtx, struct hash_table_d *);
static int want_to_gcse_p (rtx);
static bool gcse_constant_p (const_rtx);
static int oprs_unchanged_p (const_rtx, const_rtx, int);
static int oprs_anticipatable_p (const_rtx, const_rtx);
static int oprs_available_p (const_rtx, const_rtx);
static void insert_expr_in_table (rtx, enum machine_mode, rtx, int, int,
- struct hash_table *);
-static void insert_set_in_table (rtx, rtx, struct hash_table *);
+ struct hash_table_d *);
+static void insert_set_in_table (rtx, rtx, struct hash_table_d *);
static unsigned int hash_expr (const_rtx, enum machine_mode, int *, int);
static unsigned int hash_set (int, int);
static int expr_equiv_p (const_rtx, const_rtx);
static void record_last_reg_set_info (rtx, int);
static void record_last_mem_set_info (rtx);
static void record_last_set_info (rtx, const_rtx, void *);
-static void compute_hash_table (struct hash_table *);
-static void alloc_hash_table (int, struct hash_table *, int);
-static void free_hash_table (struct hash_table *);
-static void compute_hash_table_work (struct hash_table *);
-static void dump_hash_table (FILE *, const char *, struct hash_table *);
-static struct expr *lookup_set (unsigned int, struct hash_table *);
+static void compute_hash_table (struct hash_table_d *);
+static void alloc_hash_table (int, struct hash_table_d *, int);
+static void free_hash_table (struct hash_table_d *);
+static void compute_hash_table_work (struct hash_table_d *);
+static void dump_hash_table (FILE *, const char *, struct hash_table_d *);
+static struct expr *lookup_set (unsigned int, struct hash_table_d *);
static struct expr *next_set (unsigned int, struct expr *);
static void reset_opr_set_tables (void);
static int oprs_not_set_p (const_rtx, const_rtx);
static void compute_transp (const_rtx, int, sbitmap *, int);
static void compute_transpout (void);
static void compute_local_properties (sbitmap *, sbitmap *, sbitmap *,
- struct hash_table *);
+ struct hash_table_d *);
static void compute_cprop_data (void);
static void find_used_regs (rtx *, void *);
static int try_replace_reg (rtx, rtx, rtx);
static void
compute_local_properties (sbitmap *transp, sbitmap *comp, sbitmap *antloc,
- struct hash_table *table)
+ struct hash_table_d *table)
{
unsigned int i;
static void
insert_expr_in_table (rtx x, enum machine_mode mode, rtx insn, int antic_p,
- int avail_p, struct hash_table *table)
+ int avail_p, struct hash_table_d *table)
{
int found, do_not_record_p;
unsigned int hash;
basic block. */
static void
-insert_set_in_table (rtx x, rtx insn, struct hash_table *table)
+insert_set_in_table (rtx x, rtx insn, struct hash_table_d *table)
{
int found;
unsigned int hash;
expression one). */
static void
-hash_scan_set (rtx pat, rtx insn, struct hash_table *table)
+hash_scan_set (rtx pat, rtx insn, struct hash_table_d *table)
{
rtx src = SET_SRC (pat);
rtx dest = SET_DEST (pat);
static void
hash_scan_clobber (rtx x ATTRIBUTE_UNUSED, rtx insn ATTRIBUTE_UNUSED,
- struct hash_table *table ATTRIBUTE_UNUSED)
+ struct hash_table_d *table ATTRIBUTE_UNUSED)
{
/* Currently nothing to do. */
}
static void
hash_scan_call (rtx x ATTRIBUTE_UNUSED, rtx insn ATTRIBUTE_UNUSED,
- struct hash_table *table ATTRIBUTE_UNUSED)
+ struct hash_table_d *table ATTRIBUTE_UNUSED)
{
/* Currently nothing to do. */
}
otherwise it is for the expression hash table. */
static void
-hash_scan_insn (rtx insn, struct hash_table *table)
+hash_scan_insn (rtx insn, struct hash_table_d *table)
{
rtx pat = PATTERN (insn);
int i;
}
static void
-dump_hash_table (FILE *file, const char *name, struct hash_table *table)
+dump_hash_table (FILE *file, const char *name, struct hash_table_d *table)
{
int i;
/* Flattened out table, so it's printed in proper order. */
TABLE is the table computed. */
static void
-compute_hash_table_work (struct hash_table *table)
+compute_hash_table_work (struct hash_table_d *table)
{
int i;
be created. */
static void
-alloc_hash_table (int n_insns, struct hash_table *table, int set_p)
+alloc_hash_table (int n_insns, struct hash_table_d *table, int set_p)
{
int n;
/* Free things allocated by alloc_hash_table. */
static void
-free_hash_table (struct hash_table *table)
+free_hash_table (struct hash_table_d *table)
{
free (table->table);
}
expression hash table. */
static void
-compute_hash_table (struct hash_table *table)
+compute_hash_table (struct hash_table_d *table)
{
/* Initialize count of number of entries in hash table. */
table->n_elems = 0;
table entry, or NULL if not found. */
static struct expr *
-lookup_set (unsigned int regno, struct hash_table *table)
+lookup_set (unsigned int regno, struct hash_table_d *table)
{
unsigned int hash = hash_set (regno, table->size);
struct expr *expr;
sese
new_sese (edge entry, edge exit)
{
- sese res = XNEW (struct sese);
+ sese res = XNEW (struct sese_d);
SESE_ENTRY (res) = entry;
SESE_EXIT (res) = exit;
loop_iv_stack_push_iv (loop_iv_stack stack, tree iv, const char *name)
{
iv_stack_entry *entry = XNEW (iv_stack_entry);
- name_tree named_iv = XNEW (struct name_tree);
+ name_tree named_iv = XNEW (struct name_tree_d);
named_iv->t = iv;
named_iv->name = name;
/* Structure containing the mapping between the CLooG's induction
variable and the type of the old induction variable. */
-typedef struct ivtype_map_elt
+typedef struct ivtype_map_elt_d
{
tree type;
const char *cloog_iv;
static int
debug_ivtype_map_1 (void **slot, void *s ATTRIBUTE_UNUSED)
{
- struct ivtype_map_elt *entry = (struct ivtype_map_elt *) *slot;
+ struct ivtype_map_elt_d *entry = (struct ivtype_map_elt_d *) *slot;
debug_ivtype_elt (entry);
return 1;
}
{
ivtype_map_elt res;
- res = XNEW (struct ivtype_map_elt);
+ res = XNEW (struct ivtype_map_elt_d);
res->cloog_iv = cloog_iv;
res->type = type;
static hashval_t
ivtype_map_elt_info (const void *elt)
{
- return htab_hash_pointer (((const struct ivtype_map_elt *) elt)->cloog_iv);
+ return htab_hash_pointer (((const struct ivtype_map_elt_d *) elt)->cloog_iv);
}
/* Compares database elements E1 and E2. */
static int
eq_ivtype_map_elts (const void *e1, const void *e2)
{
- const struct ivtype_map_elt *elt1 = (const struct ivtype_map_elt *) e1;
- const struct ivtype_map_elt *elt2 = (const struct ivtype_map_elt *) e2;
+ const struct ivtype_map_elt_d *elt1 = (const struct ivtype_map_elt_d *) e1;
+ const struct ivtype_map_elt_d *elt2 = (const struct ivtype_map_elt_d *) e2;
return (elt1->cloog_iv == elt2->cloog_iv);
}
static tree
gcc_type_for_cloog_iv (const char *cloog_iv, graphite_bb_p gbb)
{
- struct ivtype_map_elt tmp;
+ struct ivtype_map_elt_d tmp;
PTR *slot;
tmp.cloog_iv = cloog_iv;
/* Structure containing the mapping between the old names and the new
names used after block copy in the new loop context. */
-typedef struct rename_map_elt
+typedef struct rename_map_elt_d
{
tree old_name, new_name;
} *rename_map_elt;
static int
debug_rename_map_1 (void **slot, void *s ATTRIBUTE_UNUSED)
{
- struct rename_map_elt *entry = (struct rename_map_elt *) *slot;
+ struct rename_map_elt_d *entry = (struct rename_map_elt_d *) *slot;
debug_rename_elt (entry);
return 1;
}
{
rename_map_elt res;
- res = XNEW (struct rename_map_elt);
+ res = XNEW (struct rename_map_elt_d);
res->old_name = old_name;
res->new_name = new_name;
static hashval_t
rename_map_elt_info (const void *elt)
{
- return htab_hash_pointer (((const struct rename_map_elt *) elt)->old_name);
+ return htab_hash_pointer (((const struct rename_map_elt_d *) elt)->old_name);
}
/* Compares database elements E1 and E2. */
static int
eq_rename_map_elts (const void *e1, const void *e2)
{
- const struct rename_map_elt *elt1 = (const struct rename_map_elt *) e1;
- const struct rename_map_elt *elt2 = (const struct rename_map_elt *) e2;
+ const struct rename_map_elt_d *elt1 = (const struct rename_map_elt_d *) e1;
+ const struct rename_map_elt_d *elt2 = (const struct rename_map_elt_d *) e2;
return (elt1->old_name == elt2->old_name);
}
static tree
get_new_name_from_old_name (htab_t map, tree old_name)
{
- struct rename_map_elt tmp;
+ struct rename_map_elt_d tmp;
PTR *slot;
tmp.old_name = old_name;
if (!induction_var)
return false;
- oldiv = XNEW (struct name_tree);
+ oldiv = XNEW (struct name_tree_d);
oldiv->t = induction_var;
oldiv->name = get_name (SSA_NAME_VAR (oldiv->t));
oldiv->loop = loop;
gcc_assert (SCOP_ADD_PARAMS (scop));
- nvar = XNEW (struct name_tree);
+ nvar = XNEW (struct name_tree_d);
nvar->t = var;
nvar->name = NULL;
VEC_safe_push (name_tree, heap, SCOP_PARAMS (scop), nvar);
for (i = 0; VEC_iterate (name_tree, SCOP_OLDIVS (scop), i, iv); i++)
{
- struct rename_map_elt tmp;
+ struct rename_map_elt_d tmp;
if (!flow_bb_inside_loop_p (iv->loop, GBB_BB (gbb)))
continue;
static void
register_old_and_new_names (htab_t map, tree old_name, tree new_name)
{
- struct rename_map_elt tmp;
+ struct rename_map_elt_d tmp;
PTR *slot;
tmp.old_name = old_name;
static int
add_loop_exit_phis (void **slot, void *s)
{
- struct rename_map_elt *entry = (struct rename_map_elt *) *slot;
+ struct rename_map_elt_d *entry = (struct rename_map_elt_d *) *slot;
tree new_name = entry->new_name;
basic_block bb = (basic_block) s;
gimple phi = create_phi_node (new_name, bb);
static int
add_guard_exit_phis (void **slot, void *s)
{
- struct rename_map_elt *entry = (struct rename_map_elt *) *slot;
+ struct rename_map_elt_d *entry = (struct rename_map_elt_d *) *slot;
struct igp *i = (struct igp *) s;
basic_block bb = i->bb;
edge true_edge = i->true_edge;
static int
copy_renames (void **slot, void *s)
{
- struct rename_map_elt *entry = (struct rename_map_elt *) *slot;
+ struct rename_map_elt_d *entry = (struct rename_map_elt_d *) *slot;
htab_t res = (htab_t) s;
tree old_name = entry->old_name;
tree new_name = entry->new_name;
- struct rename_map_elt tmp;
+ struct rename_map_elt_d tmp;
PTR *x;
tmp.old_name = old_name;
VEC_free (basic_block, heap, bbs);
}
-typedef struct ifsese {
+typedef struct ifsese_d
+{
sese region;
sese true_region;
sese false_region;
{
edge e;
edge_iterator ei;
- sese sese_region = GGC_NEW (struct sese);
- sese true_region = GGC_NEW (struct sese);
- sese false_region = GGC_NEW (struct sese);
- ifsese if_region = GGC_NEW (struct ifsese);
+ sese sese_region = GGC_NEW (struct sese_d);
+ sese true_region = GGC_NEW (struct sese_d);
+ sese false_region = GGC_NEW (struct sese_d);
+ ifsese if_region = GGC_NEW (struct ifsese_d);
edge exit = create_empty_if_region_on_edge (entry, condition);
if_region->region = sese_region;
for (t = user_stmt->substitutions; t; t = t->next, index++)
{
PTR *slot;
- struct ivtype_map_elt tmp;
+ struct ivtype_map_elt_d tmp;
struct clast_expr *expr = (struct clast_expr *)
((struct clast_assignment *)t)->RHS;
CloogLoop *cloog_loop;
};
-typedef struct name_tree
+typedef struct name_tree_d
{
tree t;
const char *name;
/* A Single Entry, Single Exit region is a part of the CFG delimited
by two edges. */
-typedef struct sese
+typedef struct sese_d
{
/* Single ENTRY and single EXIT from the SESE region. */
edge entry, exit;
/* Interprocedural constant propagation
- Copyright (C) 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
Contributed by Razya Ladelsky <RAZYA@il.ibm.com>
This file is part of GCC.
return flag_ipa_cp;
}
-struct ipa_opt_pass pass_ipa_cp =
+struct ipa_opt_pass_d pass_ipa_cp =
{
{
IPA_PASS,
return todo | execute_fixup_cfg ();
}
-struct ipa_opt_pass pass_ipa_inline =
+struct ipa_opt_pass_d pass_ipa_inline =
{
{
IPA_PASS,
/* Callgraph based analysis of static variables.
- Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
This file is part of GCC.
&& !(errorcount || sorrycount));
}
-struct ipa_opt_pass pass_ipa_pure_const =
+struct ipa_opt_pass_d pass_ipa_pure_const =
{
{
IPA_PASS,
/* Callgraph based analysis of static variables.
- Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
This file is part of GCC.
&& !(errorcount || sorrycount));
}
-struct ipa_opt_pass pass_ipa_reference =
+struct ipa_opt_pass_d pass_ipa_reference =
{
{
IPA_PASS,
enum omega_result result;
int e;
bool any_color = false;
- omega_pb tmp_problem = XNEW (struct omega_pb);
+ omega_pb tmp_problem = XNEW (struct omega_pb_d);
omega_copy_problem (tmp_problem, pb);
tmp_problem->safe_vars = 0;
if (!expensive)
goto eliminate_redundant_done;
- tmp_problem = XNEW (struct omega_pb);
+ tmp_problem = XNEW (struct omega_pb_d);
conservative++;
for (e = pb->num_geqs - 1; e >= 0; e--)
return;
conservative++;
- tmp_problem = XNEW (struct omega_pb);
+ tmp_problem = XNEW (struct omega_pb_d);
for (e = pb->num_geqs - 1; e >= 0; e--)
if (pb->geqs[e].color == omega_red)
omega_print_problem (dump_file, pb);
}
- tmp_problem = XNEW (struct omega_pb);
+ tmp_problem = XNEW (struct omega_pb_d);
omega_copy_eqn (&pb->eqs[0], &pb->geqs[e], pb->num_vars);
pb->num_eqs = 1;
omega_initialize ();
/* Allocate and initialize PB. */
- pb = XCNEW (struct omega_pb);
+ pb = XCNEW (struct omega_pb_d);
pb->var = XCNEWVEC (int, OMEGA_MAX_VARS + 2);
pb->forwarding_address = XCNEWVEC (int, OMEGA_MAX_VARS + 2);
pb->geqs = omega_alloc_eqns (0, OMEGA_MAX_GEQS);
This code has no license restrictions, and is considered public
domain.
- Changes copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
+ Changes copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
Contributed by Sebastian Pop <sebastian.pop@inria.fr>
This file is part of GCC.
};
/* Structure for equations. */
-typedef struct eqn
+typedef struct eqn_d
{
int key;
int touched;
int *coef;
} *eqn;
-typedef struct omega_pb
+typedef struct omega_pb_d
{
/* The number of variables in the system of equations. */
int num_vars;
omega_alloc_eqns (int s, int n)
{
int i;
- eqn res = (eqn) (xcalloc (n, sizeof (struct eqn)));
+ eqn res = (eqn) (xcalloc (n, sizeof (struct eqn_d)));
for (i = n - 1; i >= 0; i--)
{
See expr.h for documentation of these optabs. */
#if GCC_VERSION >= 4000
-__extension__ struct optab optab_table[OTI_MAX]
+__extension__ struct optab_d optab_table[OTI_MAX]
= { [0 ... OTI_MAX - 1].handlers[0 ... NUM_MACHINE_MODES - 1].insn_code
= CODE_FOR_nothing };
#else
/* init_insn_codes will do runtime initialization otherwise. */
-struct optab optab_table[OTI_MAX];
+struct optab_d optab_table[OTI_MAX];
#endif
rtx libfunc_table[LTI_MAX];
/* Tables of patterns for converting one mode to another. */
#if GCC_VERSION >= 4000
-__extension__ struct convert_optab convert_optab_table[COI_MAX]
+__extension__ struct convert_optab_d convert_optab_table[COI_MAX]
= { [0 ... COI_MAX - 1].handlers[0 ... NUM_MACHINE_MODES - 1]
[0 ... NUM_MACHINE_MODES - 1].insn_code
= CODE_FOR_nothing };
#else
/* init_convert_optab will do runtime initialization otherwise. */
-struct convert_optab convert_optab_table[COI_MAX];
+struct convert_optab_d convert_optab_table[COI_MAX];
#endif
/* Contains the optab used for each rtx code. */
{
rtx temp;
optab direct_optab = unsignedp ? uoptab : soptab;
- struct optab wide_soptab;
+ struct optab_d wide_soptab;
/* Do it without widening, if possible. */
temp = expand_binop (mode, direct_optab, op0, op1, target,
/* Definitions for code generation pass of GNU compiler.
- Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
Free Software Foundation, Inc.
This file is part of GCC.
enum insn_code insn_code;
};
-struct optab
+struct optab_d
{
enum rtx_code code;
const char *libcall_basename;
char libcall_suffix;
- void (*libcall_gen)(struct optab *, const char *name, char suffix, enum machine_mode);
+ void (*libcall_gen)(struct optab_d *, const char *name, char suffix,
+ enum machine_mode);
struct optab_handlers handlers[NUM_MACHINE_MODES];
};
-typedef struct optab * optab;
+typedef struct optab_d * optab;
/* A convert_optab is for some sort of conversion operation between
modes. The first array index is the destination mode, the second
is the source mode. */
-struct convert_optab
+struct convert_optab_d
{
enum rtx_code code;
const char *libcall_basename;
- void (*libcall_gen)(struct convert_optab *, const char *name,
+ void (*libcall_gen)(struct convert_optab_d *, const char *name,
enum machine_mode,
enum machine_mode);
struct optab_handlers handlers[NUM_MACHINE_MODES][NUM_MACHINE_MODES];
};
-typedef struct convert_optab *convert_optab;
+typedef struct convert_optab_d *convert_optab;
/* Given an enum insn_code, access the function to construct
the body of that kind of insn. */
OTI_MAX
};
-extern struct optab optab_table[OTI_MAX];
+extern struct optab_d optab_table[OTI_MAX];
#define ssadd_optab (&optab_table[OTI_ssadd])
#define usadd_optab (&optab_table[OTI_usadd])
COI_MAX
};
-extern struct convert_optab convert_optab_table[COI_MAX];
+extern struct convert_optab_d convert_optab_table[COI_MAX];
#define sext_optab (&convert_optab_table[COI_sext])
#define zext_optab (&convert_optab_table[COI_zext])
static void
add_ipa_transform_pass (void *data)
{
- struct ipa_opt_pass *ipa_pass = (struct ipa_opt_pass *) data;
+ struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) data;
VEC_safe_push (ipa_opt_pass, heap, cfun->ipa_transforms_to_apply, ipa_pass);
}
/* Execute summary generation for all of the passes in IPA_PASS. */
static void
-execute_ipa_summary_passes (struct ipa_opt_pass *ipa_pass)
+execute_ipa_summary_passes (struct ipa_opt_pass_d *ipa_pass)
{
while (ipa_pass)
{
ipa_pass->generate_summary ();
pass_fini_dump_file (pass);
}
- ipa_pass = (struct ipa_opt_pass *)ipa_pass->pass.next;
+ ipa_pass = (struct ipa_opt_pass_d *)ipa_pass->pass.next;
}
}
static void
execute_one_ipa_transform_pass (struct cgraph_node *node,
- struct ipa_opt_pass *ipa_pass)
+ struct ipa_opt_pass_d *ipa_pass)
{
struct opt_pass *pass = &ipa_pass->pass;
unsigned int todo_after = 0;
{
if (!quiet_flag && !cfun)
fprintf (stderr, " <summary generate>");
- execute_ipa_summary_passes ((struct ipa_opt_pass *) pass);
+ execute_ipa_summary_passes ((struct ipa_opt_pass_d *) pass);
}
summaries_generated = true;
}
+2009-05-15 Ian Lance Taylor <iant@google.com>
+
+ * gcc.dg/Wcxx-compat-10.c: New testcase.
+
2009-05-15 Manuel López-Ibáñez <manu@gcc.gnu.org>
PR 16302
--- /dev/null
+/* { dg-do compile } */
+/* { dg-options "-Wc++-compat" } */
+
+struct s1 { int f; };
+typedef int s2;
+void
+f1 ()
+{
+ typedef int s1;
+ struct s2 { int f; };
+}
+
+struct s3 { int f; };
+typedef struct s3 s3;
+
+typedef struct s4 s4;
+struct s4 { int f; };
+
+struct s5 { int f; }; /* { dg-message "note: originally defined here" } */
+typedef int s5; /* { dg-warning "invalid in C\[+\]\[+\]" } */
+
+typedef int s6; /* { dg-message "note: originally defined here" } */
+struct s6 { int f; }; /* { dg-warning "invalid in C\[+\]\[+\]" } */
+
+void
+f2 ()
+{
+ struct s7 { int f; }; /* { dg-message "note: originally defined here" } */
+ typedef int s7; /* { dg-warning "invalid in C\[+\]\[+\]" } */
+
+ typedef int s8; /* { dg-message "note: originally defined here" } */
+ struct s8 { int f; }; /* { dg-warning "invalid in C\[+\]\[+\]" } */
+
+ struct s9 { int f; };
+ { typedef int s9; }
+
+ typedef int s10;
+ { struct s10 { int f; }; }
+}
+
+enum e1 { A };
+typedef int e2;
+void
+f3 ()
+{
+ typedef int e1;
+ enum e2 { B };
+}
+
+enum e3 { C };
+typedef enum e3 e3;
+
+enum e5 { E }; /* { dg-message "note: originally defined here" } */
+typedef int e5; /* { dg-warning "invalid in C\[+\]\[+\]" } */
+
+typedef int e6; /* { dg-message "note: originally defined here" } */
+enum e6 { F }; /* { dg-warning "invalid in C\[+\]\[+\]" } */
+
+void
+f4 ()
+{
+ enum e7 { G }; /* { dg-message "note: originally defined here" } */
+ typedef int e7; /* { dg-warning "invalid in C\[+\]\[+\]" } */
+
+ typedef int e8; /* { dg-message "note: originally defined here" } */
+ enum e8 { H }; /* { dg-warning "invalid in C\[+\]\[+\]" } */
+
+ enum e9 { I };
+ { typedef int e9; }
+
+ typedef int e10;
+ { enum e10 { J }; }
+}
/* Callback for for_each_eh_region. Helper for cleanup_dead_labels. */
static void
-update_eh_label (struct eh_region *region)
+update_eh_label (struct eh_region_d *region)
{
tree old_label = get_eh_region_tree_label (region);
if (old_label)
of space by only allocating memory for those that can throw. */
static void
-record_stmt_eh_region (struct eh_region *region, gimple t)
+record_stmt_eh_region (struct eh_region_d *region, gimple t)
{
if (!region)
return;
/* What's "current" while constructing the eh region tree. These
correspond to variables of the same name in cfun->eh, which we
don't have easy access to. */
- struct eh_region *cur_region;
+ struct eh_region_d *cur_region;
/* Processing of TRY_FINALLY requires a bit more state. This is
split out into a separate structure so that we don't have to
struct leh_state *outer;
/* The exception region created for it. */
- struct eh_region *region;
+ struct eh_region_d *region;
/* The goto queue. */
struct goto_queue_node *goto_queue;
static gimple_seq
lower_catch (struct leh_state *state, gimple tp)
{
- struct eh_region *try_region;
+ struct eh_region_d *try_region;
struct leh_state this_state;
gimple_stmt_iterator gsi;
tree out_label;
out_label = NULL;
for (gsi = gsi_start (gimple_try_cleanup (tp)); !gsi_end_p (gsi); )
{
- struct eh_region *catch_region;
+ struct eh_region_d *catch_region;
tree eh_label;
gimple x, gcatch;
lower_eh_filter (struct leh_state *state, gimple tp)
{
struct leh_state this_state;
- struct eh_region *this_region;
+ struct eh_region_d *this_region;
gimple inner;
tree eh_label;
lower_cleanup (struct leh_state *state, gimple tp)
{
struct leh_state this_state;
- struct eh_region *this_region;
+ struct eh_region_d *this_region;
struct leh_tf_state fake_tf;
gimple_seq result;
/* Construct EH edges for STMT. */
static void
-make_eh_edge (struct eh_region *region, void *data)
+make_eh_edge (struct eh_region_d *region, void *data)
{
gimple stmt;
tree lab;
bool is_resx;
bool inlinable = false;
tree label = gimple_block_label (new_bb);
- struct eh_region *r;
+ struct eh_region_d *r;
if (gimple_code (stmt) == GIMPLE_RESX)
{
field, output error if something goes wrong. */
static void
-mark_eh_edge (struct eh_region *region, void *data)
+mark_eh_edge (struct eh_region_d *region, void *data)
{
gimple stmt;
tree lab;
operands from DATA->bb_to_remove. */
static void
-make_eh_edge_and_update_phi (struct eh_region *region, void *data)
+make_eh_edge_and_update_phi (struct eh_region_d *region, void *data)
{
struct update_info *info = (struct update_info *) data;
edge e, e2;
/* Description of IPA pass with generate summary, write, execute, read and
transform stages. */
-struct ipa_opt_pass
+struct ipa_opt_pass_d
{
struct opt_pass pass;
extern struct gimple_opt_pass pass_tracer;
/* IPA Passes */
-extern struct ipa_opt_pass pass_ipa_inline;
-extern struct ipa_opt_pass pass_ipa_cp;
-extern struct ipa_opt_pass pass_ipa_reference;
-extern struct ipa_opt_pass pass_ipa_pure_const;
+extern struct ipa_opt_pass_d pass_ipa_inline;
+extern struct ipa_opt_pass_d pass_ipa_cp;
+extern struct ipa_opt_pass_d pass_ipa_reference;
+extern struct ipa_opt_pass_d pass_ipa_pure_const;
extern struct simple_ipa_opt_pass pass_ipa_matrix_reorg;
extern struct simple_ipa_opt_pass pass_ipa_early_inline;
/* Predictive commoning.
- Copyright (C) 2005, 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
This file is part of GCC.
/* Data references (or phi nodes that carry data reference values across
loop iterations). */
-typedef struct dref
+typedef struct dref_d
{
/* The reference itself. */
struct data_reference *ref;
comps[ca] = comp;
}
- dataref = XCNEW (struct dref);
+ dataref = XCNEW (struct dref_d);
dataref->ref = dr;
dataref->stmt = DR_STMT (dr);
dataref->offset = double_int_zero;
static void
insert_looparound_copy (chain_p chain, dref ref, gimple phi)
{
- dref nw = XCNEW (struct dref), aref;
+ dref nw = XCNEW (struct dref_d), aref;
unsigned i;
nw->stmt = phi;
for (i = 0; (VEC_iterate (dref, ch1->refs, i, r1)
&& VEC_iterate (dref, ch2->refs, i, r2)); i++)
{
- nw = XCNEW (struct dref);
+ nw = XCNEW (struct dref_d);
nw->stmt = stmt_combining_refs (r1, r2);
nw->distance = r1->distance;
+2009-05-15 Ian Lance Taylor <iant@google.com>
+
+ * include/cpplib.h (enum cpp_builtin_type): Rename from enum
+ builtin_type. Change all uses.
+
2009-05-14 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
PR cpp/36674
/* Different flavors of builtin macro. _Pragma is an operator, but we
handle it with the builtin code for efficiency reasons. */
-enum builtin_type
+enum cpp_builtin_type
{
BT_SPECLINE = 0, /* `__LINE__' */
BT_DATE, /* `__DATE__' */
/* Answers to an assertion. */
struct answer * GTY ((tag ("NTV_ANSWER"))) answers;
/* Code for a builtin macro. */
- enum builtin_type GTY ((tag ("NTV_BUILTIN"))) builtin;
+ enum cpp_builtin_type GTY ((tag ("NTV_BUILTIN"))) builtin;
/* Macro argument index. */
unsigned short GTY ((tag ("NTV_ARGUMENT"))) arg_index;
};
if (b->always_warn_if_redefined
|| CPP_OPTION (pfile, warn_builtin_macro_redefined))
hp->flags |= NODE_WARN;
- hp->value.builtin = (enum builtin_type) b->value;
+ hp->value.builtin = (enum cpp_builtin_type) b->value;
}
}
OSDN Git Service
