CbC/CbC_gcc: gcc/gimple.h comparison

comparison gcc/gimple.h @ 57:326d9e06c2e3

modify c-parser.c

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Mon, 15 Feb 2010 00:54:17 +0900
parents	9de9dad105d4 77e2b8dfacca
children	1b10fe6932e1

comparison

equal deleted inserted replaced

-:f62c169bbc24
+:326d9e06c2e3
 DEF_VEC_P(gimple);
 DEF_VEC_ALLOC_P(gimple,heap);
 DEF_VEC_ALLOC_P(gimple,gc);
+typedef gimple *gimple_p;
+DEF_VEC_P(gimple_p);
+DEF_VEC_ALLOC_P(gimple_p,heap);
 DEF_VEC_P(gimple_seq);
 DEF_VEC_ALLOC_P(gimple_seq,gc);
 DEF_VEC_ALLOC_P(gimple_seq,heap);
 /* For each block, the PHI nodes that need to be rewritten are stored into
 #define GIMPLE_CHECK(GS, CODE)						\
 do {									\
 const_gimple __gs = (GS);						\
 if (gimple_code (__gs) != (CODE))					\
 gimple_check_failed (__gs, __FILE__, __LINE__, __FUNCTION__,	\
-	  		   (CODE), 0);					\
+	  		   (CODE), ERROR_MARK);				\
 } while (0)
 #else  /* not ENABLE_GIMPLE_CHECKING  */
 #define GIMPLE_CHECK(GS, CODE)			(void)0
 #endif
 GF_OMP_SECTION_LAST		= 1 << 0,
 GF_PREDICT_TAKEN		= 1 << 15
 };
+/* Currently, there's only one type of gimple debug stmt.  Others are
+envisioned, for example, to enable the generation of is_stmt notes
+in line number information, to mark sequence points, etc.  This
+subcode is to be used to tell them apart.  */
+enum gimple_debug_subcode {
+GIMPLE_DEBUG_BIND = 0
+};
 /* Masks for selecting a pass local flag (PLF) to work on.  These
 masks are used by gimple_set_plf and gimple_plf.  */
 enum plf_mask {
 GF_PLF_1	= 1 << 0,
 GF_PLF_2	= 1 << 1
 };
 /* A node in a gimple_seq_d.  */
-struct gimple_seq_node_d GTY((chain_next ("%h.next"), chain_prev ("%h.prev")))
+struct GTY((chain_next ("%h.next"), chain_prev ("%h.prev"))) gimple_seq_node_d {
-{
 gimple stmt;
 struct gimple_seq_node_d *prev;
 struct gimple_seq_node_d *next;
 };
 /* A double-linked sequence of gimple statements.  */
-struct gimple_seq_d GTY ((chain_next ("%h.next_free")))
+struct GTY ((chain_next ("%h.next_free"))) gimple_seq_d {
-{
 /* First and last statements in the sequence.  */
 gimple_seq_node first;
 gimple_seq_node last;
 /* Sequences are created/destroyed frequently.  To minimize
 /* Data structure definitions for GIMPLE tuples.  NOTE: word markers
 are for 64 bit hosts.  */
-struct gimple_statement_base GTY(())
+struct GTY(()) gimple_statement_base {
-{
 /* [ WORD 1 ]
 Main identifying code for a tuple.  */
 ENUM_BITFIELD(gimple_code) code : 8;
 /* Nonzero if a warning should not be emitted on this tuple.  */
 unsigned modified 		: 1;
 /* Nonzero if this statement contains volatile operands.  */
 unsigned has_volatile_ops 	: 1;
-/* Nonzero if this statement contains memory refernces.  */
+/* Padding to get subcode to 16 bit alignment.  */
-unsigned references_memory_p 	: 1;
+unsigned pad			: 1;
 /* The SUBCODE field can be used for tuple-specific flags for tuples
 that do not require subcodes.  Note that SUBCODE should be at
 least as wide as tree codes, as several tuples store tree codes
 in there.  */
 };
 /* Base structure for tuples with operands.  */
-struct gimple_statement_with_ops_base GTY(())
+struct GTY(()) gimple_statement_with_ops_base
 {
-/* [ WORD  1-4 ]  */
+/* [ WORD 1-4 ]  */
 struct gimple_statement_base gsbase;
-/* [ WORD 5 ]
+/* [ WORD 5-6 ]
-Symbols whose addresses are taken by this statement (i.e., they
-appear inside ADDR_EXPR nodes).  */
-bitmap GTY((skip (""))) addresses_taken;
-/* [ WORD 6-7 ]
 SSA operand vectors.  NOTE: It should be possible to
 amalgamate these vectors with the operand vector OP.  However,
 the SSA operand vectors are organized differently and contain
 more information (like immediate use chaining).  */
 struct def_optype_d GTY((skip (""))) *def_ops;
 };
 /* Statements that take register operands.  */
-struct gimple_statement_with_ops GTY(())
+struct GTY(()) gimple_statement_with_ops
 {
-/* [ WORD 1-7 ]  */
+/* [ WORD 1-6 ]  */
 struct gimple_statement_with_ops_base opbase;
-/* [ WORD 8 ]
+/* [ WORD 7 ]
 Operand vector.  NOTE!  This must always be the last field
 of this structure.  In particular, this means that this
 structure cannot be embedded inside another one.  */
 tree GTY((length ("%h.opbase.gsbase.num_ops"))) op[1];
 };
 /* Base for statements that take both memory and register operands.  */
-struct gimple_statement_with_memory_ops_base GTY(())
+struct GTY(()) gimple_statement_with_memory_ops_base
 {
-/* [ WORD 1-7 ]  */
+/* [ WORD 1-6 ]  */
 struct gimple_statement_with_ops_base opbase;
-/* [ WORD 8-9 ]
+/* [ WORD 7-8 ]
-Vectors for virtual operands.  */
+Virtual operands for this statement.  The GC will pick them
-struct voptype_d GTY((skip (""))) *vdef_ops;
+up via the ssa_names array.  */
-struct voptype_d GTY((skip (""))) *vuse_ops;
+tree GTY((skip (""))) vdef;
+tree GTY((skip (""))) vuse;
-/* [ WORD 9-10 ]
-Symbols stored/loaded by this statement.  */
-bitmap GTY((skip (""))) stores;
-bitmap GTY((skip (""))) loads;
 };
 /* Statements that take both memory and register operands.  */
-struct gimple_statement_with_memory_ops GTY(())
+struct GTY(()) gimple_statement_with_memory_ops
 {
-/* [ WORD 1-10 ]  */
+/* [ WORD 1-8 ]  */
 struct gimple_statement_with_memory_ops_base membase;
-/* [ WORD 11 ]
+/* [ WORD 9 ]
 Operand vector.  NOTE!  This must always be the last field
 of this structure.  In particular, this means that this
 structure cannot be embedded inside another one.  */
 tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1];
 };
 /* OpenMP statements (#pragma omp).  */
-struct gimple_statement_omp GTY(())
+struct GTY(()) gimple_statement_omp {
-{
 /* [ WORD 1-4 ]  */
 struct gimple_statement_base gsbase;
 /* [ WORD 5 ]  */
 gimple_seq body;
 };
 /* GIMPLE_BIND */
-struct gimple_statement_bind GTY(())
+struct GTY(()) gimple_statement_bind {
-{
 /* [ WORD 1-4 ]  */
 struct gimple_statement_base gsbase;
 /* [ WORD 5 ]
 Variables declared in this scope.  */
 };
 /* GIMPLE_CATCH */
-struct gimple_statement_catch GTY(())
+struct GTY(()) gimple_statement_catch {
-{
 /* [ WORD 1-4 ]  */
 struct gimple_statement_base gsbase;
 /* [ WORD 5 ]  */
 tree types;
 };
 /* GIMPLE_EH_FILTER */
-struct gimple_statement_eh_filter GTY(())
+struct GTY(()) gimple_statement_eh_filter {
-{
 /* [ WORD 1-4 ]  */
 struct gimple_statement_base gsbase;
-/* Subcode: EH_FILTER_MUST_NOT_THROW.  A boolean flag analogous to
-the tree counterpart.  */
 /* [ WORD 5 ]
 Filter types.  */
 tree types;
 Failure actions.  */
 gimple_seq failure;
 };
+/* GIMPLE_EH_MUST_NOT_THROW */
+struct GTY(()) gimple_statement_eh_mnt {
+/* [ WORD 1-4 ]  */
+struct gimple_statement_base gsbase;
+/* [ WORD 5 ] Abort function decl.  */
+tree fndecl;
+};
 /* GIMPLE_PHI */
-struct gimple_statement_phi GTY(())
+struct GTY(()) gimple_statement_phi {
-{
 /* [ WORD 1-4 ]  */
 struct gimple_statement_base gsbase;
 /* [ WORD 5 ]  */
 unsigned capacity;
 /* [ WORD 7 ]  */
 struct phi_arg_d GTY ((length ("%h.nargs"))) args[1];
 };
-/* GIMPLE_RESX */
+/* GIMPLE_RESX, GIMPLE_EH_DISPATCH */
-struct gimple_statement_resx GTY(())
+struct GTY(()) gimple_statement_eh_ctrl
 {
 /* [ WORD 1-4 ]  */
 struct gimple_statement_base gsbase;
 /* [ WORD 5 ]
 };
 /* GIMPLE_TRY */
-struct gimple_statement_try GTY(())
+struct GTY(()) gimple_statement_try {
-{
 /* [ WORD 1-4 ]  */
 struct gimple_statement_base gsbase;
 /* [ WORD 5 ]
 Expression to evaluate.  */
 GIMPLE_TRY_CATCH_IS_CLEANUP = 1 << 2
 };
 /* GIMPLE_WITH_CLEANUP_EXPR */
-struct gimple_statement_wce GTY(())
+struct GTY(()) gimple_statement_wce {
-{
 /* [ WORD 1-4 ]  */
 struct gimple_statement_base gsbase;
 /* Subcode: CLEANUP_EH_ONLY.  True if the cleanup should only be
 	      executed if an exception is thrown, not on normal exit of its
 };
 /* GIMPLE_ASM  */
-struct gimple_statement_asm GTY(())
+struct GTY(()) gimple_statement_asm
 {
-/* [ WORD 1-10 ]  */
+/* [ WORD 1-8 ]  */
 struct gimple_statement_with_memory_ops_base membase;
-/* [ WORD 11 ]
+/* [ WORD 9 ]
 __asm__ statement.  */
 const char *string;
-/* [ WORD 12 ]
+/* [ WORD 10 ]
-Number of inputs, outputs and clobbers.  */
+Number of inputs, outputs, clobbers, labels.  */
 unsigned char ni;
 unsigned char no;
-unsigned short nc;
+unsigned char nc;
+unsigned char nl;
-/* [ WORD 13 ]
+/* [ WORD 11 ]
 Operand vector.  NOTE!  This must always be the last field
 of this structure.  In particular, this means that this
 structure cannot be embedded inside another one.  */
 tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1];
 };
 /* GIMPLE_OMP_CRITICAL */
-struct gimple_statement_omp_critical GTY(())
+struct GTY(()) gimple_statement_omp_critical {
-{
 /* [ WORD 1-5 ]  */
 struct gimple_statement_omp omp;
 /* [ WORD 6 ]
 Critical section name.  */
 tree name;
 };
-struct gimple_omp_for_iter GTY(())
+struct GTY(()) gimple_omp_for_iter {
-{
 /* Condition code.  */
 enum tree_code cond;
 /* Index variable.  */
 tree index;
 /* Initial value.  */
 tree initial;
 /* Final value.  */
 tree final;
 /* Increment.  */
 tree incr;
 };
 /* GIMPLE_OMP_FOR */
-struct gimple_statement_omp_for GTY(())
+struct GTY(()) gimple_statement_omp_for {
-{
 /* [ WORD 1-5 ]  */
 struct gimple_statement_omp omp;
 /* [ WORD 6 ]  */
 tree clauses;
 };
 /* GIMPLE_OMP_PARALLEL */
-struct gimple_statement_omp_parallel GTY(())
+struct GTY(()) gimple_statement_omp_parallel {
-{
 /* [ WORD 1-5 ]  */
 struct gimple_statement_omp omp;
 /* [ WORD 6 ]
 Clauses.  */
 };
 /* GIMPLE_OMP_TASK */
-struct gimple_statement_omp_task GTY(())
+struct GTY(()) gimple_statement_omp_task {
-{
 /* [ WORD 1-8 ]  */
 struct gimple_statement_omp_parallel par;
 /* [ WORD 9 ]
 Child function holding firstprivate initialization if needed.  */
 /* Uses struct gimple_statement_omp.  */
 /* GIMPLE_OMP_SECTIONS */
-struct gimple_statement_omp_sections GTY(())
+struct GTY(()) gimple_statement_omp_sections {
-{
 /* [ WORD 1-5 ]  */
 struct gimple_statement_omp omp;
 /* [ WORD 6 ]  */
 tree clauses;
 /* GIMPLE_OMP_CONTINUE.
 Note: This does not inherit from gimple_statement_omp, because we
 do not need the body field.  */
-struct gimple_statement_omp_continue GTY(())
+struct GTY(()) gimple_statement_omp_continue {
-{
 /* [ WORD 1-4 ]  */
 struct gimple_statement_base gsbase;
 /* [ WORD 5 ]  */
 tree control_def;
 tree control_use;
 };
 /* GIMPLE_OMP_SINGLE */
-struct gimple_statement_omp_single GTY(())
+struct GTY(()) gimple_statement_omp_single {
-{
 /* [ WORD 1-5 ]  */
 struct gimple_statement_omp omp;
 /* [ WORD 6 ]  */
 tree clauses;
 };
 /* GIMPLE_OMP_ATOMIC_LOAD.
 Note: This is based on gimple_statement_base, not g_s_omp, because g_s_omp
 contains a sequence, which we don't need here.  */
-struct gimple_statement_omp_atomic_load GTY(())
+struct GTY(()) gimple_statement_omp_atomic_load {
-{
 /* [ WORD 1-4 ]  */
 struct gimple_statement_base gsbase;
 /* [ WORD 5-6 ]  */
 tree rhs, lhs;
 };
 /* GIMPLE_OMP_ATOMIC_STORE.
 See note on GIMPLE_OMP_ATOMIC_LOAD.  */
-struct gimple_statement_omp_atomic_store GTY(())
+struct GTY(()) gimple_statement_omp_atomic_store {
-{
 /* [ WORD 1-4 ]  */
 struct gimple_statement_base gsbase;
 /* [ WORD 5 ]  */
 tree val;
 };
+#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP)	SYM,
 enum gimple_statement_structure_enum {
-#define DEFGSSTRUCT(SYM, STRING)	SYM,
 #include "gsstruct.def"
-#undef DEFGSSTRUCT
 LAST_GSS_ENUM
 };
+#undef DEFGSSTRUCT
 /* Define the overall contents of a gimple tuple.  It may be any of the
 structures declared above for various types of tuples.  */
-union gimple_statement_d GTY ((desc ("gimple_statement_structure (&%h)")))
+union GTY ((desc ("gimple_statement_structure (&%h)"))) gimple_statement_d {
-{
 struct gimple_statement_base GTY ((tag ("GSS_BASE"))) gsbase;
 struct gimple_statement_with_ops GTY ((tag ("GSS_WITH_OPS"))) gsops;
+struct gimple_statement_with_memory_ops_base GTY ((tag ("GSS_WITH_MEM_OPS_BASE"))) gsmembase;
 struct gimple_statement_with_memory_ops GTY ((tag ("GSS_WITH_MEM_OPS"))) gsmem;
 struct gimple_statement_omp GTY ((tag ("GSS_OMP"))) omp;
 struct gimple_statement_bind GTY ((tag ("GSS_BIND"))) gimple_bind;
 struct gimple_statement_catch GTY ((tag ("GSS_CATCH"))) gimple_catch;
 struct gimple_statement_eh_filter GTY ((tag ("GSS_EH_FILTER"))) gimple_eh_filter;
+struct gimple_statement_eh_mnt GTY ((tag ("GSS_EH_MNT"))) gimple_eh_mnt;
 struct gimple_statement_phi GTY ((tag ("GSS_PHI"))) gimple_phi;
-struct gimple_statement_resx GTY ((tag ("GSS_RESX"))) gimple_resx;
+struct gimple_statement_eh_ctrl GTY ((tag ("GSS_EH_CTRL"))) gimple_eh_ctrl;
 struct gimple_statement_try GTY ((tag ("GSS_TRY"))) gimple_try;
 struct gimple_statement_wce GTY ((tag ("GSS_WCE"))) gimple_wce;
 struct gimple_statement_asm GTY ((tag ("GSS_ASM"))) gimple_asm;
 struct gimple_statement_omp_critical GTY ((tag ("GSS_OMP_CRITICAL"))) gimple_omp_critical;
 struct gimple_statement_omp_for GTY ((tag ("GSS_OMP_FOR"))) gimple_omp_for;
 struct gimple_statement_omp_atomic_load GTY ((tag ("GSS_OMP_ATOMIC_LOAD"))) gimple_omp_atomic_load;
 struct gimple_statement_omp_atomic_store GTY ((tag ("GSS_OMP_ATOMIC_STORE"))) gimple_omp_atomic_store;
 };
 /* In gimple.c.  */
+/* Offset in bytes to the location of the operand vector.
+Zero if there is no operand vector for this tuple structure.  */
+extern size_t const gimple_ops_offset_[];
+/* Map GIMPLE codes to GSS codes.  */
+extern enum gimple_statement_structure_enum const gss_for_code_[];
+/* This variable holds the currently expanded gimple statement for purposes
+of comminucating the profile info to the builtin expanders.  */
+extern gimple currently_expanding_gimple_stmt;
 gimple gimple_build_return (tree);
 gimple gimple_build_assign_stat (tree, tree MEM_STAT_DECL);
 #define gimple_build_assign(l,r) gimple_build_assign_stat (l, r MEM_STAT_INFO)
 gimple gimple_build_assign_with_ops_stat (enum tree_code, tree, tree,
 					  tree MEM_STAT_DECL);
 #define gimple_build_assign_with_ops(c,o1,o2,o3) \
 gimple_build_assign_with_ops_stat (c, o1, o2, o3 MEM_STAT_INFO)
+gimple gimple_build_debug_bind_stat (tree, tree, gimple MEM_STAT_DECL);
+#define gimple_build_debug_bind(var,val,stmt)			\
+gimple_build_debug_bind_stat ((var), (val), (stmt) MEM_STAT_INFO)
 gimple gimple_build_call_vec (tree, VEC(tree, heap) *);
 gimple gimple_build_call (tree, unsigned, ...);
 gimple gimple_build_call_from_tree (tree);
 gimple gimplify_assign (tree, tree, gimple_seq *);
 gimple gimple_build_cond (enum tree_code, tree, tree, tree, tree);
 gimple gimple_build_label (tree label);
 gimple gimple_build_goto (tree dest);
 gimple gimple_build_nop (void);
 gimple gimple_build_bind (tree, gimple_seq, tree);
-gimple gimple_build_asm (const char *, unsigned, unsigned, unsigned, ...);
 gimple gimple_build_asm_vec (const char *, VEC(tree,gc) *, VEC(tree,gc) *,
-VEC(tree,gc) *);
+VEC(tree,gc) *, VEC(tree,gc) *);
 gimple gimple_build_catch (tree, gimple_seq);
 gimple gimple_build_eh_filter (tree, gimple_seq);
+gimple gimple_build_eh_must_not_throw (tree);
 gimple gimple_build_try (gimple_seq, gimple_seq, enum gimple_try_flags);
 gimple gimple_build_wce (gimple_seq);
 gimple gimple_build_resx (int);
+gimple gimple_build_eh_dispatch (int);
+gimple gimple_build_switch_nlabels (unsigned, tree, tree);
 gimple gimple_build_switch (unsigned, tree, tree, ...);
 gimple gimple_build_switch_vec (tree, tree, VEC(tree,heap) *);
 gimple gimple_build_omp_parallel (gimple_seq, tree, tree, tree);
 gimple gimple_build_omp_task (gimple_seq, tree, tree, tree, tree, tree, tree);
 gimple gimple_build_omp_for (gimple_seq, tree, size_t, gimple_seq);
 gimple gimple_build_omp_single (gimple_seq, tree);
 gimple gimple_build_cdt (tree, tree);
 gimple gimple_build_omp_atomic_load (tree, tree);
 gimple gimple_build_omp_atomic_store (tree);
 gimple gimple_build_predict (enum br_predictor, enum prediction);
-enum gimple_statement_structure_enum gimple_statement_structure (gimple);
 enum gimple_statement_structure_enum gss_for_assign (enum tree_code);
 void sort_case_labels (VEC(tree,heap) *);
 void gimple_set_body (tree, gimple_seq);
 gimple_seq gimple_body (tree);
 bool gimple_has_body_p (tree);
 void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree);
 void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *, enum tree_code,
 				     tree, tree);
 tree gimple_get_lhs (const_gimple);
 void gimple_set_lhs (gimple, tree);
+void gimple_replace_lhs (gimple, tree);
 gimple gimple_copy (gimple);
 bool is_gimple_operand (const_tree);
 void gimple_set_modified (gimple, bool);
 void gimple_cond_get_ops_from_tree (tree, enum tree_code *, tree *, tree *);
 gimple gimple_build_cond_from_tree (tree, tree, tree);
 bool gimple_could_trap_p (gimple);
 bool gimple_assign_rhs_could_trap_p (gimple);
 void gimple_regimplify_operands (gimple, gimple_stmt_iterator *);
 bool empty_body_p (gimple_seq);
 unsigned get_gimple_rhs_num_ops (enum tree_code);
+#define gimple_alloc(c, n) gimple_alloc_stat (c, n MEM_STAT_INFO)
+gimple gimple_alloc_stat (enum gimple_code, unsigned MEM_STAT_DECL);
+const char *gimple_decl_printable_name (tree, int);
+tree gimple_fold_obj_type_ref (tree, tree);
 /* Returns true iff T is a valid GIMPLE statement.  */
 extern bool is_gimple_stmt (tree);
 /* Returns true iff TYPE is a valid type for a scalar register variable.  */
 extern bool is_gimple_reg_type (tree);
 /* Returns true iff T is a scalar register variable.  */
 extern bool is_gimple_reg (tree);
-/* Returns true if T is a GIMPLE temporary variable, false otherwise.  */
-extern bool is_gimple_formal_tmp_var (tree);
-/* Returns true if T is a GIMPLE temporary register variable.  */
-extern bool is_gimple_formal_tmp_reg (tree);
 /* Returns true iff T is any sort of variable.  */
 extern bool is_gimple_variable (tree);
 /* Returns true iff T is any sort of symbol.  */
 extern bool is_gimple_id (tree);
 /* Returns true iff T is a variable or an INDIRECT_REF (of a variable).  */
 /* Returns true iff T is a GIMPLE asm statement input.  */
 extern bool is_gimple_asm_val (tree);
 /* Returns true iff T is a valid rhs for a MODIFY_EXPR where the LHS is a
 GIMPLE temporary, a renamed user variable, or something else,
 respectively.  */
-extern bool is_gimple_formal_tmp_rhs (tree);
 extern bool is_gimple_reg_rhs (tree);
 extern bool is_gimple_mem_rhs (tree);
 /* Returns true iff T is a valid if-statement condition.  */
 extern bool is_gimple_condexpr (tree);
 extern bool is_gimple_call_addr (tree);
 /* If T makes a function call, returns the CALL_EXPR operand.  */
 extern tree get_call_expr_in (tree t);
 extern void recalculate_side_effects (tree);
+extern bool compare_field_offset (tree, tree);
+extern tree gimple_register_type (tree);
+extern void print_gimple_types_stats (void);
+extern void free_gimple_type_tables (void);
+extern tree gimple_unsigned_type (tree);
+extern tree gimple_signed_type (tree);
+extern alias_set_type gimple_get_alias_set (tree);
+extern void count_uses_and_derefs (tree, gimple, unsigned *, unsigned *,
+				   unsigned *);
+extern bool walk_stmt_load_store_addr_ops (gimple, void *,
+					   bool (*)(gimple, tree, void *),
+					   bool (*)(gimple, tree, void *),
+					   bool (*)(gimple, tree, void *));
+extern bool walk_stmt_load_store_ops (gimple, void *,
+				      bool (*)(gimple, tree, void *),
+				      bool (*)(gimple, tree, void *));
+extern bool gimple_ior_addresses_taken (bitmap, gimple);
 /* In gimplify.c  */
 extern tree create_tmp_var_raw (tree, const char *);
 extern tree create_tmp_var_name (const char *);
 extern tree create_tmp_var (tree, const char *);
 extern tree get_initialized_tmp_var (tree, gimple_seq *, gimple_seq *);
 extern tree get_formal_tmp_var (tree, gimple_seq *);
 extern void declare_vars (tree, gimple, bool);
-extern void tree_annotate_all_with_location (tree *, location_t);
 extern void annotate_all_with_location (gimple_seq, location_t);
 /* Validation of GIMPLE expressions.  Note that these predicates only check
 the basic form of the expression, they don't recurse to make sure that
 underlying nodes are also of the right form.  */
 typedef bool (*gimple_predicate)(tree);
 /* FIXME we should deduce this from the predicate.  */
-typedef enum fallback_t {
+enum fallback {
 fb_none = 0,		/* Do not generate a temporary.  */
 fb_rvalue = 1,	/* Generate an rvalue to hold the result of a
 			   gimplified expression.  */
 			   gimplified expression.  */
 fb_mayfail = 4,	/* Gimplification may fail.  Error issued
 			   afterwards.  */
 fb_either= fb_rvalue | fb_lvalue
-} fallback_t;
+};
+typedef int fallback_t;
 enum gimplify_status {
 GS_ERROR	= -2,	/* Something Bad Seen.  */
 GS_UNHANDLED	= -1,	/* A langhook result for "I dunno".  */
 GS_OK		= 0,	/* We did something, maybe more to do.  */
 VEC(gimple,heap) *bind_expr_stack;
 tree temps;
 gimple_seq conditional_cleanups;
 tree exit_label;
 tree return_temp;
 VEC(tree,heap) *case_labels;
 /* The formal temporary table.  Should this be persistent?  */
 htab_t temp_htab;
 int conditions;
 extern tree gimple_boolify (tree);
 extern gimple_predicate rhs_predicate_for (tree);
 extern tree canonicalize_cond_expr_cond (tree);
 /* In omp-low.c.  */
-extern void diagnose_omp_structured_block_errors (tree);
 extern tree omp_reduction_init (tree, tree);
 /* In tree-nested.c.  */
 extern void lower_nested_functions (tree);
 extern void insert_field_into_struct (tree, tree);
 extern tree gimple_assign_rhs_to_tree (gimple);
 /* In builtins.c  */
 extern bool validate_gimple_arglist (const_gimple, ...);
-/* In tree-ssa-operands.c  */
-extern void gimple_add_to_addresses_taken (gimple, tree);
 /* In tree-ssa.c  */
 extern bool tree_ssa_useless_type_conversion (tree);
+extern tree tree_ssa_strip_useless_type_conversions (tree);
 extern bool useless_type_conversion_p (tree, tree);
 extern bool types_compatible_p (tree, tree);
 /* Return the code for GIMPLE statement G.  */
 static inline enum gimple_code
 gimple_code (const_gimple g)
 {
 return g->gsbase.code;
+}
+/* Return the GSS code used by a GIMPLE code.  */
+static inline enum gimple_statement_structure_enum
+gss_for_code (enum gimple_code code)
+{
+gcc_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE);
+return gss_for_code_[code];
+}
+/* Return which GSS code is used by GS.  */
+static inline enum gimple_statement_structure_enum
+gimple_statement_structure (gimple gs)
+{
+return gss_for_code (gimple_code (gs));
 }
 /* Return true if statement G has sub-statements.  This is only true for
 High GIMPLE statements.  */
 default:
 return false;
 }
 }
 /* Return the basic block holding statement G.  */
 static inline struct basic_block_def *
 gimple_bb (const_gimple g)
 gimple_has_mem_ops (const_gimple g)
 {
 return gimple_code (g) >= GIMPLE_ASSIGN && gimple_code (g) <= GIMPLE_RETURN;
 }
-/* Return the set of addresses taken by statement G.  */
-static inline bitmap
-gimple_addresses_taken (const_gimple g)
-{
-if (gimple_has_ops (g))
-return g->gsops.opbase.addresses_taken;
-else
-return NULL;
-}
-/* Return a pointer to the set of addresses taken by statement G.  */
-static inline bitmap *
-gimple_addresses_taken_ptr (gimple g)
-{
-if (gimple_has_ops (g))
-return &g->gsops.opbase.addresses_taken;
-else
-return NULL;
-}
-/* Set B to be the set of addresses taken by statement G.  The
-previous set is freed.  */
-static inline void
-gimple_set_addresses_taken (gimple g, bitmap b)
-{
-gcc_assert (gimple_has_ops (g));
-BITMAP_FREE (g->gsops.opbase.addresses_taken);
-g->gsops.opbase.addresses_taken = b;
-}
 /* Return the set of DEF operands for statement G.  */
 static inline struct def_optype_d *
 gimple_def_ops (const_gimple g)
 gcc_assert (gimple_has_ops (g));
 g->gsops.opbase.use_ops = use;
 }
-/* Return the set of VUSE operands for statement G.  */
+/* Return the set of VUSE operand for statement G.  */
-static inline struct voptype_d *
+static inline use_operand_p
-gimple_vuse_ops (const_gimple g)
+gimple_vuse_op (const_gimple g)
+{
+struct use_optype_d *ops;
+if (!gimple_has_mem_ops (g))
+return NULL_USE_OPERAND_P;
+ops = g->gsops.opbase.use_ops;
+if (ops
+&& USE_OP_PTR (ops)->use == &g->gsmembase.vuse)
+return USE_OP_PTR (ops);
+return NULL_USE_OPERAND_P;
+}
+/* Return the set of VDEF operand for statement G.  */
+static inline def_operand_p
+gimple_vdef_op (const_gimple g)
+{
+struct def_optype_d *ops;
+if (!gimple_has_mem_ops (g))
+return NULL_DEF_OPERAND_P;
+ops = g->gsops.opbase.def_ops;
+if (ops
+&& DEF_OP_PTR (ops) == &g->gsmembase.vdef)
+return DEF_OP_PTR (ops);
+return NULL_DEF_OPERAND_P;
+}
+/* Return the single VUSE operand of the statement G.  */
+static inline tree
+gimple_vuse (const_gimple g)
+{
+if (!gimple_has_mem_ops (g))
+return NULL_TREE;
+return g->gsmembase.vuse;
+}
+/* Return the single VDEF operand of the statement G.  */
+static inline tree
+gimple_vdef (const_gimple g)
+{
+if (!gimple_has_mem_ops (g))
+return NULL_TREE;
+return g->gsmembase.vdef;
+}
+/* Return the single VUSE operand of the statement G.  */
+static inline tree *
+gimple_vuse_ptr (gimple g)
 {
 if (!gimple_has_mem_ops (g))
 return NULL;
-return g->gsmem.membase.vuse_ops;
+return &g->gsmembase.vuse;
 }
+/* Return the single VDEF operand of the statement G.  */
-/* Set OPS to be the set of VUSE operands for statement G.  */
+static inline tree *
-static inline void
+gimple_vdef_ptr (gimple g)
-gimple_set_vuse_ops (gimple g, struct voptype_d *ops)
-{
-gcc_assert (gimple_has_mem_ops (g));
-g->gsmem.membase.vuse_ops = ops;
-}
-/* Return the set of VDEF operands for statement G.  */
-static inline struct voptype_d *
-gimple_vdef_ops (const_gimple g)
 {
 if (!gimple_has_mem_ops (g))
 return NULL;
-return g->gsmem.membase.vdef_ops;
+return &g->gsmembase.vdef;
 }
+/* Set the single VUSE operand of the statement G.  */
-/* Set OPS to be the set of VDEF operands for statement G.  */
+static inline void
-static inline void
+gimple_set_vuse (gimple g, tree vuse)
-gimple_set_vdef_ops (gimple g, struct voptype_d *ops)
 {
 gcc_assert (gimple_has_mem_ops (g));
-g->gsmem.membase.vdef_ops = ops;
+g->gsmembase.vuse = vuse;
 }
+/* Set the single VDEF operand of the statement G.  */
-/* Return the set of symbols loaded by statement G.  Each element of the
-set is the DECL_UID of the corresponding symbol.  */
+static inline void
+gimple_set_vdef (gimple g, tree vdef)
-static inline bitmap
+{
-gimple_loaded_syms (const_gimple g)
+gcc_assert (gimple_has_mem_ops (g));
-{
+g->gsmembase.vdef = vdef;
-if (!gimple_has_mem_ops (g))
-return NULL;
-return g->gsmem.membase.loads;
-}
-/* Return the set of symbols stored by statement G.  Each element of
-the set is the DECL_UID of the corresponding symbol.  */
-static inline bitmap
-gimple_stored_syms (const_gimple g)
-{
-if (!gimple_has_mem_ops (g))
-return NULL;
-return g->gsmem.membase.stores;
 }
 /* Return true if statement G has operands and the modified field has
 been set.  */
 /* Return true if statement STMT may access memory.  */
 static inline bool
 gimple_references_memory_p (gimple stmt)
 {
-return gimple_has_mem_ops (stmt) && stmt->gsbase.references_memory_p;
+return gimple_has_mem_ops (stmt) && gimple_vuse (stmt);
 }
-/* Set the REFERENCES_MEMORY_P flag for STMT to MEM_P.  */
-static inline void
-gimple_set_references_memory (gimple stmt, bool mem_p)
-{
-if (gimple_has_mem_ops (stmt))
-stmt->gsbase.references_memory_p = (unsigned) mem_p;
-}
 /* Return the subcode for OMP statement S.  */
 static inline unsigned
 gimple_omp_subcode (const_gimple s)
 /* Return the array of operands for statement GS.  */
 static inline tree *
 gimple_ops (gimple gs)
 {
-/* Offset in bytes to the location of the operand vector in every
+size_t off;
-tuple structure.  Defined in gimple.c  */
-extern size_t const gimple_ops_offset_[];
-if (!gimple_has_ops (gs))
-return NULL;
 /* All the tuples have their operand vector at the very bottom
-of the structure.  */
+of the structure.  Note that those structures that do not
-return ((tree *) ((char *) gs + gimple_ops_offset_[gimple_code (gs)]));
+have an operand vector have a zero offset.  */
+off = gimple_ops_offset_[gimple_statement_structure (gs)];
+gcc_assert (off != 0);
+return (tree *) ((char *) gs + off);
 }
 /* Return operand I for statement GS.  */
 static inline void
 gimple_call_set_fndecl (gimple gs, tree decl)
 {
 GIMPLE_CHECK (gs, GIMPLE_CALL);
 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
-gimple_set_op (gs, 1, build_fold_addr_expr (decl));
+gimple_set_op (gs, 1, build_fold_addr_expr_loc (gimple_location (gs), decl));
 }
 /* If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it.
 Otherwise return NULL.  This function is analogous to
 static inline enum tree_code
 gimple_cond_code (const_gimple gs)
 {
 GIMPLE_CHECK (gs, GIMPLE_COND);
-return gs->gsbase.subcode;
+return (enum tree_code) gs->gsbase.subcode;
 }
 /* Set CODE to be the predicate code for the conditional statement GS.  */
 }
 /* Set DEST to be the destination of the unconditonal jump GS.  */
 static inline void
 gimple_goto_set_dest (gimple gs, tree dest)
 {
 GIMPLE_CHECK (gs, GIMPLE_GOTO);
 gcc_assert (is_gimple_operand (dest));
 gimple_set_op (gs, 0, dest);
 {
 GIMPLE_CHECK (gs, GIMPLE_ASM);
 return gs->gimple_asm.nc;
 }
+/* Return the number of label operands for GIMPLE_ASM GS.  */
+static inline unsigned
+gimple_asm_nlabels (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+return gs->gimple_asm.nl;
+}
 /* Return input operand INDEX of GIMPLE_ASM GS.  */
 static inline tree
 gimple_asm_input_op (const_gimple gs, unsigned index)
 gcc_assert (index <= gs->gimple_asm.nc);
 gcc_assert (TREE_CODE (clobber_op) == TREE_LIST);
 gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no, clobber_op);
 }
+/* Return label operand INDEX of GIMPLE_ASM GS.  */
+static inline tree
+gimple_asm_label_op (const_gimple gs, unsigned index)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+gcc_assert (index <= gs->gimple_asm.nl);
+return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc);
+}
+/* Set LABEL_OP to be label operand INDEX in GIMPLE_ASM GS.  */
+static inline void
+gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+gcc_assert (index <= gs->gimple_asm.nl);
+gcc_assert (TREE_CODE (label_op) == TREE_LIST);
+gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc, label_op);
+}
 /* Return the string representing the assembly instruction in
 GIMPLE_ASM GS.  */
 static inline const char *
 {
 GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
 gs->gimple_eh_filter.failure = failure;
 }
-/* Return the EH_FILTER_MUST_NOT_THROW flag.  */
+/* Get the function decl to be called by the MUST_NOT_THROW region.  */
-static inline bool
+static inline tree
+gimple_eh_must_not_throw_fndecl (gimple gs)
-gimple_eh_filter_must_not_throw (gimple gs)
+{
-{
+GIMPLE_CHECK (gs, GIMPLE_EH_MUST_NOT_THROW);
-GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
+return gs->gimple_eh_mnt.fndecl;
-return gs->gsbase.subcode != 0;
+}
-}
+/* Set the function decl to be called by GS to DECL.  */
-/* Set the EH_FILTER_MUST_NOT_THROW flag to the value MNTP.  */
+static inline void
-static inline void
+gimple_eh_must_not_throw_set_fndecl (gimple gs, tree decl)
-gimple_eh_filter_set_must_not_throw (gimple gs, bool mntp)
+{
-{
+GIMPLE_CHECK (gs, GIMPLE_EH_MUST_NOT_THROW);
-GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
+gs->gimple_eh_mnt.fndecl = decl;
-gs->gsbase.subcode = (unsigned int) mntp;
 }
 /* GIMPLE_TRY accessors. */
 static inline int
 gimple_resx_region (const_gimple gs)
 {
 GIMPLE_CHECK (gs, GIMPLE_RESX);
-return gs->gimple_resx.region;
+return gs->gimple_eh_ctrl.region;
 }
 /* Set REGION to be the region number for GIMPLE_RESX GS.  */
 static inline void
 gimple_resx_set_region (gimple gs, int region)
 {
 GIMPLE_CHECK (gs, GIMPLE_RESX);
-gs->gimple_resx.region = region;
+gs->gimple_eh_ctrl.region = region;
 }
+/* Return the region number for GIMPLE_EH_DISPATCH GS.  */
+static inline int
+gimple_eh_dispatch_region (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_EH_DISPATCH);
+return gs->gimple_eh_ctrl.region;
+}
+/* Set REGION to be the region number for GIMPLE_EH_DISPATCH GS.  */
+static inline void
+gimple_eh_dispatch_set_region (gimple gs, int region)
+{
+GIMPLE_CHECK (gs, GIMPLE_EH_DISPATCH);
+gs->gimple_eh_ctrl.region = region;
+}
 /* Return the number of labels associated with the switch statement GS.  */
 static inline unsigned
 gimple_switch_num_labels (const_gimple gs)
 gimple_switch_set_default_label (gimple gs, tree label)
 {
 gimple_switch_set_label (gs, 0, label);
 }
+/* Return true if GS is a GIMPLE_DEBUG statement.  */
+static inline bool
+is_gimple_debug (const_gimple gs)
+{
+return gimple_code (gs) == GIMPLE_DEBUG;
+}
+/* Return true if S is a GIMPLE_DEBUG BIND statement.  */
+static inline bool
+gimple_debug_bind_p (const_gimple s)
+{
+if (is_gimple_debug (s))
+return s->gsbase.subcode == GIMPLE_DEBUG_BIND;
+return false;
+}
+/* Return the variable bound in a GIMPLE_DEBUG bind statement.  */
+static inline tree
+gimple_debug_bind_get_var (gimple dbg)
+{
+GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+gcc_assert (gimple_debug_bind_p (dbg));
+return gimple_op (dbg, 0);
+}
+/* Return the value bound to the variable in a GIMPLE_DEBUG bind
+statement.  */
+static inline tree
+gimple_debug_bind_get_value (gimple dbg)
+{
+GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+gcc_assert (gimple_debug_bind_p (dbg));
+return gimple_op (dbg, 1);
+}
+/* Return a pointer to the value bound to the variable in a
+GIMPLE_DEBUG bind statement.  */
+static inline tree *
+gimple_debug_bind_get_value_ptr (gimple dbg)
+{
+GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+gcc_assert (gimple_debug_bind_p (dbg));
+return gimple_op_ptr (dbg, 1);
+}
+/* Set the variable bound in a GIMPLE_DEBUG bind statement.  */
+static inline void
+gimple_debug_bind_set_var (gimple dbg, tree var)
+{
+GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+gcc_assert (gimple_debug_bind_p (dbg));
+gimple_set_op (dbg, 0, var);
+}
+/* Set the value bound to the variable in a GIMPLE_DEBUG bind
+statement.  */
+static inline void
+gimple_debug_bind_set_value (gimple dbg, tree value)
+{
+GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+gcc_assert (gimple_debug_bind_p (dbg));
+gimple_set_op (dbg, 1, value);
+}
+/* The second operand of a GIMPLE_DEBUG_BIND, when the value was
+optimized away.  */
+#define GIMPLE_DEBUG_BIND_NOVALUE NULL_TREE /* error_mark_node */
+/* Remove the value bound to the variable in a GIMPLE_DEBUG bind
+statement.  */
+static inline void
+gimple_debug_bind_reset_value (gimple dbg)
+{
+GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+gcc_assert (gimple_debug_bind_p (dbg));
+gimple_set_op (dbg, 1, GIMPLE_DEBUG_BIND_NOVALUE);
+}
+/* Return true if the GIMPLE_DEBUG bind statement is bound to a
+value.  */
+static inline bool
+gimple_debug_bind_has_value_p (gimple dbg)
+{
+GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+gcc_assert (gimple_debug_bind_p (dbg));
+return gimple_op (dbg, 1) != GIMPLE_DEBUG_BIND_NOVALUE;
+}
+#undef GIMPLE_DEBUG_BIND_NOVALUE
 /* Return the body for the OMP statement GS.  */
 static inline gimple_seq
 gimple_omp_body (gimple gs)
 {
 return gs->omp.body;
 }
 }
 /* Returns true when the gimple statment STMT is any of the OpenMP types.  */
+#define CASE_GIMPLE_OMP				\
+case GIMPLE_OMP_PARALLEL:			\
+case GIMPLE_OMP_TASK:			\
+case GIMPLE_OMP_FOR:			\
+case GIMPLE_OMP_SECTIONS:			\
+case GIMPLE_OMP_SECTIONS_SWITCH:		\
+case GIMPLE_OMP_SINGLE:			\
+case GIMPLE_OMP_SECTION:			\
+case GIMPLE_OMP_MASTER:			\
+case GIMPLE_OMP_ORDERED:			\
+case GIMPLE_OMP_CRITICAL:			\
+case GIMPLE_OMP_RETURN:			\
+case GIMPLE_OMP_ATOMIC_LOAD:		\
+case GIMPLE_OMP_ATOMIC_STORE:		\
+case GIMPLE_OMP_CONTINUE
 static inline bool
 is_gimple_omp (const_gimple stmt)
 {
-return (gimple_code (stmt) == GIMPLE_OMP_PARALLEL
+switch (gimple_code (stmt))
-	  || gimple_code (stmt) == GIMPLE_OMP_TASK
+{
-	  || gimple_code (stmt) == GIMPLE_OMP_FOR
+CASE_GIMPLE_OMP:
-	  || gimple_code (stmt) == GIMPLE_OMP_SECTIONS
+return true;
-	  || gimple_code (stmt) == GIMPLE_OMP_SECTIONS_SWITCH
+default:
-	  || gimple_code (stmt) == GIMPLE_OMP_SINGLE
+return false;
-	  || gimple_code (stmt) == GIMPLE_OMP_SECTION
+}
-	  || gimple_code (stmt) == GIMPLE_OMP_MASTER
-	  || gimple_code (stmt) == GIMPLE_OMP_ORDERED
-	  || gimple_code (stmt) == GIMPLE_OMP_CRITICAL
-	  || gimple_code (stmt) == GIMPLE_OMP_RETURN
-	  || gimple_code (stmt) == GIMPLE_OMP_ATOMIC_LOAD
-	  || gimple_code (stmt) == GIMPLE_OMP_ATOMIC_STORE
-	  || gimple_code (stmt) == GIMPLE_OMP_CONTINUE);
 }
 /* Returns TRUE if statement G is a GIMPLE_NOP.  */
 {
 return gimple_code (g) == GIMPLE_NOP;
 }
-/* Return the new type set by GIMPLE_CHANGE_DYNAMIC_TYPE statement GS.  */
+/* Return true if GS is a GIMPLE_RESX.  */
-static inline tree
+static inline bool
-gimple_cdt_new_type (gimple gs)
+is_gimple_resx (const_gimple gs)
 {
-GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
+return gimple_code (gs) == GIMPLE_RESX;
-return gimple_op (gs, 1);
+}
-}
-/* Return a pointer to the new type set by GIMPLE_CHANGE_DYNAMIC_TYPE
-statement GS.  */
-static inline tree *
-gimple_cdt_new_type_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
-return gimple_op_ptr (gs, 1);
-}
-/* Set NEW_TYPE to be the type returned by GIMPLE_CHANGE_DYNAMIC_TYPE
-statement GS.  */
-static inline void
-gimple_cdt_set_new_type (gimple gs, tree new_type)
-{
-GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
-gcc_assert (TREE_CODE_CLASS (TREE_CODE (new_type)) == tcc_type);
-gimple_set_op (gs, 1, new_type);
-}
-/* Return the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE statement GS.  */
-static inline tree
-gimple_cdt_location (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
-return gimple_op (gs, 0);
-}
-/* Return a pointer to the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE
-statement GS.  */
-static inline tree *
-gimple_cdt_location_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
-return gimple_op_ptr (gs, 0);
-}
-/* Set PTR to be the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE
-statement GS.  */
-static inline void
-gimple_cdt_set_location (gimple gs, tree ptr)
-{
-GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
-gimple_set_op (gs, 0, ptr);
-}
 /* Return the predictor of GIMPLE_PREDICT statement GS.  */
 static inline enum br_predictor
 gimple_predict_predictor (gimple gs)
 	  default:
 	    /* As fallback use the type of the LHS.  */
 	    type = TREE_TYPE (gimple_get_lhs (stmt));
 	    break;
 	  }
-/* Integral sub-types are never the type of the expression,
-but they still can be the type of the result as the base
-	 type (in which expressions are computed) is trivially
-	 convertible to one of its sub-types.  So always return
-	 the base type here.  */
-if (INTEGRAL_TYPE_P (type)
-	  && TREE_TYPE (type)
-	  /* But only if they are trivially convertible.  */
-	  && useless_type_conversion_p (type, TREE_TYPE (type)))
-	type = TREE_TYPE (type);
 return type;
 }
 else if (code == GIMPLE_COND)
 return boolean_type_node;
 else
 static inline gimple_stmt_iterator
 gsi_start_bb (basic_block bb)
 {
 gimple_stmt_iterator i;
 gimple_seq seq;
 seq = bb_seq (bb);
 i.ptr = gimple_seq_first (seq);
 i.seq = seq;
 i.bb = bb;
 gsi_next (&gsi);
 return gsi;
 }
+/* Advance the iterator to the next non-debug gimple statement.  */
+static inline void
+gsi_next_nondebug (gimple_stmt_iterator *i)
+{
+do
+{
+gsi_next (i);
+}
+while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i)));
+}
+/* Advance the iterator to the next non-debug gimple statement.  */
+static inline void
+gsi_prev_nondebug (gimple_stmt_iterator *i)
+{
+do
+{
+gsi_prev (i);
+}
+while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i)));
+}
+/* Return a new iterator pointing to the first non-debug statement in
+basic block BB.  */
+static inline gimple_stmt_iterator
+gsi_start_nondebug_bb (basic_block bb)
+{
+gimple_stmt_iterator i = gsi_start_bb (bb);
+if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
+gsi_next_nondebug (&i);
+return i;
+}
+/* Return a new iterator pointing to the last non-debug statement in
+basic block BB.  */
+static inline gimple_stmt_iterator
+gsi_last_nondebug_bb (basic_block bb)
+{
+gimple_stmt_iterator i = gsi_last_bb (bb);
+if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
+gsi_prev_nondebug (&i);
+return i;
+}
 /* Return a pointer to the current stmt.
 NOTE: You may want to use gsi_replace on the iterator itself,
 as this performs additional bookkeeping that will not be done
 if you simply assign through a pointer returned by gsi_stmt_ptr.  */
 static inline gimple *

Mercurial > hg > CbC > CbC_gcc

comparison gcc/gimple.h @ 57:326d9e06c2e3