./:

	* rtl.h (LABEL_REF_NONLOCAL_P): Don't check for REG_LABEL_OPERAND
	or REG_LABEL_TARGET.
	* calls.c (emit_library_call_value_1): Use MEM_P rather than
	comparing MODE with MEM.
	* gimple.c (gimple_build_predict): Cast END_PREDICTORS before
	comparing with GF_PREDICT_TAKEN.
	(gimple_get_lhs): Change code to enum gimple_code.
	(gimple_set_lhs): Likewise.
	* ifcvt.c (noce_process_if_block): Correct GET_MODE to GET_CODE.
	* omp-low.c (find_omp_clause): Change kind parameter to enum
	omp_clause_code.
	* tree-flow.h (find_omp_clause): Update declaration.
	* regrename.c (clear_dead_regs): Change kind parameter to enum
	reg_note.
	* reload1.c (eliminate_regs_1): Use REG_NOTE_KIND rather than
	GET_MODE.
	* see.c (see_get_extension_data): Change return type to enum
	entry_type.  Change UNKNOWN to NOT_RELEVANT, SIGN_EXTEND to
	SIGNED_EXTENDED_DEF, ZERO_EXTEND to ZERO_EXTENDED_DEF.
	(see_gen_normalized_extension): Change extension_code parameter to
	enum entry_type.
	(see_seek_pre_extension_expr): Change extension_code to enum
	entry_type.
	(see_merge_one_def_extension): Likewise.
	(see_handle_relevant_defs): Likewise.
	(see_handle_relevant_uses): Likewise.
	(see_analyze_one_def): Likewise.
	* tree-cfg.c (need_fake_edge_p): Compare gimple code with
	GIMPLE_ASM rather than ASM_EXPR.
	* tree-ssa-alias.c (is_escape_site): Compare gimple code with
	GIMPLE_RETURN rather than RETURN_EXPR.
	* tree-ssa-ccp.c (likely_value): Change code to enum gimple_code.
	(evaluate_stmt): Likewise.
	* tree-vect-analyze.c (vect_analyze_operations): Change relevance
	to enum vect_relevant.
	(vect_mark_stmts_to_be_vectorized): Change assertion to not
	compare gimple codes with tree codes.
cp/:
	* parser.c (check_no_duplicate_clause): Change code parameter to
	enum omp_clause_code.
fortran/:
	* symbol.c (generate_isocbinding_symbol): Compare
	gfc_notification_std with ERROR rather than FAILURE.
	* resolve.c (check_assumed_size_reference): Compare array type
	with AR_FULL rather than DIMEN_ELEMENT.
	(resolve_actual_arglist): Compare with EXPR_VARIABLE rather than
	FL_VARIABLE.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@139991 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 79f38b7..375a50a 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,43 @@
+2008-09-04  Ian Lance Taylor  <iant@google.com>
+
+       * rtl.h (LABEL_REF_NONLOCAL_P): Don't check for REG_LABEL_OPERAND
+       or REG_LABEL_TARGET.
+       * calls.c (emit_library_call_value_1): Use MEM_P rather than
+       comparing MODE with MEM.
+       * gimple.c (gimple_build_predict): Cast END_PREDICTORS before
+       comparing with GF_PREDICT_TAKEN.
+       (gimple_get_lhs): Change code to enum gimple_code.
+       (gimple_set_lhs): Likewise.
+       * ifcvt.c (noce_process_if_block): Correct GET_MODE to GET_CODE.
+       * omp-low.c (find_omp_clause): Change kind parameter to enum
+       omp_clause_code.
+       * tree-flow.h (find_omp_clause): Update declaration.
+       * regrename.c (clear_dead_regs): Change kind parameter to enum
+       reg_note.
+       * reload1.c (eliminate_regs_1): Use REG_NOTE_KIND rather than
+       GET_MODE.
+       * see.c (see_get_extension_data): Change return type to enum
+       entry_type.  Change UNKNOWN to NOT_RELEVANT, SIGN_EXTEND to
+       SIGNED_EXTENDED_DEF, ZERO_EXTEND to ZERO_EXTENDED_DEF.
+       (see_gen_normalized_extension): Change extension_code parameter to
+       enum entry_type.
+       (see_seek_pre_extension_expr): Change extension_code to enum
+       entry_type.
+       (see_merge_one_def_extension): Likewise.
+       (see_handle_relevant_defs): Likewise.
+       (see_handle_relevant_uses): Likewise.
+       (see_analyze_one_def): Likewise.
+       * tree-cfg.c (need_fake_edge_p): Compare gimple code with
+       GIMPLE_ASM rather than ASM_EXPR.
+       * tree-ssa-alias.c (is_escape_site): Compare gimple code with
+       GIMPLE_RETURN rather than RETURN_EXPR.
+       * tree-ssa-ccp.c (likely_value): Change code to enum gimple_code.
+       (evaluate_stmt): Likewise.
+       * tree-vect-analyze.c (vect_analyze_operations): Change relevance
+       to enum vect_relevant.
+       (vect_mark_stmts_to_be_vectorized): Change assertion to not
+       compare gimple codes with tree codes.
+
 2008-09-04  Paul Brook  <paul@codesourcery.com>
 
        * config/arm/arm.c (arm_size_rtx_costs): Call cost function.

diff --git a/gcc/calls.c b/gcc/calls.c
index 96d05ea..a3d35b3 100644 (file)
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -3423,7 +3423,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
              flags |= ECF_PURE;
            }
 
-         if (GET_MODE (val) == MEM && !must_copy)
+         if (MEM_P (val) && !must_copy)
            slot = val;
          else
            {

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 4166bd1..f7ee7dd 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,8 @@
+2008-09-04  Ian Lance Taylor  <iant@google.com>
+
+       * parser.c (check_no_duplicate_clause): Change code parameter to
+       enum omp_clause_code.
+
 2008-09-03  Jakub Jelinek  <jakub@redhat.com>
 
        PR c++/37348

diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 32907b2..3f6e370 100644 (file)
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -20039,7 +20039,7 @@ cp_parser_omp_clause_name (cp_parser *parser)
 /* Validate that a clause of the given type does not already exist.  */
 
 static void
-check_no_duplicate_clause (tree clauses, enum tree_code code,
+check_no_duplicate_clause (tree clauses, enum omp_clause_code code,
                           const char *name, location_t location)
 {
   tree c;

diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog
index 213af61..57ed95f 100644 (file)
--- a/gcc/fortran/ChangeLog
+++ b/gcc/fortran/ChangeLog
@@ -1,3 +1,12 @@
+2008-09-04  Ian Lance Taylor  <iant@google.com>
+
+       * symbol.c (generate_isocbinding_symbol): Compare
+       gfc_notification_std with ERROR rather than FAILURE.
+       * resolve.c (check_assumed_size_reference): Compare array type
+       with AR_FULL rather than DIMEN_ELEMENT.
+       (resolve_actual_arglist): Compare with EXPR_VARIABLE rather than
+       FL_VARIABLE.
+
 2008-09-01  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
 
        PR fortran/37228

diff --git a/gcc/fortran/resolve.c b/gcc/fortran/resolve.c
index 61053c3..8c41ce4 100644 (file)
--- a/gcc/fortran/resolve.c
+++ b/gcc/fortran/resolve.c
@@ -994,9 +994,11 @@ check_assumed_size_reference (gfc_symbol *sym, gfc_expr *e)
   if (need_full_assumed_size || !(sym->as && sym->as->type == AS_ASSUMED_SIZE))
       return false;
 
+  /* FIXME: The comparison "e->ref->u.ar.type == AR_FULL" is wrong.
+     What should it be?  */
   if ((e->ref->u.ar.end[e->ref->u.ar.as->rank - 1] == NULL)
          && (e->ref->u.ar.as->type == AS_ASSUMED_SIZE)
-              && (e->ref->u.ar.type == DIMEN_ELEMENT))
+              && (e->ref->u.ar.type == AR_FULL))
     {
       gfc_error ("The upper bound in the last dimension must "
                 "appear in the reference to the assumed size "
@@ -1070,7 +1072,7 @@ resolve_actual_arglist (gfc_actual_arglist *arg, procedure_type ptype)
          continue;
        }
 
-      if (e->expr_type == FL_VARIABLE && e->symtree->ambiguous)
+      if (e->expr_type == EXPR_VARIABLE && e->symtree->ambiguous)
        {
          gfc_error ("'%s' at %L is ambiguous", e->symtree->n.sym->name,
                     &e->where);
@@ -1080,7 +1082,7 @@ resolve_actual_arglist (gfc_actual_arglist *arg, procedure_type ptype)
       if (e->ts.type != BT_PROCEDURE)
        {
          save_need_full_assumed_size = need_full_assumed_size;
-         if (e->expr_type != FL_VARIABLE)
+         if (e->expr_type != EXPR_VARIABLE)
            need_full_assumed_size = 0;
          if (gfc_resolve_expr (e) != SUCCESS)
            return FAILURE;
@@ -1224,7 +1226,7 @@ resolve_actual_arglist (gfc_actual_arglist *arg, procedure_type ptype)
         is a  variable instead, it needs to be resolved as it was not
         done at the beginning of this function.  */
       save_need_full_assumed_size = need_full_assumed_size;
-      if (e->expr_type != FL_VARIABLE)
+      if (e->expr_type != EXPR_VARIABLE)
        need_full_assumed_size = 0;
       if (gfc_resolve_expr (e) != SUCCESS)
        return FAILURE;

diff --git a/gcc/fortran/symbol.c b/gcc/fortran/symbol.c
index 7c8b7bc..ee45f2a 100644 (file)
--- a/gcc/fortran/symbol.c
+++ b/gcc/fortran/symbol.c
@@ -3922,7 +3922,7 @@ generate_isocbinding_symbol (const char *mod_name, iso_c_binding_symbol s,
   char comp_name[(GFC_MAX_SYMBOL_LEN * 2) + 1];
   int index;
 
-  if (gfc_notification_std (std_for_isocbinding_symbol (s)) == FAILURE)
+  if (gfc_notification_std (std_for_isocbinding_symbol (s)) == ERROR)
     return;
   tmp_symtree = gfc_find_symtree (gfc_current_ns->sym_root, name);
 

diff --git a/gcc/gimple.c b/gcc/gimple.c
index 7419d85..9075b2e 100644 (file)
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -1085,7 +1085,7 @@ gimple_build_predict (enum br_predictor predictor, enum prediction outcome)
 {
   gimple p = gimple_alloc (GIMPLE_PREDICT, 0);
   /* Ensure all the predictors fit into the lower bits of the subcode.  */
-  gcc_assert (END_PREDICTORS <= GF_PREDICT_TAKEN);
+  gcc_assert ((int) END_PREDICTORS <= GF_PREDICT_TAKEN);
   gimple_predict_set_predictor (p, predictor);
   gimple_predict_set_outcome (p, outcome);
   return p;
@@ -2066,7 +2066,7 @@ gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
 tree
 gimple_get_lhs (const_gimple stmt)
 {
-  enum tree_code code = gimple_code (stmt);
+  enum gimple_code code = gimple_code (stmt);
 
   if (code == GIMPLE_ASSIGN)
     return gimple_assign_lhs (stmt);
@@ -2083,7 +2083,7 @@ gimple_get_lhs (const_gimple stmt)
 void
 gimple_set_lhs (gimple stmt, tree lhs)
 {
-  enum tree_code code = gimple_code (stmt);
+  enum gimple_code code = gimple_code (stmt);
 
   if (code == GIMPLE_ASSIGN)
     gimple_assign_set_lhs (stmt, lhs);

diff --git a/gcc/ifcvt.c b/gcc/ifcvt.c
index 845fa21..aef71a7 100644 (file)
--- a/gcc/ifcvt.c
+++ b/gcc/ifcvt.c
@@ -2289,7 +2289,7 @@ noce_process_if_block (struct noce_if_info *if_info)
       if (GET_MODE (x) == BLKmode)
        return FALSE;
 
-      if (GET_MODE (x) == ZERO_EXTRACT
+      if (GET_CODE (x) == ZERO_EXTRACT
          && (GET_CODE (XEXP (x, 1)) != CONST_INT
              || GET_CODE (XEXP (x, 2)) != CONST_INT))
        return FALSE;

diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index d6c5500..7d32f21 100644 (file)
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -164,7 +164,7 @@ static tree maybe_lookup_decl_in_outer_ctx (tree, omp_context *);
 /* Find an OpenMP clause of type KIND within CLAUSES.  */
 
 tree
-find_omp_clause (tree clauses, enum tree_code kind)
+find_omp_clause (tree clauses, enum omp_clause_code kind)
 {
   for (; clauses ; clauses = OMP_CLAUSE_CHAIN (clauses))
     if (OMP_CLAUSE_CODE (clauses) == kind)

diff --git a/gcc/regrename.c b/gcc/regrename.c
index 0ed810e..bd2373c 100644 (file)
--- a/gcc/regrename.c
+++ b/gcc/regrename.c
@@ -89,7 +89,7 @@ static void scan_rtx (rtx, rtx *, enum reg_class, enum scan_actions,
 static struct du_chain *build_def_use (basic_block);
 static void dump_def_use_chain (struct du_chain *);
 static void note_sets (rtx, const_rtx, void *);
-static void clear_dead_regs (HARD_REG_SET *, enum machine_mode, rtx);
+static void clear_dead_regs (HARD_REG_SET *, enum reg_note, rtx);
 static void merge_overlapping_regs (basic_block, HARD_REG_SET *,
                                    struct du_chain *);
 
@@ -114,7 +114,7 @@ note_sets (rtx x, const_rtx set ATTRIBUTE_UNUSED, void *data)
    in the list NOTES.  */
 
 static void
-clear_dead_regs (HARD_REG_SET *pset, enum machine_mode kind, rtx notes)
+clear_dead_regs (HARD_REG_SET *pset, enum reg_note kind, rtx notes)
 {
   rtx note;
   for (note = notes; note; note = XEXP (note, 1))
@@ -1990,4 +1990,3 @@ struct rtl_opt_pass pass_cprop_hardreg =
   TODO_dump_func | TODO_verify_rtl_sharing /* todo_flags_finish */
  }
 };
-

diff --git a/gcc/reload1.c b/gcc/reload1.c
index f9d924c..1ea4109 100644 (file)
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -2709,7 +2709,7 @@ eliminate_regs_1 (rtx x, enum machine_mode mem_mode, rtx insn,
              /* If this is a REG_DEAD note, it is not valid anymore.
                 Using the eliminated version could result in creating a
                 REG_DEAD note for the stack or frame pointer.  */
-             if (GET_MODE (x) == REG_DEAD)
+             if (REG_NOTE_KIND (x) == REG_DEAD)
                return (XEXP (x, 1)
                        ? eliminate_regs_1 (XEXP (x, 1), mem_mode, insn, true)
                        : NULL_RTX);

diff --git a/gcc/rtl.h b/gcc/rtl.h
index 4b04d28..5d2e793 100644 (file)
--- a/gcc/rtl.h
+++ b/gcc/rtl.h
@@ -1246,8 +1246,7 @@ do {                                              \
 /* Likewise in an expr_list for a REG_LABEL_OPERAND or
    REG_LABEL_TARGET note.  */
 #define LABEL_REF_NONLOCAL_P(RTX)                                      \
-  (RTL_FLAG_CHECK3("LABEL_REF_NONLOCAL_P", (RTX), LABEL_REF,           \
-                  REG_LABEL_OPERAND, REG_LABEL_TARGET)->volatil)
+  (RTL_FLAG_CHECK1("LABEL_REF_NONLOCAL_P", (RTX), LABEL_REF)->volatil)
 
 /* 1 if RTX is a code_label that should always be considered to be needed.  */
 #define LABEL_PRESERVE_P(RTX)                                          \

diff --git a/gcc/see.c b/gcc/see.c
index a465d52..55b37bf 100644 (file)
--- a/gcc/see.c
+++ b/gcc/see.c
@@ -712,13 +712,13 @@ see_get_extension_reg (rtx extension, bool return_dest_reg)
     Otherwise, set SOURCE_MODE to be the mode of the extended expr and return
     the rtx code of the extension.  */
 
-static enum rtx_code
+static enum entry_type
 see_get_extension_data (rtx extension, enum machine_mode *source_mode)
 {
   rtx rhs, lhs, set;
 
   if (!extension || !INSN_P (extension))
-    return UNKNOWN;
+    return NOT_RELEVANT;
 
   /* Parallel pattern for extension not supported for the moment.  */
   if (GET_CODE (PATTERN (extension)) == PARALLEL)
@@ -733,21 +733,21 @@ see_get_extension_data (rtx extension, enum machine_mode *source_mode)
   /* Don't handle extensions to something other then register or
      subregister.  */
   if (!REG_P (lhs) && GET_CODE (lhs) != SUBREG)
-    return UNKNOWN;
+    return NOT_RELEVANT;
 
   if (GET_CODE (rhs) != SIGN_EXTEND && GET_CODE (rhs) != ZERO_EXTEND)
-    return UNKNOWN;
+    return NOT_RELEVANT;
 
   if (!REG_P (XEXP (rhs, 0))
       && !(GET_CODE (XEXP (rhs, 0)) == SUBREG
           && REG_P (SUBREG_REG (XEXP (rhs, 0)))))
-    return UNKNOWN;
+    return NOT_RELEVANT;
 
   *source_mode = GET_MODE (XEXP (rhs, 0));
 
   if (GET_CODE (rhs) == SIGN_EXTEND)
-    return SIGN_EXTEND;
-  return ZERO_EXTEND;
+    return SIGN_EXTENDED_DEF;
+  return ZERO_EXTENDED_DEF;
 }
 
 
@@ -760,7 +760,7 @@ see_get_extension_data (rtx extension, enum machine_mode *source_mode)
    Otherwise, return the generated instruction.  */
 
 static rtx
-see_gen_normalized_extension (rtx reg, enum rtx_code extension_code,
+see_gen_normalized_extension (rtx reg, enum entry_type extension_code,
                              enum machine_mode mode)
 {
   rtx subreg, insn;
@@ -768,11 +768,12 @@ see_gen_normalized_extension (rtx reg, enum rtx_code extension_code,
 
   if (!reg
       || !REG_P (reg)
-      || (extension_code != SIGN_EXTEND && extension_code != ZERO_EXTEND))
+      || (extension_code != SIGN_EXTENDED_DEF
+          && extension_code != ZERO_EXTENDED_DEF))
     return NULL;
 
   subreg = gen_lowpart_SUBREG (mode, reg);
-  if (extension_code == SIGN_EXTEND)
+  if (extension_code == SIGN_EXTENDED_DEF)
     extension = gen_rtx_SIGN_EXTEND (GET_MODE (reg), subreg);
   else
     extension = gen_rtx_ZERO_EXTEND (GET_MODE (reg), subreg);
@@ -1019,14 +1020,14 @@ see_seek_pre_extension_expr (rtx extension, enum extension_type type)
 {
   struct see_pre_extension_expr **slot_pre_exp, temp_pre_exp;
   rtx dest_extension_reg = see_get_extension_reg (extension, 1);
-  enum rtx_code extension_code;
+  enum entry_type extension_code;
   enum machine_mode source_extension_mode;
 
   if (type == DEF_EXTENSION)
     {
       extension_code = see_get_extension_data (extension,
                                               &source_extension_mode);
-      gcc_assert (extension_code != UNKNOWN);
+      gcc_assert (extension_code != NOT_RELEVANT);
       extension =
        see_gen_normalized_extension (dest_extension_reg, extension_code,
                                      source_extension_mode);
@@ -2807,7 +2808,7 @@ see_merge_one_def_extension (void **slot, void *b)
   rtx simplified_temp_extension = NULL;
   rtx *pat;
   enum rtx_code code;
-  enum rtx_code extension_code;
+  enum entry_type extension_code;
   enum machine_mode source_extension_mode;
   enum machine_mode source_mode = VOIDmode;
   enum machine_mode dest_extension_mode;
@@ -2866,7 +2867,7 @@ see_merge_one_def_extension (void **slot, void *b)
            {
              rtx orig_src = SET_SRC (*sub);
 
-             if (extension_code == SIGN_EXTEND)
+             if (extension_code == SIGN_EXTENDED_DEF)
                temp_extension = gen_rtx_SIGN_EXTEND (dest_extension_mode,
                                                      orig_src);
              else
@@ -2898,7 +2899,7 @@ see_merge_one_def_extension (void **slot, void *b)
     {
       rtx orig_src = SET_SRC (*pat);
 
-      if (extension_code == SIGN_EXTEND)
+      if (extension_code == SIGN_EXTENDED_DEF)
        temp_extension = gen_rtx_SIGN_EXTEND (dest_extension_mode, orig_src);
       else
        temp_extension = gen_rtx_ZERO_EXTEND (dest_extension_mode, orig_src);
@@ -3245,7 +3246,7 @@ see_handle_relevant_defs (struct df_ref *ref, rtx insn)
 {
   struct web_entry *root_entry = NULL;
   rtx se_insn = NULL;
-  enum rtx_code extension_code;
+  enum entry_type extension_code;
   rtx reg = DF_REF_REAL_REG (ref);
   rtx ref_insn = NULL;
   unsigned int i = DF_REF_ID (ref);
@@ -3274,9 +3275,9 @@ see_handle_relevant_defs (struct df_ref *ref, rtx insn)
     {
       
       if (ENTRY_EI (root_entry)->relevancy == SIGN_EXTENDED_DEF)
-       extension_code = SIGN_EXTEND;
+       extension_code = SIGN_EXTENDED_DEF;
       else
-       extension_code = ZERO_EXTEND;
+       extension_code = ZERO_EXTENDED_DEF;
       
       se_insn =
        see_gen_normalized_extension (reg, extension_code,
@@ -3314,7 +3315,7 @@ see_handle_relevant_uses (struct df_ref *ref, rtx insn)
 {
   struct web_entry *root_entry = NULL;
   rtx se_insn = NULL;
-  enum rtx_code extension_code;
+  enum entry_type extension_code;
   rtx reg = DF_REF_REAL_REG (ref);
 
   root_entry = unionfind_root (&use_entry[DF_REF_ID (ref)]);
@@ -3333,9 +3334,9 @@ see_handle_relevant_uses (struct df_ref *ref, rtx insn)
   
   /* Generate the use extension.  */
   if (ENTRY_EI (root_entry)->relevancy == SIGN_EXTENDED_DEF)
-    extension_code = SIGN_EXTEND;
+    extension_code = SIGN_EXTENDED_DEF;
   else
-    extension_code = ZERO_EXTEND;
+    extension_code = ZERO_EXTENDED_DEF;
   
   se_insn =
     see_gen_normalized_extension (reg, extension_code,
@@ -3468,7 +3469,7 @@ static enum entry_type
 see_analyze_one_def (rtx insn, enum machine_mode *source_mode,
                     enum machine_mode *source_mode_unsigned)
 {
-  enum rtx_code extension_code;
+  enum entry_type extension_code;
   rtx rhs = NULL;
   rtx lhs = NULL;
   rtx set = NULL;
@@ -3487,8 +3488,8 @@ see_analyze_one_def (rtx insn, enum machine_mode *source_mode,
   extension_code = see_get_extension_data (insn, source_mode);
   switch (extension_code)
     {
-    case SIGN_EXTEND:
-    case ZERO_EXTEND:
+    case SIGN_EXTENDED_DEF:
+    case ZERO_EXTENDED_DEF:
       source_register = see_get_extension_reg (insn, 0);
       /* FIXME: This restriction can be relaxed.  The only thing that is
         important is that the reference would be inside the same basic block
@@ -3521,12 +3522,9 @@ see_analyze_one_def (rtx insn, enum machine_mode *source_mode,
            return NOT_RELEVANT;
        }
 
-      if (extension_code == SIGN_EXTEND)
-       return SIGN_EXTENDED_DEF;
-      else
-       return ZERO_EXTENDED_DEF;
+      return extension_code;
 
-    case UNKNOWN:
+    case NOT_RELEVANT:
       /* This may still be an EXTENDED_DEF.  */
 
       /* FIXME: This restriction can be relaxed.  It is possible to handle
@@ -3894,4 +3892,3 @@ struct rtl_opt_pass pass_see =
   TODO_dump_func                       /* todo_flags_finish */
  }
 };
-

diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index ce0649d..ce06d0e 100644 (file)
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -6231,7 +6231,7 @@ need_fake_edge_p (gimple t)
       && !(call_flags & ECF_NORETURN))
     return true;
 
-  if (gimple_code (t) == ASM_EXPR
+  if (gimple_code (t) == GIMPLE_ASM
        && (gimple_asm_volatile_p (t) || gimple_asm_input_p (t)))
     return true;
 

diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h
index c75afb0..99b993d 100644 (file)
--- a/gcc/tree-flow.h
+++ b/gcc/tree-flow.h
@@ -676,7 +676,7 @@ extern struct omp_region *new_omp_region (basic_block, enum gimple_code,
                                          struct omp_region *);
 extern void free_omp_regions (void);
 void omp_expand_local (basic_block);
-extern tree find_omp_clause (tree, enum tree_code);
+extern tree find_omp_clause (tree, enum omp_clause_code);
 tree copy_var_decl (tree, tree, tree);
 
 /*---------------------------------------------------------------------------

diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index e1540f3..42a5431 100644 (file)
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -3216,7 +3216,7 @@ is_escape_site (gimple stmt)
         Applications (OOPSLA), pp. 1-19, 1999.  */
       return ESCAPE_STORED_IN_GLOBAL;
     }
-  else if (gimple_code (stmt) == RETURN_EXPR)
+  else if (gimple_code (stmt) == GIMPLE_RETURN)
     return ESCAPE_TO_RETURN;
 
   return NO_ESCAPE;

diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index 9fe0753..8f700c4 100644 (file)
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -501,7 +501,7 @@ likely_value (gimple stmt)
   tree use;
   ssa_op_iter iter;
 
-  enum tree_code code = gimple_code (stmt);
+  enum gimple_code code = gimple_code (stmt);
 
   /* This function appears to be called only for assignments, calls,
      conditionals, and switches, due to the logic in visit_stmt.  */
@@ -1308,7 +1308,7 @@ evaluate_stmt (gimple stmt)
      bother folding the statement.  */
   else if (likelyvalue == VARYING)
     {
-      enum tree_code code = gimple_code (stmt);
+      enum gimple_code code = gimple_code (stmt);
       if (code == GIMPLE_ASSIGN)
         {
           enum tree_code subcode = gimple_assign_rhs_code (stmt);

diff --git a/gcc/tree-vect-analyze.c b/gcc/tree-vect-analyze.c
index 93cd643..06e004c 100644 (file)
--- a/gcc/tree-vect-analyze.c
+++ b/gcc/tree-vect-analyze.c
@@ -427,7 +427,7 @@ vect_analyze_operations (loop_vec_info loop_vinfo)
        {
          gimple stmt = gsi_stmt (si);
          stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
-         enum vect_def_type relevance = STMT_VINFO_RELEVANT (stmt_info);
+         enum vect_relevant relevance = STMT_VINFO_RELEVANT (stmt_info);
 
          if (vect_print_dump_info (REPORT_DETAILS))
            {
@@ -4081,8 +4081,10 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo)
 
            case vect_used_in_outer_by_reduction:
            case vect_used_in_outer:
-             gcc_assert (gimple_code (stmt) != WIDEN_SUM_EXPR
-                         && gimple_code (stmt) != DOT_PROD_EXPR);
+             gcc_assert (gimple_code (stmt) != GIMPLE_ASSIGN
+                          || (gimple_assign_rhs_code (stmt) != WIDEN_SUM_EXPR
+                              && (gimple_assign_rhs_code (stmt)
+                                  != DOT_PROD_EXPR)));
              break;
 
            case vect_used_by_reduction: