CbC/CbC_gcc: gcc/gimple.h comparison

comparison gcc/gimple.h @ 69:1b10fe6932e1

merge 69

author	Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Sun, 21 Aug 2011 07:53:12 +0900
parents	326d9e06c2e3 f6334be47118
children	b81903832de2

comparison

equal deleted inserted replaced

-:b362627d71ba
+:1b10fe6932e1
 /* Gimple IR definitions.
-Copyright 2007, 2008, 2009 Free Software Foundation, Inc.
+Copyright 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
 Contributed by Aldy Hernandez <aldyh@redhat.com>
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #ifndef GCC_GIMPLE_H
 #define GCC_GIMPLE_H
 #include "pointer-set.h"
 #include "vec.h"
+#include "vecprim.h"
+#include "vecir.h"
 #include "ggc.h"
-#include "tm.h"
-#include "hard-reg-set.h"
 #include "basic-block.h"
 #include "tree-ssa-operands.h"
+#include "tree-ssa-alias.h"
-DEF_VEC_P(gimple);
-DEF_VEC_ALLOC_P(gimple,heap);
+struct gimple_seq_node_d;
-DEF_VEC_ALLOC_P(gimple,gc);
+typedef struct gimple_seq_node_d *gimple_seq_node;
+typedef const struct gimple_seq_node_d *const_gimple_seq_node;
-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
 these vectors.  */
 typedef VEC(gimple, heap) *gimple_vec;
 DEF_VEC_P (gimple_vec);
 extern const char *const gimple_code_name[];
 extern const unsigned char gimple_rhs_class_table[];
 /* Error out if a gimple tuple is addressed incorrectly.  */
 #if defined ENABLE_GIMPLE_CHECKING
+#define gcc_gimple_checking_assert(EXPR) gcc_assert (EXPR)
 extern void gimple_check_failed (const_gimple, const char *, int,          \
 const char *, enum gimple_code,           \
 				 enum tree_code) ATTRIBUTE_NORETURN;
 #define GIMPLE_CHECK(GS, CODE)						\
 if (gimple_code (__gs) != (CODE))					\
 gimple_check_failed (__gs, __FILE__, __LINE__, __FUNCTION__,	\
 	  		   (CODE), ERROR_MARK);				\
 } while (0)
 #else  /* not ENABLE_GIMPLE_CHECKING  */
+#define gcc_gimple_checking_assert(EXPR) ((void)(0 && (EXPR)))
 #define GIMPLE_CHECK(GS, CODE)			(void)0
 #endif
 /* Class of GIMPLE expressions suitable for the RHS of assignments.  See
 get_gimple_rhs_class.  */
 enum gimple_rhs_class
 {
 GIMPLE_INVALID_RHS,	/* The expression cannot be used on the RHS.  */
+GIMPLE_TERNARY_RHS,	/* The expression is a ternary operation.  */
 GIMPLE_BINARY_RHS,	/* The expression is a binary operation.  */
 GIMPLE_UNARY_RHS,	/* The expression is a unary operation.  */
 GIMPLE_SINGLE_RHS	/* The expression is a single object (an SSA
 			   name, a _DECL, a _REF, etc.  */
 };
 GF_CALL_TAILCALL		= 1 << 3,
 GF_CALL_VA_ARG_PACK		= 1 << 4,
 #ifndef noCbC
 	GF_CALL_CBC_GOTO		= 1 << 5,
 #endif
+GF_CALL_NOTHROW		= 1 << 5,
 GF_OMP_PARALLEL_COMBINED	= 1 << 0,
 /* True on an GIMPLE_OMP_RETURN statement if the return does not require
 a thread synchronization via some sort of barrier.  The exact barrier
 that would otherwise be emitted is dependent on the OMP statement with
 }
 void gimple_seq_add_stmt (gimple_seq *, gimple);
+/* Link gimple statement GS to the end of the sequence *SEQ_P.  If
+*SEQ_P is NULL, a new sequence is allocated.  This function is
+similar to gimple_seq_add_stmt, but does not scan the operands.
+During gimplification, we need to manipulate statement sequences
+before the def/use vectors have been constructed.  */
+void gimplify_seq_add_stmt (gimple_seq *, gimple);
 /* Allocate a new sequence and initialize its first element with STMT.  */
 static inline gimple_seq
 gimple_seq_alloc_with_stmt (gimple stmt)
 {
 /* Sets the sequence of statements in BB to SEQ.  */
 static inline void
 set_bb_seq (basic_block bb, gimple_seq seq)
 {
-gcc_assert (!(bb->flags & BB_RTL));
+gcc_checking_assert (!(bb->flags & BB_RTL));
 bb->il.gimple->seq = seq;
 }
 /* Iterator object for GIMPLE statement sequences.  */
 structure cannot be embedded inside another one.  */
 tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1];
 };
+/* Call statements that take both memory and register operands.  */
+struct GTY(()) gimple_statement_call
+{
+/* [ WORD 1-8 ]  */
+struct gimple_statement_with_memory_ops_base membase;
+/* [ WORD 9-12 ]  */
+struct pt_solution call_used;
+struct pt_solution call_clobbered;
+/* [ WORD 13 ]
+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 GTY(()) gimple_statement_omp {
 /* [ WORD 1-4 ]  */
 struct gimple_statement_base gsbase;
 /* Define the overall contents of a gimple tuple.  It may be any of the
 structures declared above for various types of tuples.  */
-union GTY ((desc ("gimple_statement_structure (&%h)"))) gimple_statement_d {
+union GTY ((desc ("gimple_statement_structure (&%h)"), variable_size)) 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_call GTY ((tag ("GSS_CALL"))) gimple_call;
 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;
 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)
-void extract_ops_from_tree (tree, enum tree_code *, tree *, tree *);
+void extract_ops_from_tree_1 (tree, enum tree_code *, tree *, tree *, tree *);
 gimple gimple_build_assign_with_ops_stat (enum tree_code, tree, tree,
-					  tree MEM_STAT_DECL);
+					  tree, tree MEM_STAT_DECL);
-#define gimple_build_assign_with_ops(c,o1,o2,o3) \
+#define gimple_build_assign_with_ops(c,o1,o2,o3)			\
-gimple_build_assign_with_ops_stat (c, o1, o2, o3 MEM_STAT_INFO)
+gimple_build_assign_with_ops_stat (c, o1, o2, o3, NULL_TREE MEM_STAT_INFO)
+#define gimple_build_assign_with_ops3(c,o1,o2,o3,o4)			\
+gimple_build_assign_with_ops_stat (c, o1, o2, o3, o4 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_seq gimple_seq_alloc (void);
 void gimple_seq_free (gimple_seq);
 void gimple_seq_add_seq (gimple_seq *, gimple_seq);
 gimple_seq gimple_seq_copy (gimple_seq);
 int gimple_call_flags (const_gimple);
+int gimple_call_return_flags (const_gimple);
+int gimple_call_arg_flags (const_gimple, unsigned);
+void gimple_call_reset_alias_info (gimple);
 bool gimple_assign_copy_p (gimple);
 bool gimple_assign_ssa_name_copy_p (gimple);
-bool gimple_assign_single_p (gimple);
 bool gimple_assign_unary_nop_p (gimple);
 void gimple_set_bb (gimple, struct basic_block_def *);
-tree gimple_fold (const_gimple);
 void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree);
-void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *, enum tree_code,
+void gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator *, enum tree_code,
-				     tree, tree);
+				       tree, 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);
 void gimple_cond_set_condition_from_tree (gimple, tree);
 bool gimple_has_side_effects (const_gimple);
 bool gimple_rhs_has_side_effects (const_gimple);
 bool gimple_could_trap_p (gimple);
+bool gimple_could_trap_p_1 (gimple, bool, bool);
 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);
+bool gimple_fold_call (gimple_stmt_iterator *gsi, bool inplace);
+tree gimple_get_virt_mehtod_for_binfo (HOST_WIDE_INT, tree, tree *, bool);
+void gimple_adjust_this_by_delta (gimple_stmt_iterator *, 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);
 extern bool is_gimple_ip_invariant (const_tree);
 /* Returns true iff T is a GIMPLE rvalue.  */
 extern bool is_gimple_val (tree);
 /* Returns true iff T is a GIMPLE asm statement input.  */
 extern bool is_gimple_asm_val (tree);
+/* Returns true iff T is a valid address operand of a MEM_REF.  */
+bool is_gimple_mem_ref_addr (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_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);
-/* Returns true iff T is a type conversion.  */
-extern bool is_gimple_cast (tree);
 /* Returns true iff T is a variable that does not need to live in memory.  */
 extern bool is_gimple_non_addressable (tree t);
 /* Returns true iff T is a valid call address expression.  */
 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 bool gimple_compare_field_offset (tree, tree);
 extern tree gimple_register_type (tree);
+extern tree gimple_register_canonical_type (tree);
+enum gtc_mode { GTC_MERGE = 0, GTC_DIAG = 1 };
+extern bool gimple_types_compatible_p (tree, tree, enum gtc_mode);
 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);
 					   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);
+extern bool gimple_call_builtin_p (gimple, enum built_in_function);
 /* 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 create_tmp_reg (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 annotate_all_with_location (gimple_seq, location_t);
 extern void gimple_add_tmp_var (tree);
 extern gimple gimple_current_bind_expr (void);
 extern VEC(gimple, heap) *gimple_bind_expr_stack (void);
 extern tree voidify_wrapper_expr (tree, tree);
 extern tree build_and_jump (tree *);
-extern tree alloc_stmt_list (void);
-extern void free_stmt_list (tree);
 extern tree force_labels_r (tree *, int *, void *);
 extern enum gimplify_status gimplify_va_arg_expr (tree *, gimple_seq *,
 						  gimple_seq *);
 struct gimplify_omp_ctx;
 extern void omp_firstprivatize_variable (struct gimplify_omp_ctx *, tree);
 /* 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);
+gcc_gimple_checking_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE);
 return gss_for_code_[code];
 }
 /* Return which GSS code is used by GS.  */
 /* Set DEF to be the set of DEF operands for statement G.  */
 static inline void
 gimple_set_def_ops (gimple g, struct def_optype_d *def)
 {
-gcc_assert (gimple_has_ops (g));
+gcc_gimple_checking_assert (gimple_has_ops (g));
 g->gsops.opbase.def_ops = def;
 }
 /* Return the set of USE operands for statement G.  */
 /* Set USE to be the set of USE operands for statement G.  */
 static inline void
 gimple_set_use_ops (gimple g, struct use_optype_d *use)
 {
-gcc_assert (gimple_has_ops (g));
+gcc_gimple_checking_assert (gimple_has_ops (g));
 g->gsops.opbase.use_ops = use;
 }
 /* Return the set of VUSE operand for statement G.  */
 /* Set the single VUSE operand of the statement G.  */
 static inline void
 gimple_set_vuse (gimple g, tree vuse)
 {
-gcc_assert (gimple_has_mem_ops (g));
+gcc_gimple_checking_assert (gimple_has_mem_ops (g));
 g->gsmembase.vuse = vuse;
 }
 /* Set the single VDEF operand of the statement G.  */
 static inline void
 gimple_set_vdef (gimple g, tree vdef)
 {
-gcc_assert (gimple_has_mem_ops (g));
+gcc_gimple_checking_assert (gimple_has_mem_ops (g));
 g->gsmembase.vdef = vdef;
 }
 /* Return true if statement G has operands and the modified field has
 gimple_expr_code (const_gimple stmt)
 {
 enum gimple_code code = gimple_code (stmt);
 if (code == GIMPLE_ASSIGN || code == GIMPLE_COND)
 return (enum tree_code) stmt->gsbase.subcode;
-else if (code == GIMPLE_CALL)
-return CALL_EXPR;
 else
-gcc_unreachable ();
+{
+gcc_gimple_checking_assert (code == GIMPLE_CALL);
+return CALL_EXPR;
+}
 }
 /* Mark statement S as modified, and update it.  */
 /* Return the subcode for OMP statement S.  */
 static inline unsigned
 gimple_omp_subcode (const_gimple s)
 {
-gcc_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
+gcc_gimple_checking_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
 	      && gimple_code (s) <= GIMPLE_OMP_SINGLE);
 return s->gsbase.subcode;
 }
 /* Set the subcode for OMP statement S to SUBCODE.  */
 static inline void
 gimple_omp_set_subcode (gimple s, unsigned int subcode)
 {
 /* We only have 16 bits for the subcode.  Assert that we are not
 overflowing it.  */
-gcc_assert (subcode < (1 << 16));
+gcc_gimple_checking_assert (subcode < (1 << 16));
 s->gsbase.subcode = subcode;
 }
 /* Set the nowait flag on OMP_RETURN statement S.  */
 /* All the tuples have their operand vector at the very bottom
 of the structure.  Note that those structures that do not
 have an operand vector have a zero offset.  */
 off = gimple_ops_offset_[gimple_statement_structure (gs)];
-gcc_assert (off != 0);
+gcc_gimple_checking_assert (off != 0);
 return (tree *) ((char *) gs + off);
 }
 static inline tree
 gimple_op (const_gimple gs, unsigned i)
 {
 if (gimple_has_ops (gs))
 {
-gcc_assert (i < gimple_num_ops (gs));
+gcc_gimple_checking_assert (i < gimple_num_ops (gs));
 return gimple_ops (CONST_CAST_GIMPLE (gs))[i];
 }
 else
 return NULL_TREE;
 }
 static inline tree *
 gimple_op_ptr (const_gimple gs, unsigned i)
 {
 if (gimple_has_ops (gs))
 {
-gcc_assert (i < gimple_num_ops (gs));
+gcc_gimple_checking_assert (i < gimple_num_ops (gs));
 return gimple_ops (CONST_CAST_GIMPLE (gs)) + i;
 }
 else
 return NULL;
 }
 /* Set operand I of statement GS to OP.  */
 static inline void
 gimple_set_op (gimple gs, unsigned i, tree op)
 {
-gcc_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
+gcc_gimple_checking_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
 /* Note.  It may be tempting to assert that OP matches
 is_gimple_operand, but that would be wrong.  Different tuples
 accept slightly different sets of tree operands.  Each caller
 should perform its own validation.  */
 static inline void
 gimple_assign_set_lhs (gimple gs, tree lhs)
 {
 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-gcc_assert (is_gimple_operand (lhs));
 gimple_set_op (gs, 0, lhs);
 if (lhs && TREE_CODE (lhs) == SSA_NAME)
 SSA_NAME_DEF_STMT (lhs) = gs;
 }
 static inline void
 gimple_assign_set_rhs1 (gimple gs, tree rhs)
 {
 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-/* If there are 3 or more operands, the 2 operands on the RHS must be
-GIMPLE values.  */
-if (gimple_num_ops (gs) >= 3)
-gcc_assert (is_gimple_val (rhs));
-else
-gcc_assert (is_gimple_operand (rhs));
 gimple_set_op (gs, 1, rhs);
 }
 static inline void
 gimple_assign_set_rhs2 (gimple gs, tree rhs)
 {
 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-/* The 2 operands on the RHS must be GIMPLE values.  */
-gcc_assert (is_gimple_val (rhs));
 gimple_set_op (gs, 2, rhs);
+}
+/* Return the third operand on the RHS of assignment statement GS.
+If GS does not have two operands, NULL is returned instead.  */
+static inline tree
+gimple_assign_rhs3 (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+if (gimple_num_ops (gs) >= 4)
+return gimple_op (gs, 3);
+else
+return NULL_TREE;
+}
+/* Return a pointer to the third operand on the RHS of assignment
+statement GS.  */
+static inline tree *
+gimple_assign_rhs3_ptr (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+return gimple_op_ptr (gs, 3);
+}
+/* Set RHS to be the third operand on the RHS of assignment statement GS.  */
+static inline void
+gimple_assign_set_rhs3 (gimple gs, tree rhs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+gimple_set_op (gs, 3, rhs);
+}
+/* A wrapper around gimple_assign_set_rhs_with_ops_1, for callers which expect
+to see only a maximum of two operands.  */
+static inline void
+gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
+				tree op1, tree op2)
+{
+gimple_assign_set_rhs_with_ops_1 (gsi, code, op1, op2, NULL);
+}
+/* A wrapper around extract_ops_from_tree_1, for callers which expect
+to see only a maximum of two operands.  */
+static inline void
+extract_ops_from_tree (tree expr, enum tree_code *code, tree *op0,
+		       tree *op1)
+{
+tree op2;
+extract_ops_from_tree_1 (expr, code, op0, op1, &op2);
+gcc_assert (op2 == NULL_TREE);
 }
 /* Returns true if GS is a nontemporal move.  */
 static inline bool
 gimple_assign_rhs_code (const_gimple gs)
 {
 enum tree_code code;
 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-code = gimple_expr_code (gs);
+code = (enum tree_code) gs->gsbase.subcode;
+/* While we initially set subcode to the TREE_CODE of the rhs for
+GIMPLE_SINGLE_RHS assigns we do not update that subcode to stay
+in sync when we rewrite stmts into SSA form or do SSA propagations.  */
 if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS)
 code = TREE_CODE (gimple_assign_rhs1 (gs));
 return code;
 }
 static inline enum gimple_rhs_class
 gimple_assign_rhs_class (const_gimple gs)
 {
 return get_gimple_rhs_class (gimple_assign_rhs_code (gs));
+}
+/* Return true if GS is an assignment with a singleton RHS, i.e.,
+there is no operator associated with the assignment itself.
+Unlike gimple_assign_copy_p, this predicate returns true for
+any RHS operand, including those that perform an operation
+and do not have the semantics of a copy, such as COND_EXPR.  */
+static inline bool
+gimple_assign_single_p (gimple gs)
+{
+return (is_gimple_assign (gs)
+&& gimple_assign_rhs_class (gs) == GIMPLE_SINGLE_RHS);
 }
 /* Return true if S is a type-cast assignment.  */
 static inline void
 gimple_call_set_lhs (gimple gs, tree lhs)
 {
 GIMPLE_CHECK (gs, GIMPLE_CALL);
-gcc_assert (!lhs || is_gimple_operand (lhs));
 gimple_set_op (gs, 0, lhs);
 if (lhs && TREE_CODE (lhs) == SSA_NAME)
 SSA_NAME_DEF_STMT (lhs) = gs;
 }
 static inline void
 gimple_call_set_fn (gimple gs, tree fn)
 {
 GIMPLE_CHECK (gs, GIMPLE_CALL);
-gcc_assert (is_gimple_operand (fn));
 gimple_set_op (gs, 1, fn);
 }
 /* Set FNDECL to be the function called by call 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_loc (gimple_location (gs), decl));
 }
 /* If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it.
 gimple_call_fndecl (const_gimple gs)
 {
 tree addr = gimple_call_fn (gs);
 if (TREE_CODE (addr) == ADDR_EXPR)
 {
-gcc_assert (TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL);
+tree fndecl = TREE_OPERAND (addr, 0);
+if (TREE_CODE (fndecl) == MEM_REF)
+	{
+	  if (TREE_CODE (TREE_OPERAND (fndecl, 0)) == ADDR_EXPR
+	      && integer_zerop (TREE_OPERAND (fndecl, 1)))
+	    return TREE_OPERAND (TREE_OPERAND (fndecl, 0), 0);
+	  else
+	    return NULL_TREE;
+	}
 return TREE_OPERAND (addr, 0);
 }
 return NULL_TREE;
 }
 {
 tree fn = gimple_call_fn (gs);
 tree type = TREE_TYPE (fn);
 /* See through the pointer.  */
-gcc_assert (POINTER_TYPE_P (type));
 type = TREE_TYPE (type);
-gcc_assert (TREE_CODE (type) == FUNCTION_TYPE
-	      || TREE_CODE (type) == METHOD_TYPE);
 /* The type returned by a FUNCTION_DECL is the type of its
 function type.  */
 return TREE_TYPE (type);
 }
 static inline void
 gimple_call_set_chain (gimple gs, tree chain)
 {
 GIMPLE_CHECK (gs, GIMPLE_CALL);
-gcc_assert (chain == NULL
-|| TREE_CODE (chain) == ADDR_EXPR
-|| SSA_VAR_P (chain));
 gimple_set_op (gs, 2, chain);
 }
 /* Return the number of arguments used by call statement GS.  */
 gimple_call_num_args (const_gimple gs)
 {
 unsigned num_ops;
 GIMPLE_CHECK (gs, GIMPLE_CALL);
 num_ops = gimple_num_ops (gs);
-gcc_assert (num_ops >= 3);
 return num_ops - 3;
 }
 /* Return the argument at position INDEX for call statement GS.  */
 static inline void
 gimple_call_set_arg (gimple gs, unsigned index, tree arg)
 {
 GIMPLE_CHECK (gs, GIMPLE_CALL);
-gcc_assert (is_gimple_operand (arg));
 gimple_set_op (gs, index + 3, arg);
 }
 /* If TAIL_P is true, mark call statement S as being a tail call
 GIMPLE_CHECK (s, GIMPLE_CALL);
 return (gimple_call_flags (s) & ECF_NORETURN) != 0;
 }
+/* If NOTHROW_P is true, GIMPLE_CALL S is a call that is known to not throw
+even if the called function can throw in other cases.  */
+static inline void
+gimple_call_set_nothrow (gimple s, bool nothrow_p)
+{
+GIMPLE_CHECK (s, GIMPLE_CALL);
+if (nothrow_p)
+s->gsbase.subcode |= GF_CALL_NOTHROW;
+else
+s->gsbase.subcode &= ~GF_CALL_NOTHROW;
+}
 /* Return true if S is a nothrow call.  */
 static inline bool
 gimple_call_nothrow_p (gimple s)
 {
 GIMPLE_CHECK (orig_call, GIMPLE_CALL);
 dest_call->gsbase.subcode = orig_call->gsbase.subcode;
 }
+/* Return a pointer to the points-to solution for the set of call-used
+variables of the call CALL.  */
+static inline struct pt_solution *
+gimple_call_use_set (gimple call)
+{
+GIMPLE_CHECK (call, GIMPLE_CALL);
+return &call->gimple_call.call_used;
+}
+/* Return a pointer to the points-to solution for the set of call-used
+variables of the call CALL.  */
+static inline struct pt_solution *
+gimple_call_clobber_set (gimple call)
+{
+GIMPLE_CHECK (call, GIMPLE_CALL);
+return &call->gimple_call.call_clobbered;
+}
 /* Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a
 non-NULL lhs.  */
 static inline bool
 gimple_has_lhs (gimple stmt)
 static inline void
 gimple_cond_set_code (gimple gs, enum tree_code code)
 {
 GIMPLE_CHECK (gs, GIMPLE_COND);
-gcc_assert (TREE_CODE_CLASS (code) == tcc_comparison);
 gs->gsbase.subcode = code;
 }
 /* Return the LHS of the predicate computed by conditional statement GS.  */
 static inline void
 gimple_cond_set_lhs (gimple gs, tree lhs)
 {
 GIMPLE_CHECK (gs, GIMPLE_COND);
-gcc_assert (is_gimple_operand (lhs));
 gimple_set_op (gs, 0, lhs);
 }
 /* Return the RHS operand of the predicate computed by conditional GS.  */
 static inline void
 gimple_cond_set_rhs (gimple gs, tree rhs)
 {
 GIMPLE_CHECK (gs, GIMPLE_COND);
-gcc_assert (is_gimple_operand (rhs));
 gimple_set_op (gs, 1, rhs);
 }
 /* Return the label used by conditional statement GS when its
 static inline void
 gimple_cond_set_true_label (gimple gs, tree label)
 {
 GIMPLE_CHECK (gs, GIMPLE_COND);
-gcc_assert (!label || TREE_CODE (label) == LABEL_DECL);
 gimple_set_op (gs, 2, label);
 }
 /* Set LABEL to be the label used by conditional statement GS when its
 static inline void
 gimple_cond_set_false_label (gimple gs, tree label)
 {
 GIMPLE_CHECK (gs, GIMPLE_COND);
-gcc_assert (!label || TREE_CODE (label) == LABEL_DECL);
 gimple_set_op (gs, 3, label);
 }
 /* Return the label used by conditional statement GS when its
 static inline void
 gimple_label_set_label (gimple gs, tree label)
 {
 GIMPLE_CHECK (gs, GIMPLE_LABEL);
-gcc_assert (TREE_CODE (label) == LABEL_DECL);
 gimple_set_op (gs, 0, label);
 }
 /* Return the destination of the unconditional 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);
 }
 /* Return the variables declared in the GIMPLE_BIND statement GS.  */
 static inline void
 gimple_bind_set_block (gimple gs, tree block)
 {
 GIMPLE_CHECK (gs, GIMPLE_BIND);
-gcc_assert (block == NULL_TREE || TREE_CODE (block) == BLOCK);
+gcc_gimple_checking_assert (block == NULL_TREE
+			      || TREE_CODE (block) == BLOCK);
 gs->gimple_bind.block = block;
 }
 /* Return the number of input operands for GIMPLE_ASM GS.  */
 static inline tree
 gimple_asm_input_op (const_gimple gs, unsigned index)
 {
 GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.ni);
+gcc_gimple_checking_assert (index <= gs->gimple_asm.ni);
 return gimple_op (gs, index);
 }
 /* Return a pointer to input operand INDEX of GIMPLE_ASM GS.  */
 static inline tree *
 gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
 {
 GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.ni);
+gcc_gimple_checking_assert (index <= gs->gimple_asm.ni);
 return gimple_op_ptr (gs, index);
 }
 /* Set IN_OP to be input operand INDEX in GIMPLE_ASM GS.  */
 static inline void
 gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
 {
 GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.ni);
+gcc_gimple_checking_assert (index <= gs->gimple_asm.ni
-gcc_assert (TREE_CODE (in_op) == TREE_LIST);
+			      && TREE_CODE (in_op) == TREE_LIST);
 gimple_set_op (gs, index, in_op);
 }
 /* Return output operand INDEX of GIMPLE_ASM GS.  */
 static inline tree
 gimple_asm_output_op (const_gimple gs, unsigned index)
 {
 GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.no);
+gcc_gimple_checking_assert (index <= gs->gimple_asm.no);
 return gimple_op (gs, index + gs->gimple_asm.ni);
 }
 /* Return a pointer to output operand INDEX of GIMPLE_ASM GS.  */
 static inline tree *
 gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
 {
 GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.no);
+gcc_gimple_checking_assert (index <= gs->gimple_asm.no);
 return gimple_op_ptr (gs, index + gs->gimple_asm.ni);
 }
 /* Set OUT_OP to be output operand INDEX in GIMPLE_ASM GS.  */
 static inline void
 gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
 {
 GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.no);
+gcc_gimple_checking_assert (index <= gs->gimple_asm.no
-gcc_assert (TREE_CODE (out_op) == TREE_LIST);
+			      && TREE_CODE (out_op) == TREE_LIST);
 gimple_set_op (gs, index + gs->gimple_asm.ni, out_op);
 }
 /* Return clobber operand INDEX of GIMPLE_ASM GS.  */
 static inline tree
 gimple_asm_clobber_op (const_gimple gs, unsigned index)
 {
 GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.nc);
+gcc_gimple_checking_assert (index <= gs->gimple_asm.nc);
 return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no);
 }
 /* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM GS.  */
 static inline void
 gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
 {
 GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.nc);
+gcc_gimple_checking_assert (index <= gs->gimple_asm.nc
-gcc_assert (TREE_CODE (clobber_op) == TREE_LIST);
+			      && 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);
+gcc_gimple_checking_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_gimple_checking_assert (index <= gs->gimple_asm.nl
-gcc_assert (TREE_CODE (label_op) == TREE_LIST);
+			      && 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 void
 gimple_try_set_kind (gimple gs, enum gimple_try_flags kind)
 {
 GIMPLE_CHECK (gs, GIMPLE_TRY);
-gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
+gcc_gimple_checking_assert (kind == GIMPLE_TRY_CATCH
+			      || kind == GIMPLE_TRY_FINALLY);
 if (gimple_try_kind (gs) != kind)
 gs->gsbase.subcode = (unsigned int) kind;
 }
 /* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag.  */
 static inline bool
 gimple_try_catch_is_cleanup (const_gimple gs)
 {
-gcc_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
+gcc_gimple_checking_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
 return (gs->gsbase.subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
 }
 /* Return the sequence of statements used as the body for GIMPLE_TRY GS.  */
 /* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag.  */
 static inline void
 gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
 {
-gcc_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
+gcc_gimple_checking_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
 if (catch_is_cleanup)
 g->gsbase.subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP;
 else
 g->gsbase.subcode &= ~GIMPLE_TRY_CATCH_IS_CLEANUP;
 }
 static inline struct phi_arg_d *
 gimple_phi_arg (gimple gs, unsigned index)
 {
 GIMPLE_CHECK (gs, GIMPLE_PHI);
-gcc_assert (index <= gs->gimple_phi.capacity);
+gcc_gimple_checking_assert (index <= gs->gimple_phi.capacity);
 return &(gs->gimple_phi.args[index]);
 }
 /* Set PHIARG to be the argument corresponding to incoming edge INDEX
 for GIMPLE_PHI GS.  */
 static inline void
 gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg)
 {
 GIMPLE_CHECK (gs, GIMPLE_PHI);
-gcc_assert (index <= gs->gimple_phi.nargs);
+gcc_gimple_checking_assert (index <= gs->gimple_phi.nargs);
-memcpy (gs->gimple_phi.args + index, phiarg, sizeof (struct phi_arg_d));
+gs->gimple_phi.args[index] = *phiarg;
 }
 /* Return the region number for GIMPLE_RESX GS.  */
 static inline int
 gimple_switch_num_labels (const_gimple gs)
 {
 unsigned num_ops;
 GIMPLE_CHECK (gs, GIMPLE_SWITCH);
 num_ops = gimple_num_ops (gs);
-gcc_assert (num_ops > 1);
+gcc_gimple_checking_assert (num_ops > 1);
 return num_ops - 1;
 }
 /* Set NLABELS to be the number of labels for the switch statement GS.  */
 static inline void
 gimple_switch_set_index (gimple gs, tree index)
 {
 GIMPLE_CHECK (gs, GIMPLE_SWITCH);
-gcc_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
+gcc_gimple_checking_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
 gimple_set_op (gs, 0, index);
 }
 /* Return the label numbered INDEX.  The default label is 0, followed by any
 static inline tree
 gimple_switch_label (const_gimple gs, unsigned index)
 {
 GIMPLE_CHECK (gs, GIMPLE_SWITCH);
-gcc_assert (gimple_num_ops (gs) > index + 1);
+gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1);
 return gimple_op (gs, index + 1);
 }
 /* Set the label number INDEX to LABEL.  0 is always the default label.  */
 static inline void
 gimple_switch_set_label (gimple gs, unsigned index, tree label)
 {
 GIMPLE_CHECK (gs, GIMPLE_SWITCH);
-gcc_assert (gimple_num_ops (gs) > index + 1);
+gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1
-gcc_assert (label == NULL_TREE || TREE_CODE (label) == CASE_LABEL_EXPR);
+			      && (label == NULL_TREE
+			          || TREE_CODE (label) == CASE_LABEL_EXPR));
 gimple_set_op (gs, index + 1, label);
 }
 /* Return the default label for a switch statement.  */
 static inline tree
 gimple_debug_bind_get_var (gimple dbg)
 {
 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
-gcc_assert (gimple_debug_bind_p (dbg));
+gcc_gimple_checking_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));
+gcc_gimple_checking_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));
+gcc_gimple_checking_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));
+gcc_gimple_checking_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));
+gcc_gimple_checking_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.  */
 static inline void
 gimple_debug_bind_reset_value (gimple dbg)
 {
 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
-gcc_assert (gimple_debug_bind_p (dbg));
+gcc_gimple_checking_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));
+gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
 return gimple_op (dbg, 1) != GIMPLE_DEBUG_BIND_NOVALUE;
 }
 #undef GIMPLE_DEBUG_BIND_NOVALUE
 static inline tree
 gimple_omp_for_index (const_gimple gs, size_t i)
 {
 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
+gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
 return gs->gimple_omp_for.iter[i].index;
 }
 /* Return a pointer to the index variable for OMP_FOR GS.  */
 static inline tree *
 gimple_omp_for_index_ptr (gimple gs, size_t i)
 {
 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
+gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
 return &gs->gimple_omp_for.iter[i].index;
 }
 /* Set INDEX to be the index variable for OMP_FOR GS.  */
 static inline void
 gimple_omp_for_set_index (gimple gs, size_t i, tree index)
 {
 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
+gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
 gs->gimple_omp_for.iter[i].index = index;
 }
 /* Return the initial value for OMP_FOR GS.  */
 static inline tree
 gimple_omp_for_initial (const_gimple gs, size_t i)
 {
 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
+gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
 return gs->gimple_omp_for.iter[i].initial;
 }
 /* Return a pointer to the initial value for OMP_FOR GS.  */
 static inline tree *
 gimple_omp_for_initial_ptr (gimple gs, size_t i)
 {
 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
+gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
 return &gs->gimple_omp_for.iter[i].initial;
 }
 /* Set INITIAL to be the initial value for OMP_FOR GS.  */
 static inline void
 gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
 {
 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
+gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
 gs->gimple_omp_for.iter[i].initial = initial;
 }
 /* Return the final value for OMP_FOR GS.  */
 static inline tree
 gimple_omp_for_final (const_gimple gs, size_t i)
 {
 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
+gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
 return gs->gimple_omp_for.iter[i].final;
 }
 /* Return a pointer to the final value for OMP_FOR GS.  */
 static inline tree *
 gimple_omp_for_final_ptr (gimple gs, size_t i)
 {
 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
+gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
 return &gs->gimple_omp_for.iter[i].final;
 }
 /* Set FINAL to be the final value for OMP_FOR GS.  */
 static inline void
 gimple_omp_for_set_final (gimple gs, size_t i, tree final)
 {
 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
+gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
 gs->gimple_omp_for.iter[i].final = final;
 }
 /* Return the increment value for OMP_FOR GS.  */
 static inline tree
 gimple_omp_for_incr (const_gimple gs, size_t i)
 {
 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
+gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
 return gs->gimple_omp_for.iter[i].incr;
 }
 /* Return a pointer to the increment value for OMP_FOR GS.  */
 static inline tree *
 gimple_omp_for_incr_ptr (gimple gs, size_t i)
 {
 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
+gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
 return &gs->gimple_omp_for.iter[i].incr;
 }
 /* Set INCR to be the increment value for OMP_FOR GS.  */
 static inline void
 gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
 {
 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
+gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
 gs->gimple_omp_for.iter[i].incr = incr;
 }
 /* Return the sequence of statements to execute before the OMP_FOR
 static inline void
 gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
 {
 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (TREE_CODE_CLASS (cond) == tcc_comparison);
+gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison
-gcc_assert (i < gs->gimple_omp_for.collapse);
+			      && i < gs->gimple_omp_for.collapse);
 gs->gimple_omp_for.iter[i].cond = cond;
 }
 /* Return the condition code associated with OMP_FOR GS.  */
 static inline enum tree_code
 gimple_omp_for_cond (const_gimple gs, size_t i)
 {
 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
+gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse);
 return gs->gimple_omp_for.iter[i].cond;
 }
 /* Set the value being stored in an atomic store.  */
 static inline tree *
 gimple_return_retval_ptr (const_gimple gs)
 {
 GIMPLE_CHECK (gs, GIMPLE_RETURN);
-gcc_assert (gimple_num_ops (gs) == 1);
 return gimple_op_ptr (gs, 0);
 }
 /* Return the return value for GIMPLE_RETURN GS.  */
 static inline tree
 gimple_return_retval (const_gimple gs)
 {
 GIMPLE_CHECK (gs, GIMPLE_RETURN);
-gcc_assert (gimple_num_ops (gs) == 1);
 return gimple_op (gs, 0);
 }
 /* Set RETVAL to be the return value for GIMPLE_RETURN GS.  */
 static inline void
 gimple_return_set_retval (gimple gs, tree retval)
 {
 GIMPLE_CHECK (gs, GIMPLE_RETURN);
-gcc_assert (gimple_num_ops (gs) == 1);
-gcc_assert (retval == NULL_TREE
-|| TREE_CODE (retval) == RESULT_DECL
-	      || is_gimple_val (retval));
 gimple_set_op (gs, 0, retval);
 }
 /* Returns true when the gimple statment STMT is any of the OpenMP types.  */
 }
 #endif /* GATHER_STATISTICS */
 extern void dump_gimple_statistics (void);
+/* In gimple-fold.c.  */
+void gimplify_and_update_call_from_tree (gimple_stmt_iterator *, tree);
+tree gimple_fold_builtin (gimple);
+bool fold_stmt (gimple_stmt_iterator *);
+bool fold_stmt_inplace (gimple);
+tree maybe_fold_offset_to_address (location_t, tree, tree, tree);
+tree maybe_fold_offset_to_reference (location_t, tree, tree, tree);
+tree maybe_fold_stmt_addition (location_t, tree, tree, tree);
+tree get_symbol_constant_value (tree);
+tree canonicalize_constructor_val (tree);
+bool may_propagate_address_into_dereference (tree, tree);
+extern tree maybe_fold_and_comparisons (enum tree_code, tree, tree,
+					enum tree_code, tree, tree);
+extern tree maybe_fold_or_comparisons (enum tree_code, tree, tree,
+				       enum tree_code, tree, tree);
 #endif  /* GCC_GIMPLE_H */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/gimple.h @ 69:1b10fe6932e1