+2013-12-10 Oleg Endo <olegendo@gcc.gnu.org>
+
+ * gcc/cgraph.h (cgraph_node_set_iterator, varpool_node_set_iterator):
+ Remove typedef.
+ (cgraph_inline_failed_enum, cgraph_inline_failed_t): Remove typedef and
+ rename to cgraph_inline_failed_t.
+ * gcc/tree-ssa-alias.h (ao_ref_s, ao_ref): Remove typedef and rename
+ to ao_ref.
+ * gcc/reload.h (reg_equivs_s, reg_equivs_t): Remove typedef and rename
+ to reg_equivs_t.
+ * gcc/conditions.h (CC_STATUS): Remove typedef.
+ * gcc/bitmap.h (bitmap_obstack): Remove typedef.
+ (bitmap_element_def, bitmap_element): Remove typedef and rename to
+ bitmap_element.
+ (bitmap_head_def, bitmap_head): Remove typedef and rename to
+ bitmap_head.
+ (bitmap_iterator): Remove typedef.
+ * gcc/target.h (cumulative_args_t, print_switch_type,
+ secondary_reload_info): Remove typedef.
+ * gcc/dwarf2out.h (dw_cfi_oprnd_struct, dw_cfi_oprnd): Remove
+ dw_cfi_oprnd_struct alias.
+ (dw_cfi_struct, dw_cfi_node): Remove typedef and rename to dw_cfi_node.
+ (dw_fde_struct, dw_fde_node): Remove typedef and rename to dw_fde_node.
+ (cfa_loc, dw_cfa_location): Remove typedef and rename to
+ dw_cfa_location.
+ (dw_vec_struct, dw_vec_const): Remove typedef and rename to
+ dw_vec_const.
+ (dw_val_struct, dw_val_node): Remove typedef and rename to dw_val_node.
+ (dw_loc_descr_struct, dw_loc_descr_node): Remove typedef and rename to
+ dw_loc_descr_node.
+ * gcc/params.h (param_info, compiler_param): Remove typedef.
+ * gcc/opts.h (cl_deferred_param): Remove typedef.
+ * gcc/sreal.h (sreal): Remove typedef.
+ * gcc/ddg.h (dep_type, dep_data_type): Remove typedef.
+ * gcc/graphite-clast-to-gimple.h (cloog_prog_clast, bb_pbb_def): Remove
+ typedef.
+ * gcc/lto-streamer.h (lto_decl_stream_e_t, lto_encoder_entry,
+ lto_symtab_encoder_iterator, res_pair): Remove typedef.
+ * gcc/tree-affine.h (affine_tree_combination, aff_tree): Remove typedef
+ and rename to aff_tree.
+ * gcc/sched-int.h (region): Remove typedef.
+ * gcc/diagnostic.h (diagnostic_info,
+ diagnostic_classification_change_t): Remove typedef.
+ * gcc/tree-ssa-loop.h (affine_iv_d): Remove typedef and rename to
+ affine_iv.
+ * gcc/sbitmap.h (sbitmap_iterator): Remove typedef.
+ * gcc/ssa-iterators.h (immediate_use_iterator_d, imm_use_iterator):
+ Remove typedef and rename to imm_use_iterator.
+ (ssa_operand_iterator_d, ssa_op_iter): Remove typedef and rename to
+ ssa_op_iter.
+ * gcc/ggc-internal.h (ggc_statistics): Remove typedef.
+ * gcc/cselib.h (cselib_val_struct, cselib_val): Remove typedef and
+ rename to cselib_val.
+ * gcc/tree-core.h (alias_pair): Remove typedef.
+ (constructor_elt_d, constructor_elt): Remove typedef and rename to
+ constructor_elt.
+ (ssa_use_operand_d, ssa_use_operand_t): Remove typedef and rename to
+ ssa_use_operand_t.
+ * gcc/graphite-sese-to-poly.h (base_alias_pair): Remove typedef.
+ * gcc/tree-data-ref.h (conflict_function): Remove typedef.
+ * gcc/tree-inline.h (copy_body_data): Remove typedef.
+ * gcc/ipa-inline.h (condition, size_time_entry, inline_param_summary_t,
+ edge_growth_cache_entry): Remove typedef.
+ * gcc/regrename.h (operand_rr_info, insn_rr_info): Remove typedef.
+ * gcc/gimple-iterator.h (gimple_stmt_iterator_d, gimple_stmt_iterator):
+ Remove typedef and rename to gimple_stmt_iterator.
+ * gcc/basic-block.h (ce_if_block, ce_if_block_t): Remove typedef and
+ rename to ce_if_block.
+ (edge_iterator): Remove typedef.
+ * gcc/ipa-prop.h (ipa_agg_jf_item, ipa_agg_jf_item_t): Remove typedef
+ and rename to ipa_agg_jf_item.
+ (ipa_agg_jump_function_t, ipa_param_descriptor_t, ipa_node_params_t,
+ ipa_parm_adjustment_t): Remove typedef.
+ (ipa_jump_func, ipa_jump_func_t): Remove typedef and rename to
+ ipa_jump_func.
+ (ipa_edge_args, ipa_edge_args_t): Remove typedef and rename to
+ ipa_edge_args.
+ * gcc/gcov-io.h (gcov_bucket_type): Remove typedef.
+ (gcov_working_set_info, gcov_working_set_t): Remove typedef and rename
+ to gcov_working_set_t.
+ * gcc/ira-int.h (minmax_set_iterator, ira_allocno_iterator,
+ ira_object_iterator, ira_allocno_object_iterator, ira_pref_iterator,
+ ira_copy_iterator, ira_object_conflict_iterator): Remove typedef.
+ * gcc/tree-iterator.h (tree_stmt_iterator): Remove typedef.
+ * gcc/rtl.h (addr_diff_vec_flags, mem_attrs, reg_attrs,
+ replace_label_data): Remove typedef.
+ (rtunion_def, rtunion): Remove typedef and rename to rtunion.
+ * gcc/hard-reg-set.h (hard_reg_set_iterator): Remove typedef.
+ * gcc/sel-sched-ir.h (_list_iterator, sel_global_bb_info_def,
+ sel_region_bb_info_def, succ_iterator): Remove typedef.
+ (deps_where_def, deps_where_t): Remove typedef and rename to
+ deps_where_t.
+ * gcc/coretypes.h: Adapt forward declarations.
+ * gcc/tree-scalar-evolution.h: Likewise.
+ * gcc/tree-ssa-address.h: Likewise.
+ * gcc/tree-ssa-operands.h: Likewise.
+ * gcc/function.h: Likewise.
+ * gcc/config/frv/frv-protos.h: Likewise.
+ * gcc/targhooks.h: Likewise.
+ * gcc/basic_block.h: Likewise.
+ * gcc/rtl.def: Adapt documentation.
+ * gcc/doc/tm.texi: Likewise.
+ * gcc/ipa-cp.c: Adapt uses.
+ * gcc/bitmap.c: Likewise.
+ * gcc/dwarf2out.c: Likewise.
+ * gcc/target.def: Likewise.
+ * gcc/ipa-inline-analysis.c: Likewise.
+ * gcc/dwarf2cfi.c: Likewise.
+ * gcc/tree-ssa-loop-ivopts.c: Likewise.
+ * gcc/lto-cgraph.c: Likewise.
+ * gcc/config/frv/frv.c: Likewise.
+ * gcc/ifcvt.c: Likewise.
+ * gcc/ipa-prop.c: Likewise.
+
2013-12-10 Kai Tietz <ktietz@redhat.com>
PR target/56807
needs to be in a public file in case the IFCVT macros call
functions passing the ce_if_block data structure. */
-typedef struct ce_if_block
+struct ce_if_block
{
basic_block test_bb; /* First test block. */
basic_block then_bb; /* THEN block. */
int num_then_insns; /* # of insns in THEN block. */
int num_else_insns; /* # of insns in ELSE block. */
int pass; /* Pass number. */
-} ce_if_block_t;
+};
/* This structure maintains an edge list vector. */
/* FIXME: Make this a vec<edge>. */
/* Iterator object for edges. */
-typedef struct {
+struct edge_iterator {
unsigned index;
vec<edge, va_gc> **container;
-} edge_iterator;
+};
static inline vec<edge, va_gc> *
ei_container (edge_iterator i)
extern int dfs_enumerate_from (basic_block, int,
bool (*)(const_basic_block, const void *),
basic_block *, int, const void *);
-extern void compute_dominance_frontiers (struct bitmap_head_def *);
-extern bitmap compute_idf (bitmap, struct bitmap_head_def *);
+extern void compute_dominance_frontiers (struct bitmap_head *);
+extern bitmap compute_idf (bitmap, struct bitmap_head *);
extern basic_block * single_pred_before_succ_order (void);
/* In cfgrtl.c */
extern void default_rtl_profile (void);
/* In profile.c. */
-typedef struct gcov_working_set_info gcov_working_set_t;
+struct gcov_working_set_t;
extern gcov_working_set_t *find_working_set (unsigned pct_times_10);
/* Check tha probability is sane. */
/* Inner list was just a singleton. */
bitmap_ggc_free = element->prev;
else
- element = ggc_alloc_bitmap_element_def ();
+ element = ggc_alloc_bitmap_element ();
}
if (GATHER_STATISTICS)
bit_obstack = &bitmap_default_obstack;
map = bit_obstack->heads;
if (map)
- bit_obstack->heads = (struct bitmap_head_def *) map->first;
+ bit_obstack->heads = (struct bitmap_head *) map->first;
else
map = XOBNEW (&bit_obstack->obstack, bitmap_head);
bitmap_initialize_stat (map, bit_obstack PASS_MEM_STAT);
{
bitmap map;
- map = ggc_alloc_bitmap_head_def ();
+ map = ggc_alloc_bitmap_head ();
bitmap_initialize_stat (map, NULL PASS_MEM_STAT);
if (GATHER_STATISTICS)
}
DEBUG_FUNCTION void
-debug (const bitmap_head_def &ref)
+debug (const bitmap_head &ref)
{
dump_bitmap (stderr, &ref);
}
DEBUG_FUNCTION void
-debug (const bitmap_head_def *ptr)
+debug (const bitmap_head *ptr)
{
if (ptr)
debug (*ptr);
This sparse set representation is suitable for sparse sets with an
unknown (a priori) universe. The set is represented as a double-linked
- list of container nodes (struct bitmap_element_def). Each node consists
+ list of container nodes (struct bitmap_element). Each node consists
of an index for the first member that could be held in the container,
a small array of integers that represent the members in the container,
and pointers to the next and previous element in the linked list. The
#define BITMAP_ELEMENT_ALL_BITS (BITMAP_ELEMENT_WORDS * BITMAP_WORD_BITS)
/* Obstack for allocating bitmaps and elements from. */
-typedef struct GTY (()) bitmap_obstack {
- struct bitmap_element_def *elements;
- struct bitmap_head_def *heads;
+struct GTY (()) bitmap_obstack {
+ struct bitmap_element *elements;
+ struct bitmap_head *heads;
struct obstack GTY ((skip)) obstack;
-} bitmap_obstack;
+};
/* Bitmap set element. We use a linked list to hold only the bits that
are set. This allows for use to grow the bitset dynamically without
bitmap_elt_clear_from to be implemented in unit time rather than
linear in the number of elements to be freed. */
-typedef struct GTY((chain_next ("%h.next"), chain_prev ("%h.prev"))) bitmap_element_def {
- struct bitmap_element_def *next; /* Next element. */
- struct bitmap_element_def *prev; /* Previous element. */
+struct GTY((chain_next ("%h.next"), chain_prev ("%h.prev"))) bitmap_element {
+ struct bitmap_element *next; /* Next element. */
+ struct bitmap_element *prev; /* Previous element. */
unsigned int indx; /* regno/BITMAP_ELEMENT_ALL_BITS. */
BITMAP_WORD bits[BITMAP_ELEMENT_WORDS]; /* Bits that are set. */
-} bitmap_element;
+};
/* Head of bitmap linked list. The 'current' member points to something
already pointed to by the chain started by first, so GTY((skip)) it. */
-typedef struct GTY(()) bitmap_head_def {
+struct GTY(()) bitmap_head {
unsigned int indx; /* Index of last element looked at. */
unsigned int descriptor_id; /* Unique identifier for the allocation
site of this bitmap, for detailed
bitmap_element * GTY((skip(""))) current; /* Last element looked at. */
bitmap_obstack *obstack; /* Obstack to allocate elements from.
If NULL, then use GGC allocation. */
-} bitmap_head;
+};
/* Global data */
extern bitmap_element bitmap_zero_bits; /* Zero bitmap element */
{
bitmap_print (file, map, "", "\n");
}
-extern void debug (const bitmap_head_def &ref);
-extern void debug (const bitmap_head_def *ptr);
+extern void debug (const bitmap_head &ref);
+extern void debug (const bitmap_head *ptr);
extern unsigned bitmap_first_set_bit (const_bitmap);
extern unsigned bitmap_last_set_bit (const_bitmap);
/* Iterator for bitmaps. */
-typedef struct
+struct bitmap_iterator
{
/* Pointer to the current bitmap element. */
bitmap_element *elt1;
it is shifted right, so that the actual bit is always the least
significant bit of ACTUAL. */
BITMAP_WORD bits;
-} bitmap_iterator;
+};
/* Initialize a single bitmap iterator. START_BIT is the first bit to
iterate from. */
/* Iterator structure for cgraph node sets. */
-typedef struct
+struct cgraph_node_set_iterator
{
cgraph_node_set set;
unsigned index;
-} cgraph_node_set_iterator;
+};
/* Iterator structure for varpool node sets. */
-typedef struct
+struct varpool_node_set_iterator
{
varpool_node_set set;
unsigned index;
-} varpool_node_set_iterator;
+};
#define DEFCIFCODE(code, string) CIF_ ## code,
/* Reasons for inlining failures. */
-typedef enum cgraph_inline_failed_enum {
+enum cgraph_inline_failed_t {
#include "cif-code.def"
CIF_N_REASONS
-} cgraph_inline_failed_t;
+};
/* Structure containing additional information about an indirect call. */
PTR GTY ((skip (""))) aux;
/* When equal to CIF_OK, inline this call. Otherwise, points to the
explanation why function was not inlined. */
- cgraph_inline_failed_t inline_failed;
+ enum cgraph_inline_failed_t inline_failed;
/* The stmt_uid of call_stmt. This is used by LTO to recover the call_stmt
when the function is serialized in. */
unsigned int lto_stmt_uid;
#define CC_STATUS_MDEP_INIT 0
#endif
-typedef struct {int flags; rtx value1, value2; CC_STATUS_MDEP mdep;} CC_STATUS;
+struct CC_STATUS {int flags; rtx value1, value2; CC_STATUS_MDEP mdep;};
/* While outputting an insn as assembler code,
this is the status BEFORE that insn. */
extern void frv_split_double_load (rtx, rtx);
extern void frv_split_double_store (rtx, rtx);
#ifdef BB_HEAD
-extern void frv_ifcvt_init_extra_fields (ce_if_block_t *);
-extern void frv_ifcvt_modify_tests (ce_if_block_t *, rtx *, rtx *);
+extern void frv_ifcvt_init_extra_fields (ce_if_block *);
+extern void frv_ifcvt_modify_tests (ce_if_block *, rtx *, rtx *);
extern void frv_ifcvt_modify_multiple_tests
- (ce_if_block_t *, basic_block,
+ (ce_if_block *, basic_block,
rtx *, rtx *);
-extern rtx frv_ifcvt_modify_insn (ce_if_block_t *, rtx, rtx);
-extern void frv_ifcvt_modify_final (ce_if_block_t *);
-extern void frv_ifcvt_modify_cancel (ce_if_block_t *);
+extern rtx frv_ifcvt_modify_insn (ce_if_block *, rtx, rtx);
+extern void frv_ifcvt_modify_final (ce_if_block *);
+extern void frv_ifcvt_modify_cancel (ce_if_block *);
#endif
extern enum reg_class frv_secondary_reload_class
(enum reg_class,
tests cannot be converted. */
void
-frv_ifcvt_modify_tests (ce_if_block_t *ce_info, rtx *p_true, rtx *p_false)
+frv_ifcvt_modify_tests (ce_if_block *ce_info, rtx *p_true, rtx *p_false)
{
basic_block test_bb = ce_info->test_bb; /* test basic block */
basic_block then_bb = ce_info->then_bb; /* THEN */
(const_int 0))) */
void
-frv_ifcvt_modify_multiple_tests (ce_if_block_t *ce_info,
+frv_ifcvt_modify_multiple_tests (ce_if_block *ce_info,
basic_block bb,
rtx *p_true,
rtx *p_false)
insn cannot be converted to be executed conditionally. */
rtx
-frv_ifcvt_modify_insn (ce_if_block_t *ce_info,
+frv_ifcvt_modify_insn (ce_if_block *ce_info,
rtx pattern,
rtx insn)
{
conditional if information CE_INFO. */
void
-frv_ifcvt_modify_final (ce_if_block_t *ce_info ATTRIBUTE_UNUSED)
+frv_ifcvt_modify_final (ce_if_block *ce_info ATTRIBUTE_UNUSED)
{
rtx existing_insn;
rtx check_insn;
information CE_INFO. */
void
-frv_ifcvt_modify_cancel (ce_if_block_t *ce_info ATTRIBUTE_UNUSED)
+frv_ifcvt_modify_cancel (ce_if_block *ce_info ATTRIBUTE_UNUSED)
{
int i;
rtx p = frv_ifcvt.added_insns_list;
typedef HOST_WIDEST_INT gcov_type;
typedef unsigned HOST_WIDEST_INT gcov_type_unsigned;
-struct bitmap_head_def;
-typedef struct bitmap_head_def *bitmap;
-typedef const struct bitmap_head_def *const_bitmap;
+struct bitmap_head;
+typedef struct bitmap_head *bitmap;
+typedef const struct bitmap_head *const_bitmap;
struct simple_bitmap_def;
typedef struct simple_bitmap_def *sbitmap;
typedef const struct simple_bitmap_def *const_sbitmap;
typedef struct gimple_statement_base *gimple;
typedef const struct gimple_statement_base *const_gimple;
typedef gimple gimple_seq;
-struct gimple_stmt_iterator_d;
-typedef struct gimple_stmt_iterator_d gimple_stmt_iterator;
+struct gimple_stmt_iterator;
union section;
typedef union section section;
struct gcc_options;
<http://www.gnu.org/licenses/>. */
/* Describe a value. */
-typedef struct cselib_val_struct {
+struct cselib_val {
/* The hash value. */
unsigned int hash;
use it as an address in a MEM. */
struct elt_list *addr_list;
- struct cselib_val_struct *next_containing_mem;
-} cselib_val;
+ struct cselib_val *next_containing_mem;
+};
/* A list of rtl expressions that hold the same value. */
struct elt_loc_list {
typedef struct ddg_scc *ddg_scc_ptr;
typedef struct ddg_all_sccs *ddg_all_sccs_ptr;
-typedef enum {TRUE_DEP, OUTPUT_DEP, ANTI_DEP} dep_type;
-typedef enum {REG_OR_MEM_DEP, REG_DEP, MEM_DEP, REG_AND_MEM_DEP}
- dep_data_type;
+enum dep_type {TRUE_DEP, OUTPUT_DEP, ANTI_DEP};
+enum dep_data_type {REG_OR_MEM_DEP, REG_DEP, MEM_DEP, REG_AND_MEM_DEP};
/* The following two macros enables direct access to the successors and
predecessors bitmaps held in each ddg_node. Do not make changes to
/* A diagnostic is described by the MESSAGE to send, the FILE and LINE of
its context and its KIND (ice, error, warning, note, ...) See complete
list in diagnostic.def. */
-typedef struct diagnostic_info
+struct diagnostic_info
{
text_info message;
location_t location;
diagnostic_t kind;
/* Which OPT_* directly controls this diagnostic. */
int option_index;
-} diagnostic_info;
+};
/* Each time a diagnostic's classification is changed with a pragma,
we record the change and the location of the change in an array of
these structs. */
-typedef struct diagnostic_classification_change_t
+struct diagnostic_classification_change_t
{
location_t location;
int option;
diagnostic_t kind;
-} diagnostic_classification_change_t;
+};
/* Forward declarations. */
typedef void (*diagnostic_starter_fn) (diagnostic_context *,
hook returns true for both @code{ptr_mode} and @code{Pmode}.
@end deftypefn
-@deftypefn {Target Hook} bool TARGET_REF_MAY_ALIAS_ERRNO (struct ao_ref_s *@var{ref})
+@deftypefn {Target Hook} bool TARGET_REF_MAY_ALIAS_ERRNO (struct ao_ref *@var{ref})
Define this to return nonzero if the memory reference @var{ref} may alias with the system C library errno location. The default version of this hook assumes the system C library errno location is either a declaration of type int or accessed by dereferencing a pointer to int.
@end deftypefn
descriptor sequence. */
static void
-get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
+get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_node *loc)
{
- struct dw_loc_descr_struct *ptr;
+ struct dw_loc_descr_node *ptr;
cfa->offset = 0;
cfa->base_offset = 0;
cfa->indirect = 0;
/* Construct a DW_CFA_def_cfa_expression instruction to
calculate the CFA using a full location expression since no
register-offset pair is available. */
- struct dw_loc_descr_struct *loc_list;
+ struct dw_loc_descr_node *loc_list;
cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
loc_list = build_cfa_loc (new_cfa, 0);
dw_cfa_location, adding the given OFFSET to the result of the
expression. */
-struct dw_loc_descr_struct *
+struct dw_loc_descr_node *
build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
{
- struct dw_loc_descr_struct *head, *tmp;
+ struct dw_loc_descr_node *head, *tmp;
offset += cfa->offset;
the address at OFFSET from the CFA when stack is aligned to
ALIGNMENT byte. */
-struct dw_loc_descr_struct *
+struct dw_loc_descr_node *
build_cfa_aligned_loc (dw_cfa_location *cfa,
HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
{
- struct dw_loc_descr_struct *head;
+ struct dw_loc_descr_node *head;
unsigned int dwarf_fp
= DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
typedef struct die_struct *dw_die_ref;
typedef const struct die_struct *const_dw_die_ref;
-typedef struct dw_val_struct *dw_val_ref;
-typedef struct dw_cfi_struct *dw_cfi_ref;
-typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
+typedef struct dw_val_node *dw_val_ref;
+typedef struct dw_cfi_node *dw_cfi_ref;
+typedef struct dw_loc_descr_node *dw_loc_descr_ref;
typedef struct dw_loc_list_struct *dw_loc_list_ref;
dw_cfi_oprnd_loc
};
-typedef union GTY(()) dw_cfi_oprnd_struct {
+typedef union GTY(()) {
unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
- struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
-}
-dw_cfi_oprnd;
+ struct dw_loc_descr_node * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
+} dw_cfi_oprnd;
-typedef struct GTY(()) dw_cfi_struct {
+struct GTY(()) dw_cfi_node {
enum dwarf_call_frame_info dw_cfi_opc;
dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
dw_cfi_oprnd1;
dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
dw_cfi_oprnd2;
-}
-dw_cfi_node;
+};
typedef vec<dw_cfi_ref, va_gc> *cfi_vec;
-typedef struct dw_fde_struct *dw_fde_ref;
+typedef struct dw_fde_node *dw_fde_ref;
/* All call frame descriptions (FDE's) in the GCC generated DWARF
refer to a single Common Information Entry (CIE), defined at
CIE obviates the need to keep track of multiple CIE's
in the DWARF generation routines below. */
-typedef struct GTY(()) dw_fde_struct {
+struct GTY(()) dw_fde_node {
tree decl;
const char *dw_fde_begin;
const char *dw_fde_current_label;
/* True iff dw_fde_second_begin label is in text_section or
cold_text_section. */
unsigned second_in_std_section : 1;
-}
-dw_fde_node;
+};
/* This is how we define the location of the CFA. We use to handle it
It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
Instead of passing around REG and OFFSET, we pass a copy
of this structure. */
-typedef struct GTY(()) cfa_loc {
+struct GTY(()) dw_cfa_location {
HOST_WIDE_INT offset;
HOST_WIDE_INT base_offset;
/* REG is in DWARF_FRAME_REGNUM space, *not* normal REGNO space. */
unsigned int reg;
BOOL_BITFIELD indirect : 1; /* 1 if CFA is accessed via a dereference. */
BOOL_BITFIELD in_use : 1; /* 1 if a saved cfa is stored here. */
-} dw_cfa_location;
+};
/* Each DIE may have a series of attribute/value pairs. Values
/* Describe a floating point constant value, or a vector constant value. */
-typedef struct GTY(()) dw_vec_struct {
+struct GTY(()) dw_vec_const {
unsigned char * GTY((atomic)) array;
unsigned length;
unsigned elt_size;
-}
-dw_vec_const;
+};
struct addr_table_entry_struct;
/* The dw_val_node describes an attribute's value, as it is
represented internally. */
-typedef struct GTY(()) dw_val_struct {
+struct GTY(()) dw_val_node {
enum dw_val_class val_class;
struct addr_table_entry_struct * GTY(()) val_entry;
union dw_val_struct_union
} GTY ((tag ("dw_val_class_vms_delta"))) val_vms_delta;
}
GTY ((desc ("%1.val_class"))) v;
-}
-dw_val_node;
+};
/* Locations in memory are described using a sequence of stack machine
operations. */
-typedef struct GTY(()) dw_loc_descr_struct {
+struct GTY(()) dw_loc_descr_node {
dw_loc_descr_ref dw_loc_next;
ENUM_BITFIELD (dwarf_location_atom) dw_loc_opc : 8;
/* Used to distinguish DW_OP_addr with a direct symbol relocation
int dw_loc_addr;
dw_val_node dw_loc_oprnd1;
dw_val_node dw_loc_oprnd2;
-}
-dw_loc_descr_node;
+};
/* Interface from dwarf2out.c to dwarf2cfi.c. */
-extern struct dw_loc_descr_struct *build_cfa_loc
+extern struct dw_loc_descr_node *build_cfa_loc
(dw_cfa_location *, HOST_WIDE_INT);
-extern struct dw_loc_descr_struct *build_cfa_aligned_loc
+extern struct dw_loc_descr_node *build_cfa_aligned_loc
(dw_cfa_location *, HOST_WIDE_INT offset, HOST_WIDE_INT alignment);
-extern struct dw_loc_descr_struct *mem_loc_descriptor
+extern struct dw_loc_descr_node *mem_loc_descriptor
(rtx, enum machine_mode mode, enum machine_mode mem_mode,
enum var_init_status);
extern bool loc_descr_equal_p (dw_loc_descr_ref, dw_loc_descr_ref);
extern enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
(enum dwarf_call_frame_info cfi);
-extern void output_cfi_directive (FILE *f, struct dw_cfi_struct *cfi);
+extern void output_cfi_directive (FILE *f, struct dw_cfi_node *cfi);
extern void dwarf2out_decl (tree);
extern void dwarf2out_emit_cfi (dw_cfi_ref cfi);
struct temp_slot;
typedef struct temp_slot *temp_slot_p;
struct call_site_record_d;
-struct dw_fde_struct;
+struct dw_fde_node;
class ipa_opt_pass_d;
typedef ipa_opt_pass_d *ipa_opt_pass;
/* Dwarf2 Frame Description Entry, containing the Call Frame Instructions
used for unwinding. Only set when either dwarf2 unwinding or dwarf2
debugging is enabled. */
- struct dw_fde_struct *fde;
+ struct dw_fde_node *fde;
/* Last statement uid. */
int last_stmt_uid;
/* Structured records. */
/* Structure used for each bucket of the log2 histogram of counter values. */
-typedef struct
+struct gcov_bucket_type
{
/* Number of counters whose profile count falls within the bucket. */
gcov_unsigned_t num_counters;
gcov_type min_value;
/* Cumulative value of the profile counts in this bucket. */
gcov_type cum_value;
-} gcov_bucket_type;
+};
/* For a log2 scale histogram with each range split into 4
linear sub-ranges, there will be at most 64 (max gcov_type bit size) - 1 log2
/* Working set size statistics for a given percentage of the entire
profile (sum_all from the counter summary). */
-typedef struct gcov_working_set_info
+struct gcov_working_set_t
{
/* Number of hot counters included in this working set. */
unsigned num_counters;
/* Smallest counter included in this working set. */
gcov_type min_counter;
-} gcov_working_set_t;
+};
GCOV_LINKAGE void compute_working_sets (const struct gcov_ctr_summary *summary,
gcov_working_set_t *gcov_working_sets);
/* This structure contains the statistics common to all collectors.
Particular collectors can extend this structure. */
-typedef struct ggc_statistics
+struct ggc_statistics
{
/* At present, we don't really gather any interesting statistics. */
int unused;
-} ggc_statistics;
+};
/* Used by the various collectors to gather and print statistics that
do not depend on the collector in use. */
/* Iterator object for GIMPLE statement sequences. */
-typedef struct gimple_stmt_iterator_d
+struct gimple_stmt_iterator
{
/* Sequence node holding the current statement. */
gimple_seq_node ptr;
block/sequence is removed. */
gimple_seq *seq;
basic_block bb;
-} gimple_stmt_iterator;
+};
enum gsi_iterator_update
{
/* Data structure for CLooG program representation. */
-typedef struct cloog_prog_clast {
+struct cloog_prog_clast {
CloogProgram *prog;
struct clast_stmt *stmt;
-} cloog_prog_clast;
+};
/* Stores BB's related PBB. */
-typedef struct bb_pbb_def
+struct bb_pbb_def
{
basic_block bb;
poly_bb_p pbb;
-} bb_pbb_def;
+};
extern void debug_clast_stmt (struct clast_stmt *);
extern void print_clast_stmt (FILE *, struct clast_stmt *);
#ifndef GCC_GRAPHITE_SESE_TO_POLY_H
#define GCC_GRAPHITE_SESE_TO_POLY_H
-typedef struct base_alias_pair base_alias_pair;
struct base_alias_pair
{
int base_obj_set;
/* Iterator for hard register sets. */
-typedef struct
+struct hard_reg_set_iterator
{
/* Pointer to the current element. */
HARD_REG_ELT_TYPE *pelt;
it is shifted right, so that the actual bit is always the least
significant bit of ACTUAL. */
HARD_REG_ELT_TYPE bits;
-} hard_reg_set_iterator;
+};
#define HARD_REG_ELT_BITS UHOST_BITS_PER_WIDE_INT
static rtx find_active_insn_before (basic_block, rtx);
static rtx find_active_insn_after (basic_block, rtx);
static basic_block block_fallthru (basic_block);
-static int cond_exec_process_insns (ce_if_block_t *, rtx, rtx, rtx, int, int);
+static int cond_exec_process_insns (ce_if_block *, rtx, rtx, rtx, int, int);
static rtx cond_exec_get_condition (rtx);
static rtx noce_get_condition (rtx, rtx *, bool);
static int noce_operand_ok (const_rtx);
-static void merge_if_block (ce_if_block_t *);
+static void merge_if_block (ce_if_block *);
static int find_cond_trap (basic_block, edge, edge);
static basic_block find_if_header (basic_block, int);
static int block_jumps_and_fallthru_p (basic_block, basic_block);
static int noce_find_if_block (basic_block, edge, edge, int);
-static int cond_exec_find_if_block (ce_if_block_t *);
+static int cond_exec_find_if_block (ce_if_block *);
static int find_if_case_1 (basic_block, edge, edge);
static int find_if_case_2 (basic_block, edge, edge);
static int dead_or_predicable (basic_block, basic_block, basic_block,
insns were processed. */
static int
-cond_exec_process_insns (ce_if_block_t *ce_info ATTRIBUTE_UNUSED,
+cond_exec_process_insns (ce_if_block *ce_info ATTRIBUTE_UNUSED,
/* if block information */rtx start,
/* first insn to look at */rtx end,
/* last insn to look at */rtx test,
converting the block. */
static int
-cond_exec_process_if_block (ce_if_block_t * ce_info,
+cond_exec_process_if_block (ce_if_block * ce_info,
/* if block information */int do_multiple_p)
{
basic_block test_bb = ce_info->test_bb; /* last test block */
static basic_block
find_if_header (basic_block test_bb, int pass)
{
- ce_if_block_t ce_info;
+ ce_if_block ce_info;
edge then_edge;
edge else_edge;
/* Return all context independent values from aggregate lattices in PLATS in a
vector. Return NULL if there are none. */
-static vec<ipa_agg_jf_item_t, va_gc> *
+static vec<ipa_agg_jf_item, va_gc> *
context_independent_aggregate_values (struct ipcp_param_lattices *plats)
{
- vec<ipa_agg_jf_item_t, va_gc> *res = NULL;
+ vec<ipa_agg_jf_item, va_gc> *res = NULL;
if (plats->aggs_bottom
|| plats->aggs_contain_variable
gather_context_independent_values (struct ipa_node_params *info,
vec<tree> *known_csts,
vec<tree> *known_binfos,
- vec<ipa_agg_jump_function_t> *known_aggs,
+ vec<ipa_agg_jump_function> *known_aggs,
int *removable_params_cost)
{
int i, count = ipa_get_param_count (info);
if (known_aggs)
{
- vec<ipa_agg_jf_item_t, va_gc> *agg_items;
+ vec<ipa_agg_jf_item, va_gc> *agg_items;
struct ipa_agg_jump_function *ajf;
agg_items = context_independent_aggregate_values (plats);
issue. */
static vec<ipa_agg_jump_function_p>
-agg_jmp_p_vec_for_t_vec (vec<ipa_agg_jump_function_t> known_aggs)
+agg_jmp_p_vec_for_t_vec (vec<ipa_agg_jump_function> known_aggs)
{
vec<ipa_agg_jump_function_p> ret;
struct ipa_agg_jump_function *ajf;
struct ipa_node_params *info = IPA_NODE_REF (node);
int i, count = ipa_get_param_count (info);
vec<tree> known_csts, known_binfos;
- vec<ipa_agg_jump_function_t> known_aggs;
+ vec<ipa_agg_jump_function> known_aggs;
vec<ipa_agg_jump_function_p> known_aggs_ptrs;
bool always_const;
int base_time = inline_summary (node)->time;
/* Go through PLATS and create a vector of values consisting of values and
offsets (minus OFFSET) of lattices that contain only a single value. */
-static vec<ipa_agg_jf_item_t>
+static vec<ipa_agg_jf_item>
copy_plats_to_inter (struct ipcp_param_lattices *plats, HOST_WIDE_INT offset)
{
- vec<ipa_agg_jf_item_t> res = vNULL;
+ vec<ipa_agg_jf_item> res = vNULL;
if (!plats->aggs || plats->aggs_contain_variable || plats->aggs_bottom)
return vNULL;
static void
intersect_with_plats (struct ipcp_param_lattices *plats,
- vec<ipa_agg_jf_item_t> *inter,
+ vec<ipa_agg_jf_item> *inter,
HOST_WIDE_INT offset)
{
struct ipcp_agg_lattice *aglat;
/* Copy agggregate replacement values of NODE (which is an IPA-CP clone) to the
vector result while subtracting OFFSET from the individual value offsets. */
-static vec<ipa_agg_jf_item_t>
+static vec<ipa_agg_jf_item>
agg_replacements_to_vector (struct cgraph_node *node, int index,
HOST_WIDE_INT offset)
{
struct ipa_agg_replacement_value *av;
- vec<ipa_agg_jf_item_t> res = vNULL;
+ vec<ipa_agg_jf_item> res = vNULL;
for (av = ipa_get_agg_replacements_for_node (node); av; av = av->next)
if (av->index == index
static void
intersect_with_agg_replacements (struct cgraph_node *node, int index,
- vec<ipa_agg_jf_item_t> *inter,
+ vec<ipa_agg_jf_item> *inter,
HOST_WIDE_INT offset)
{
struct ipa_agg_replacement_value *srcvals;
copy all incoming values to it. If we determine we ended up with no values
whatsoever, return a released vector. */
-static vec<ipa_agg_jf_item_t>
+static vec<ipa_agg_jf_item>
intersect_aggregates_with_edge (struct cgraph_edge *cs, int index,
- vec<ipa_agg_jf_item_t> inter)
+ vec<ipa_agg_jf_item> inter)
{
struct ipa_jump_func *jfunc;
jfunc = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), index);
else
{
inter.release ();
- return vec<ipa_agg_jf_item_t>();
+ return vec<ipa_agg_jf_item>();
}
return inter;
}
for (i = 0; i < count ; i++)
{
struct cgraph_edge *cs;
- vec<ipa_agg_jf_item_t> inter = vNULL;
+ vec<ipa_agg_jf_item> inter = vNULL;
struct ipa_agg_jf_item *item;
struct ipcp_param_lattices *plats = ipa_get_parm_lattices (dest_info, i);
int j;
/* Turn KNOWN_AGGS into a list of aggreate replacement values. */
static struct ipa_agg_replacement_value *
-known_aggs_to_agg_replacement_list (vec<ipa_agg_jump_function_t> known_aggs)
+known_aggs_to_agg_replacement_list (vec<ipa_agg_jump_function> known_aggs)
{
struct ipa_agg_replacement_value *res = NULL;
struct ipa_agg_jump_function *aggjf;
for (i = 0; i < count; i++)
{
- static vec<ipa_agg_jf_item_t> values = vec<ipa_agg_jf_item_t>();
+ static vec<ipa_agg_jf_item> values = vec<ipa_agg_jf_item>();
struct ipcp_param_lattices *plats;
bool interesting = false;
for (struct ipa_agg_replacement_value *av = aggval; av; av = av->next)
struct ipa_node_params *info = IPA_NODE_REF (node);
int i, count = ipa_get_param_count (info);
vec<tree> known_csts, known_binfos;
- vec<ipa_agg_jump_function_t> known_aggs = vNULL;
+ vec<ipa_agg_jump_function> known_aggs = vNULL;
bool ret = false;
if (count == 0)
static int
predicate_probability (conditions conds,
struct predicate *p, clause_t possible_truths,
- vec<inline_param_summary_t> inline_param_summary)
+ vec<inline_param_summary> inline_param_summary)
{
int i;
int combined_prob = REG_BR_PROB_BASE;
vec<ipa_agg_jump_function_p> known_aggs,
int *ret_size, int *ret_time,
inline_hints *ret_hints,
- vec<inline_param_summary_t>
+ vec<inline_param_summary>
inline_param_summary)
{
struct inline_summary *info = inline_summary (node);
vector. They are of simple for function_param OP VAL, where VAL is
IPA invariant. The conditions are then referred by predicates. */
-typedef struct GTY(()) condition
- {
- /* If agg_contents is set, this is the offset from which the used data was
- loaded. */
- HOST_WIDE_INT offset;
- tree val;
- int operand_num;
- ENUM_BITFIELD(tree_code) code : 16;
- /* Set if the used data were loaded from an aggregate parameter or from
- data received by reference. */
- unsigned agg_contents : 1;
- /* If agg_contents is set, this differentiates between loads from data
- passed by reference and by value. */
- unsigned by_ref : 1;
- } condition;
+struct GTY(()) condition
+{
+ /* If agg_contents is set, this is the offset from which the used data was
+ loaded. */
+ HOST_WIDE_INT offset;
+ tree val;
+ int operand_num;
+ ENUM_BITFIELD(tree_code) code : 16;
+ /* Set if the used data were loaded from an aggregate parameter or from
+ data received by reference. */
+ unsigned agg_contents : 1;
+ /* If agg_contents is set, this differentiates between loads from data
+ passed by reference and by value. */
+ unsigned by_ref : 1;
+};
/* Inline hints are reasons why inline heuristics should preffer inlining given
function. They are represtented as bitmap of the following values. */
accounted. */
#define INLINE_SIZE_SCALE 2
#define INLINE_TIME_SCALE (CGRAPH_FREQ_BASE * 2)
-typedef struct GTY(()) size_time_entry
+struct GTY(()) size_time_entry
{
struct predicate predicate;
int size;
int time;
-} size_time_entry;
+};
/* Function inlining information. */
struct GTY(()) inline_summary
int scc_no;
};
-
+/* Need a typedef for inline_summary because of inline function
+ 'inline_summary' below. */
typedef struct inline_summary inline_summary_t;
extern GTY(()) vec<inline_summary_t, va_gc> *inline_summary_vec;
Value 0 is reserved for compile time invariants. */
int change_prob;
};
-typedef struct inline_param_summary inline_param_summary_t;
/* Information kept about callgraph edges. */
struct inline_edge_summary
/* Array indexed by parameters.
0 means that parameter change all the time, REG_BR_PROB_BASE means
that parameter is constant. */
- vec<inline_param_summary_t> param;
+ vec<inline_param_summary> param;
};
+/* Need a typedef for inline_edge_summary because of inline function
+ 'inline_edge_summary' below. */
typedef struct inline_edge_summary inline_edge_summary_t;
extern vec<inline_edge_summary_t> inline_edge_summary_vec;
-typedef struct edge_growth_cache_entry
+struct edge_growth_cache_entry
{
int time, size;
inline_hints hints;
-} edge_growth_cache_entry;
+};
extern vec<int> node_growth_cache;
extern vec<edge_growth_cache_entry> edge_growth_cache;
};
/* Vector where the parameter infos are actually stored. */
-vec<ipa_node_params_t> ipa_node_params_vector;
+vec<ipa_node_params> ipa_node_params_vector;
/* Vector of known aggregate values in cloned nodes. */
vec<ipa_agg_replacement_value_p, va_gc> *ipa_node_agg_replacements;
/* Vector where the parameter infos are actually stored. */
-vec<ipa_edge_args_t, va_gc> *ipa_edge_args_vector;
+vec<ipa_edge_args, va_gc> *ipa_edge_args_vector;
/* Holders of ipa cgraph hooks: */
static struct cgraph_edge_hook_list *edge_removal_hook_holder;
to INFO. */
static int
-ipa_get_param_decl_index_1 (vec<ipa_param_descriptor_t> descriptors, tree ptree)
+ipa_get_param_decl_index_1 (vec<ipa_param_descriptor> descriptors, tree ptree)
{
int i, count;
static void
ipa_populate_param_decls (struct cgraph_node *node,
- vec<ipa_param_descriptor_t> &descriptors)
+ vec<ipa_param_descriptor> &descriptors)
{
tree fndecl;
tree fnargs;
modified. Otherwise return -1. */
static int
-load_from_unmodified_param (vec<ipa_param_descriptor_t> descriptors,
+load_from_unmodified_param (vec<ipa_param_descriptor> descriptors,
struct param_analysis_info *parms_ainfo,
gimple stmt)
{
reference respectively. */
static bool
-ipa_load_from_parm_agg_1 (vec<ipa_param_descriptor_t> descriptors,
+ipa_load_from_parm_agg_1 (vec<ipa_param_descriptor> descriptors,
struct param_analysis_info *parms_ainfo, gimple stmt,
tree op, int *index_p, HOST_WIDE_INT *offset_p,
HOST_WIDE_INT *size_p, bool *by_ref_p)
unsigned int
ipcp_transform_function (struct cgraph_node *node)
{
- vec<ipa_param_descriptor_t> descriptors = vNULL;
+ vec<ipa_param_descriptor> descriptors = vNULL;
struct param_analysis_info *parms_ainfo;
struct ipa_agg_replacement_value *aggval;
gimple_stmt_iterator gsi;
different, all unlisted parts are assumed to be unknown and all values must
fulfill is_gimple_ip_invariant. */
-typedef struct GTY(()) ipa_agg_jf_item
+struct GTY(()) ipa_agg_jf_item
{
/* The offset at which the known value is located within the aggregate. */
HOST_WIDE_INT offset;
/* The known constant or type if this is a clobber. */
tree value;
-} ipa_agg_jf_item_t;
+};
/* Aggregate jump function - i.e. description of contents of aggregates passed
struct GTY(()) ipa_agg_jump_function
{
/* Description of the individual items. */
- vec<ipa_agg_jf_item_t, va_gc> *items;
+ vec<ipa_agg_jf_item, va_gc> *items;
/* True if the data was passed by reference (as opposed to by value). */
bool by_ref;
};
typedef struct ipa_agg_jump_function *ipa_agg_jump_function_p;
-typedef struct ipa_agg_jump_function ipa_agg_jump_function_t;
/* A jump function for a callsite represents the values passed as actual
arguments of the callsite. See enum jump_func_type for the various
types of jump functions supported. */
-typedef struct GTY (()) ipa_jump_func
+struct GTY (()) ipa_jump_func
{
/* Aggregate contants description. See struct ipa_agg_jump_function and its
description. */
struct ipa_pass_through_data GTY ((tag ("IPA_JF_PASS_THROUGH"))) pass_through;
struct ipa_ancestor_jf_data GTY ((tag ("IPA_JF_ANCESTOR"))) ancestor;
} GTY ((desc ("%1.type"))) value;
-} ipa_jump_func_t;
+};
/* Return the offset of the component that is described by a known type jump
unsigned used : 1;
};
-typedef struct ipa_param_descriptor ipa_param_descriptor_t;
struct ipcp_lattice;
/* ipa_node_params stores information related to formal parameters of functions
{
/* Information about individual formal parameters that are gathered when
summaries are generated. */
- vec<ipa_param_descriptor_t> descriptors;
+ vec<ipa_param_descriptor> descriptors;
/* Pointer to an array of structures describing individual formal
parameters. */
struct ipcp_param_lattices *lattices;
/* ipa_edge_args stores information related to a callsite and particularly its
arguments. It can be accessed by the IPA_EDGE_REF macro. */
-typedef struct GTY(()) ipa_edge_args
+struct GTY(()) ipa_edge_args
{
/* Vector of the callsite's jump function of each parameter. */
- vec<ipa_jump_func_t, va_gc> *jump_functions;
-} ipa_edge_args_t;
+ vec<ipa_jump_func, va_gc> *jump_functions;
+};
/* ipa_edge_args access functions. Please use these to access fields that
are or will be shared among various passes. */
return &(*args->jump_functions)[i];
}
-/* Vectors need to have typedefs of structures. */
-typedef struct ipa_node_params ipa_node_params_t;
-
/* Types of vectors holding the infos. */
/* Vector where the parameter infos are actually stored. */
-extern vec<ipa_node_params_t> ipa_node_params_vector;
+extern vec<ipa_node_params> ipa_node_params_vector;
/* Vector of known aggregate values in cloned nodes. */
extern GTY(()) vec<ipa_agg_replacement_value_p, va_gc> *ipa_node_agg_replacements;
/* Vector where the parameter infos are actually stored. */
-extern GTY(()) vec<ipa_edge_args_t, va_gc> *ipa_edge_args_vector;
+extern GTY(()) vec<ipa_edge_args, va_gc> *ipa_edge_args_vector;
/* Return the associated parameter/argument info corresponding to the given
node/edge. */
unsigned by_ref : 1;
};
-typedef struct ipa_parm_adjustment ipa_parm_adjustment_t;
-
-typedef vec<ipa_parm_adjustment_t> ipa_parm_adjustment_vec;
+typedef vec<ipa_parm_adjustment> ipa_parm_adjustment_vec;
vec<tree> ipa_get_vector_of_formal_parms (tree fndecl);
vec<tree> ipa_get_vector_of_formal_parm_types (tree fntype);
#endif
/* The iterator for min/max sets. */
-typedef struct {
+struct minmax_set_iterator {
/* Array containing the bit vector. */
IRA_INT_TYPE *vec;
/* The word of the bit vector currently visited. */
unsigned IRA_INT_TYPE word;
-} minmax_set_iterator;
+};
/* Initialize the iterator I for bit vector VEC containing minimal and
maximal values MIN and MAX. */
\f
/* The iterator for all allocnos. */
-typedef struct {
+struct ira_allocno_iterator {
/* The number of the current element in IRA_ALLOCNOS. */
int n;
-} ira_allocno_iterator;
+};
/* Initialize the iterator I. */
static inline void
ira_allocno_iter_cond (&(ITER), &(A));)
\f
/* The iterator for all objects. */
-typedef struct {
+struct ira_object_iterator {
/* The number of the current element in ira_object_id_map. */
int n;
-} ira_object_iterator;
+};
/* Initialize the iterator I. */
static inline void
ira_object_iter_cond (&(ITER), &(OBJ));)
\f
/* The iterator for objects associated with an allocno. */
-typedef struct {
+struct ira_allocno_object_iterator {
/* The number of the element the allocno's object array. */
int n;
-} ira_allocno_object_iterator;
+};
/* Initialize the iterator I. */
static inline void
\f
/* The iterator for prefs. */
-typedef struct {
+struct ira_pref_iterator {
/* The number of the current element in IRA_PREFS. */
int n;
-} ira_pref_iterator;
+};
/* Initialize the iterator I. */
static inline void
\f
/* The iterator for copies. */
-typedef struct {
+struct ira_copy_iterator {
/* The number of the current element in IRA_COPIES. */
int n;
-} ira_copy_iterator;
+};
/* Initialize the iterator I. */
static inline void
ira_copy_iter_cond (&(ITER), &(C));)
\f
/* The iterator for object conflicts. */
-typedef struct {
+struct ira_object_conflict_iterator {
/* TRUE if the conflicts are represented by vector of allocnos. */
bool conflict_vec_p;
/* The word of bit vector currently visited. It is defined only if
OBJECT_CONFLICT_VEC_P is FALSE. */
unsigned IRA_INT_TYPE word;
-} ira_object_conflict_iterator;
+};
/* Initialize the iterator I with ALLOCNO conflicts. */
static inline void
bp = bitpack_create (ob->main_stream);
uid = (!gimple_has_body_p (edge->caller->decl)
? edge->lto_stmt_uid : gimple_uid (edge->call_stmt) + 1);
- bp_pack_enum (&bp, cgraph_inline_failed_enum,
+ bp_pack_enum (&bp, cgraph_inline_failed_t,
CIF_N_REASONS, edge->inline_failed);
bp_pack_var_len_unsigned (&bp, uid);
bp_pack_var_len_unsigned (&bp, edge->frequency);
count = streamer_read_gcov_count (ib);
bp = streamer_read_bitpack (ib);
- inline_failed = bp_unpack_enum (&bp, cgraph_inline_failed_enum, CIF_N_REASONS);
+ inline_failed = bp_unpack_enum (&bp, cgraph_inline_failed_t, CIF_N_REASONS);
stmt_id = bp_unpack_var_len_unsigned (&bp);
freq = (int) bp_unpack_var_len_unsigned (&bp);
};
/* Indices to the various function, type and symbol streams. */
-typedef enum
+enum lto_decl_stream_e_t
{
LTO_DECL_STREAM_TYPE = 0, /* Must be first. */
LTO_DECL_STREAM_FIELD_DECL,
LTO_DECL_STREAM_NAMESPACE_DECL,
LTO_DECL_STREAM_LABEL_DECL,
LTO_N_DECL_STREAMS
-} lto_decl_stream_e_t;
+};
typedef enum ld_plugin_symbol_resolution ld_plugin_symbol_resolution_t;
};
/* Entry of LTO symtab encoder. */
-typedef struct
+struct lto_encoder_entry
{
symtab_node *node;
/* Is the node in this partition (i.e. ltrans of this partition will
For example the readonly variable initializers are encoded to aid
constant folding even if they are not in the partition. */
unsigned int initializer:1;
-} lto_encoder_entry;
+};
/* Encoder data structure used to stream callgraph nodes. */
typedef struct lto_symtab_encoder_d *lto_symtab_encoder_t;
/* Iterator structure for cgraph node sets. */
-typedef struct
+struct lto_symtab_encoder_iterator
{
lto_symtab_encoder_t encoder;
unsigned index;
-} lto_symtab_encoder_iterator;
+};
ld_plugin_symbol_resolution_t res;
unsigned index;
};
-typedef struct res_pair res_pair;
/* One of these is allocated for each object file that being compiled
/* Structure describing an option deferred for handling after the main
option handlers. */
-typedef struct
+struct cl_deferred_option
{
/* Elements from struct cl_decoded_option used for deferred
options. */
size_t opt_index;
const char *arg;
int value;
-} cl_deferred_option;
+};
/* Structure describing a single option-handling callback. */
/* The information associated with each parameter. */
-typedef struct param_info
+struct param_info
{
/* The name used with the `--param <name>=<value>' switch to set this
value. */
/* A short description of the option. */
const char *const help;
-} param_info;
+};
/* An array containing the compiler parameters and their current
values. */
\f
/* The parameters in use by language-independent code. */
-typedef enum compiler_param
+enum compiler_param
{
#define DEFPARAM(enumerator, option, msgid, default, min, max) \
enumerator,
#include "params.def"
#undef DEFPARAM
LAST_PARAM
-} compiler_param;
+};
/* The value of the parameter given by ENUM. Not an lvalue. */
#define PARAM_VALUE(ENUM) \
/* This struct describes data gathered during regrename_analyze about
a single operand of an insn. */
-typedef struct
+struct operand_rr_info
{
/* The number of chains recorded for this operand. */
int n_chains;
a memory operand. */
struct du_chain *chains[MAX_REGS_PER_ADDRESS];
struct du_head *heads[MAX_REGS_PER_ADDRESS];
-} operand_rr_info;
+};
/* A struct to hold a vector of operand_rr_info structures describing the
operands of an insn. */
-typedef struct
+struct insn_rr_info
{
operand_rr_info *op_info;
-} insn_rr_info;
+};
extern vec<insn_rr_info> insn_rr;
(this_target_reload->x_caller_save_initialized_p)
/* Register equivalences. Indexed by register number. */
-typedef struct reg_equivs_s
+struct reg_equivs_t
{
/* The constant value to which pseudo reg N is equivalent,
or zero if pseudo reg N is not equivalent to a constant.
/* The list of insns that initialized reg N from its equivalent
constant or memory slot. */
rtx init;
-} reg_equivs_t;
+};
#define reg_equiv_constant(ELT) \
(*reg_equivs)[(ELT)].constant
/* Used in the cselib routines to describe a value. Objects of this
kind are only allocated in cselib.c, in an alloc pool instead of in
- GC memory. The only operand of a VALUE is a cselib_val_struct.
+ GC memory. The only operand of a VALUE is a cselib_val.
var-tracking requires this to have a distinct integral value from
DECL codes in trees. */
DEF_RTL_EXPR(VALUE, "value", "0", RTX_OBJ)
\f
/* The flags and bitfields of an ADDR_DIFF_VEC. BASE is the base label
relative to which the offsets are calculated, as explained in rtl.def. */
-typedef struct
+struct addr_diff_vec_flags
{
/* Set at the start of shorten_branches - ONLY WHEN OPTIMIZING - : */
unsigned min_align: 8;
unsigned offset_unsigned: 1; /* offsets have to be treated as unsigned. */
unsigned : 2;
unsigned scale : 8;
-} addr_diff_vec_flags;
+};
/* Structure used to describe the attributes of a MEM. These are hashed
so MEMs that the same attributes share a data structure. This means
they cannot be modified in place. */
-typedef struct GTY(()) mem_attrs
+struct GTY(()) mem_attrs
{
/* The expression that the MEM accesses, or null if not known.
This expression might be larger than the memory reference itself.
/* True if SIZE is known. */
bool size_known_p;
-} mem_attrs;
+};
/* Structure used to describe the attributes of a REG in similar way as
mem_attrs does for MEM above. Note that the OFFSET field is calculated
object in the low part of a 4-byte register, the OFFSET field
will be -3 rather than 0. */
-typedef struct GTY(()) reg_attrs {
+struct GTY(()) reg_attrs {
tree decl; /* decl corresponding to REG. */
HOST_WIDE_INT offset; /* Offset from start of DECL. */
-} reg_attrs;
+};
/* Common union for an element of an rtx. */
-union rtunion_def
+union rtunion
{
int rt_int;
unsigned int rt_uint;
rtvec rt_rtvec;
enum machine_mode rt_type;
addr_diff_vec_flags rt_addr_diff_vec_flags;
- struct cselib_val_struct *rt_cselib;
+ struct cselib_val *rt_cselib;
tree rt_tree;
basic_block rt_bb;
mem_attrs *rt_mem;
reg_attrs *rt_reg;
struct constant_descriptor_rtx *rt_constant;
- struct dw_cfi_struct *rt_cfi;
+ struct dw_cfi_node *rt_cfi;
};
-typedef union rtunion_def rtunion;
/* This structure remembers the position of a SYMBOL_REF within an
object_block structure. A SYMBOL_REF only provides this information
#define ADDR_DIFF_VEC_FLAGS(RTX) X0ADVFLAGS (RTX, 4)
/* In a VALUE, the value cselib has assigned to RTX.
- This is a "struct cselib_val_struct", see cselib.h. */
+ This is a "struct cselib_val", see cselib.h. */
#define CSELIB_VAL_PTR(RTX) X0CSELIB (RTX, 0)
/* Holds a list of notes on what this insn does to various REGs.
#define single_set_1(I) single_set_2 (I, PATTERN (I))
/* Structure used for passing data to REPLACE_LABEL. */
-typedef struct replace_label_data
+struct replace_label_data
{
rtx r1;
rtx r2;
bool update_label_nuses;
-} replace_label_data;
+};
extern enum machine_mode get_address_mode (rtx mem);
extern int rtx_addr_can_trap_p (const_rtx);
}
/* The iterator for sbitmap. */
-typedef struct {
+struct sbitmap_iterator {
/* The pointer to the first word of the bitmap. */
const SBITMAP_ELT_TYPE *ptr;
/* The words currently visited. */
SBITMAP_ELT_TYPE word;
-} sbitmap_iterator;
+};
/* Initialize the iterator I with sbitmap BMP and the initial index
MIN. */
/* A region is the main entity for interblock scheduling: insns
are allowed to move between blocks in the same region, along
control flow graph edges, in the 'up' direction. */
-typedef struct
+struct region
{
/* Number of extended basic blocks in region. */
int rgn_nr_blocks;
unsigned int dont_calc_deps : 1;
/* This region has at least one non-trivial ebb. */
unsigned int has_real_ebb : 1;
-}
-region;
+};
extern int nr_regions;
extern region *rgn_table;
\f
/* List iterator backend. */
-typedef struct
+struct _list_iterator
{
/* The list we're iterating. */
_list_t *lp;
/* True when we've actually removed something. */
bool removed_p;
-} _list_iterator;
+};
static inline void
_list_iter_start (_list_iterator *ip, _list_t *lp, bool can_remove_p)
/* A variable to track which part of rtx we are scanning in
sched-deps.c: sched_analyze_insn (). */
-enum deps_where_def
- {
- DEPS_IN_INSN,
- DEPS_IN_LHS,
- DEPS_IN_RHS,
- DEPS_IN_NOWHERE
- };
-typedef enum deps_where_def deps_where_t;
+enum deps_where_t
+{
+ DEPS_IN_INSN,
+ DEPS_IN_LHS,
+ DEPS_IN_RHS,
+ DEPS_IN_NOWHERE
+};
\f
/* Per basic block data for the whole CFG. */
-typedef struct
+struct sel_global_bb_info_def
{
/* For each bb header this field contains a set of live registers.
For all other insns this field has a NULL.
true - block has usable LV_SET.
false - block's LV_SET should be recomputed. */
bool lv_set_valid_p;
-} sel_global_bb_info_def;
+};
typedef sel_global_bb_info_def *sel_global_bb_info_t;
#define BB_LV_SET_VALID_P(BB) (SEL_GLOBAL_BB_INFO (BB)->lv_set_valid_p)
/* Per basic block data for the region. */
-typedef struct
+struct sel_region_bb_info_def
{
/* This insn stream is constructed in such a way that it should be
traversed by PREV_INSN field - (*not* NEXT_INSN). */
/* If (AV_LEVEL == GLOBAL_LEVEL) then AV is valid. */
int av_level;
-} sel_region_bb_info_def;
+};
typedef sel_region_bb_info_def *sel_region_bb_info_t;
\f
/* Successor iterator backend. */
-typedef struct
+struct succ_iterator
{
/* True if we're at BB end. */
bool bb_end;
/* If skip to loop exits, save here information about loop exits. */
int current_exit;
vec<edge> loop_exits;
-} succ_iterator;
+};
/* A structure returning all successor's information. */
struct succs_info
#endif
/* Structure for holding a simple real number. */
-typedef struct sreal
+struct sreal
{
#if SREAL_PART_BITS < 32
unsigned HOST_WIDE_INT sig_lo; /* Significant (lower part). */
unsigned HOST_WIDE_INT sig; /* Significant. */
#endif
signed int exp; /* Exponent. */
-} sreal;
+};
extern void dump_sreal (FILE *, sreal *);
extern void debug (sreal &ref);
/* Immediate use lists are used to directly access all uses for an SSA
name and get pointers to the statement for each use.
- The structure ssa_use_operand_d consists of PREV and NEXT pointers
+ The structure ssa_use_operand_t consists of PREV and NEXT pointers
to maintain the list. A USE pointer, which points to address where
the use is located and a LOC pointer which can point to the
statement where the use is located, or, in the case of the root
If iteration is halted early, the marker node must be removed from
the list before continuing. */
-typedef struct immediate_use_iterator_d
+struct imm_use_iterator
{
/* This is the current use the iterator is processing. */
ssa_use_operand_t *imm_use;
/* This is the next ssa_name to visit. IMM_USE may get removed before
the next one is traversed to, so it must be cached early. */
ssa_use_operand_t *next_imm_name;
-} imm_use_iterator;
+};
/* Use this iterator when simply looking at stmts. Adding, deleting or
optimization, this structure is scalarized, and any unused fields are
optimized away, resulting in little overhead. */
-typedef struct ssa_operand_iterator_d
+struct ssa_op_iter
{
enum ssa_op_iter_type iter_type;
bool done;
unsigned numops;
use_optype_p uses;
gimple stmt;
-} ssa_op_iter;
+};
/* These flags are used to determine which operands are returned during
execution of the loop. */
version of this hook assumes the system C library errno location\
is either a declaration of type int or accessed by dereferencing\
a pointer to int.",
- bool, (struct ao_ref_s *ref),
+ bool, (struct ao_ref *ref),
default_ref_may_alias_errno)
/* Support for named address spaces. */
#ifdef ENABLE_CHECKING
-typedef struct { void *magic; void *p; } cumulative_args_t;
+struct cumulative_args_t { void *magic; void *p; };
#else /* !ENABLE_CHECKING */
efficient way of argument passing otherwise. However, that would come
at the cost of less type-safe !ENABLE_CHECKING compilation. */
-typedef union { void *p; } cumulative_args_t;
+union cumulative_args_t { void *p; };
#endif /* !ENABLE_CHECKING */
/* Types used by the record_gcc_switches() target function. */
-typedef enum
+enum print_switch_type
{
SWITCH_TYPE_PASSED, /* A switch passed on the command line. */
SWITCH_TYPE_ENABLED, /* An option that is currently enabled. */
SWITCH_TYPE_DESCRIPTIVE, /* Descriptive text, not a switch or option. */
SWITCH_TYPE_LINE_START, /* Please emit any necessary text at the start of a line. */
SWITCH_TYPE_LINE_END /* Please emit a line terminator. */
-}
-print_switch_type;
+};
typedef int (* print_switch_fn_type) (print_switch_type, const char *);
struct cgraph_simd_clone;
/* The struct used by the secondary_reload target hook. */
-typedef struct secondary_reload_info
+struct secondary_reload_info
{
/* icode is actually an enum insn_code, but we don't want to force every
file that includes target.h to include optabs.h . */
compatibility hook. */
struct secondary_reload_info *prev_sri;
int t_icode; /* Actually an enum insn_code - see above. */
-} secondary_reload_info;
+};
/* This is defined in sched-int.h . */
struct _dep;
struct loop;
/* This is defined in tree-ssa-alias.h. */
-struct ao_ref_s;
+struct ao_ref;
/* This is defined in tree-vectorizer.h. */
struct _stmt_vec_info;
extern bool default_target_option_pragma_parse (tree, tree);
extern bool default_target_can_inline_p (tree, tree);
extern bool default_valid_pointer_mode (enum machine_mode);
-extern bool default_ref_may_alias_errno (struct ao_ref_s *);
+extern bool default_ref_may_alias_errno (struct ao_ref *);
extern enum machine_mode default_addr_space_pointer_mode (addr_space_t);
extern enum machine_mode default_addr_space_address_mode (addr_space_t);
extern bool default_addr_space_valid_pointer_mode (enum machine_mode,
double_int coef;
};
-typedef struct affine_tree_combination
+struct aff_tree
{
/* Type of the result of the combination. */
tree type;
than MAX_AFF_ELTS elements. Type of REST will be either sizetype for
TYPE of POINTER_TYPEs or TYPE. */
tree rest;
-} aff_tree;
+};
double_int double_int_ext_for_comb (double_int, aff_tree *);
void aff_combination_const (aff_tree *, tree, double_int);
/* When processing aliases at the symbol table level, we need the
declaration of target. For this reason we need to queue aliases and
process them after all declarations has been produced. */
-typedef struct GTY(()) alias_pair {
+struct GTY(()) alias_pair {
tree decl;
tree target;
-} alias_pair;
+};
/* An initialization priority. */
typedef unsigned short priority_type;
element. INDEX can optionally design the position of VALUE: in arrays,
it is the index where VALUE has to be placed; in structures, it is the
FIELD_DECL of the member. */
-typedef struct GTY(()) constructor_elt_d {
+struct GTY(()) constructor_elt {
tree index;
tree value;
-} constructor_elt;
+};
struct GTY(()) tree_constructor {
struct tree_typed typed;
/* Immediate use linking structure. This structure is used for maintaining
a doubly linked list of uses of an SSA_NAME. */
-typedef struct GTY(()) ssa_use_operand_d {
- struct ssa_use_operand_d* GTY((skip(""))) prev;
- struct ssa_use_operand_d* GTY((skip(""))) next;
+struct GTY(()) ssa_use_operand_t {
+ struct ssa_use_operand_t* GTY((skip(""))) prev;
+ struct ssa_use_operand_t* GTY((skip(""))) next;
/* Immediate uses for a given SSA name are maintained as a cyclic
list. To recognize the root of this list, the location field
needs to point to the original SSA name. Since statements and
SSA names are of different data types, we need this union. See
- the explanation in struct immediate_use_iterator_d. */
+ the explanation in struct imm_use_iterator. */
union { gimple stmt; tree ssa_name; } GTY((skip(""))) loc;
tree *GTY((skip(""))) use;
-} ssa_use_operand_t;
+};
struct GTY(()) tree_ssa_name {
struct tree_typed typed;
"!POINTER_TYPE_P (TREE_TYPE ((tree)&%1)) : 2"))) info;
/* Immediate uses list for this SSA_NAME. */
- struct ssa_use_operand_d imm_uses;
+ struct ssa_use_operand_t imm_uses;
};
struct GTY(()) phi_arg_d {
/* imm_use MUST be the first element in struct because we do some
pointer arithmetic with it. See phi_arg_index_from_use. */
- struct ssa_use_operand_d imm_use;
+ struct ssa_use_operand_t imm_use;
tree def;
location_t locus;
};
typedef vec<tree> affine_fn;
-typedef struct
+struct conflict_function
{
unsigned n;
affine_fn fns[MAX_DIM];
-} conflict_function;
+};
/* What is a subscript? Given two array accesses a subscript is the
tuple composed of the access functions for a given dimension.
/* Data required for function body duplication. */
-typedef struct copy_body_data
+struct copy_body_data
{
/* FUNCTION_DECL for function being inlined, or in general the
source function providing the original trees. */
/* Cilk keywords currently need to replace some variables that
ordinary nested functions do not. */
bool remap_var_for_cilk;
-} copy_body_data;
+};
/* Weights of constructions for estimate_num_insns. */
/* Iterator object for GENERIC or GIMPLE TREE statements. */
-typedef struct {
+struct tree_stmt_iterator {
struct tree_statement_list_node *ptr;
tree container;
-} tree_stmt_iterator;
+};
static inline tree_stmt_iterator
tsi_start (tree t)
extern void gather_stats_on_scev_database (void);
extern unsigned int scev_const_prop (void);
extern bool expression_expensive_p (tree);
-extern bool simple_iv (struct loop *, struct loop *, tree, struct affine_iv_d *,
+extern bool simple_iv (struct loop *, struct loop *, tree, struct affine_iv *,
bool);
extern tree compute_overall_effect_of_inner_loop (struct loop *, tree);
extern void get_address_description (tree, struct mem_address *);
extern tree tree_mem_ref_addr (tree, tree);
tree create_mem_ref (gimple_stmt_iterator *, tree,
- struct affine_tree_combination *, tree, tree, tree, bool);
+ struct aff_tree *, tree, tree, tree, bool);
extern void copy_ref_info (tree, tree);
tree maybe_fold_tmr (tree);
/* Simplified and cached information about a memory reference tree.
Used by the alias-oracle internally and externally in alternate
interfaces. */
-typedef struct ao_ref_s
+struct ao_ref
{
/* The original full memory reference tree or NULL_TREE if that is
not available. */
/* Whether the memory is considered a volatile access. */
bool volatile_p;
-} ao_ref;
+};
/* In tree-ssa-alias.c */
static bool
get_computation_aff (struct loop *loop,
struct iv_use *use, struct iv_cand *cand, gimple at,
- struct affine_tree_combination *aff)
+ struct aff_tree *aff)
{
tree ubase = use->iv->base;
tree ustep = use->iv->step;
struct tree_niter_desc *niter)
{
tree cand_type, a, b, mbz, nit_type = TREE_TYPE (niter->niter), offset;
- struct affine_tree_combination nit, tmpa, tmpb;
+ struct aff_tree nit, tmpa, tmpb;
enum tree_code comp;
HOST_WIDE_INT step;
/* Affine iv. */
-typedef struct affine_iv_d
+struct affine_iv
{
/* Iv = BASE + STEP * i. */
tree base, step;
/* True if this iv does not overflow. */
bool no_overflow;
-} affine_iv;
+};
/* Description of number of iterations of a loop. All the expressions inside
the structure can be evaluated at the end of the loop's preheader
struct use_optype_d
{
struct use_optype_d *next;
- struct ssa_use_operand_d use_ptr;
+ struct ssa_use_operand_t use_ptr;
};
typedef struct use_optype_d *use_optype_p;
projects / platform / upstream / linaro-gcc.git / commitdiff