2005-03-29 Ed Falis <falis@adacore.com>

[pf3gnuchains/gcc-fork.git] / gcc / tree-eh.c

diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c
index 6103aa6..698c654 100644 (file)
--- a/gcc/tree-eh.c
+++ b/gcc/tree-eh.c
@@ -1,5 +1,5 @@
 /* Exception handling semantics and decomposition for trees.
-   Copyright (C) 2003 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -103,8 +103,7 @@ record_stmt_eh_region (struct eh_region *region, tree t)
   n->region_nr = get_eh_region_number (region);
 
   slot = htab_find_slot (throw_stmt_table, n, INSERT);
-  if (*slot)
-    abort ();
+  gcc_assert (!*slot);
   *slot = n;
 }
 
@@ -114,16 +113,14 @@ add_stmt_to_eh_region (tree t, int num)
   struct throw_stmt_node *n;
   void **slot;
 
-  if (num < 0)
-    abort ();
+  gcc_assert (num >= 0);
 
   n = ggc_alloc (sizeof (*n));
   n->stmt = t;
   n->region_nr = num;
 
   slot = htab_find_slot (throw_stmt_table, n, INSERT);
-  if (*slot)
-    abort ();
+  gcc_assert (!*slot);
   *slot = n;
 }
 
@@ -186,8 +183,7 @@ record_in_finally_tree (tree child, tree parent)
   n->parent = parent;
 
   slot = htab_find_slot (finally_tree, n, INSERT);
-  if (*slot)
-    abort ();
+  gcc_assert (!*slot);
   *slot = n;
 }
 
@@ -422,7 +418,7 @@ replace_goto_queue_1 (tree t, struct leh_tf_state *tf, tree_stmt_iterator *tsi)
       break;
 
     case STATEMENT_LIST:
-      abort ();
+      gcc_unreachable ();
 
     default:
       /* These won't have gotos in them.  */
@@ -447,6 +443,8 @@ replace_goto_queue_stmt_list (tree t, struct leh_tf_state *tf)
 static void
 replace_goto_queue (struct leh_tf_state *tf)
 {
+  if (tf->goto_queue_active == 0)
+    return;
   replace_goto_queue_stmt_list (*tf->top_p, tf);
 }
 
@@ -505,7 +503,7 @@ maybe_record_in_goto_queue (struct leh_state *state, tree stmt)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   active = tf->goto_queue_active;
@@ -547,8 +545,7 @@ verify_norecord_switch_expr (struct leh_state *state, tree switch_expr)
   for (i = 0; i < n; ++i)
     {
       tree lab = CASE_LABEL (TREE_VEC_ELT (vec, i));
-      if (outside_finally_tree (lab, tf->try_finally_expr))
-       abort ();
+      gcc_assert (!outside_finally_tree (lab, tf->try_finally_expr));
     }
 }
 #else
@@ -591,47 +588,51 @@ do_return_redirection (struct goto_queue_node *q, tree finlab, tree mod,
          depends, I guess, but it does make generation of the switch in
          lower_try_finally_switch easier.  */
 
-      if (TREE_CODE (ret_expr) == RESULT_DECL)
+      switch (TREE_CODE (ret_expr))
        {
+       case RESULT_DECL:
          if (!*return_value_p)
            *return_value_p = ret_expr;
-         else if (*return_value_p != ret_expr)
-           abort ();
-          q->cont_stmt = q->stmt;
-       }
-      else if (TREE_CODE (ret_expr) == MODIFY_EXPR)
-       {
-         tree result = TREE_OPERAND (ret_expr, 0);
-         tree new, old = TREE_OPERAND (ret_expr, 1);
-
-         if (!*return_value_p)
-           {
-             if (aggregate_value_p (TREE_TYPE (result),
-                                    TREE_TYPE (current_function_decl)))
-               /* If this function returns in memory, copy the argument
-                  into the return slot now.  Otherwise, we might need to
-                  worry about magic return semantics, so we need to use a
-                  temporary to hold the value until we're actually ready
-                  to return.  */
-               new = result;
-             else
-               new = create_tmp_var (TREE_TYPE (old), "rettmp");
-             *return_value_p = new;
-           }
          else
-           new = *return_value_p;
+           gcc_assert (*return_value_p == ret_expr);
+         q->cont_stmt = q->stmt;
+         break;
 
-         x = build (MODIFY_EXPR, TREE_TYPE (new), new, old);
-         append_to_statement_list (x, &q->repl_stmt);
+       case MODIFY_EXPR:
+         {
+           tree result = TREE_OPERAND (ret_expr, 0);
+           tree new, old = TREE_OPERAND (ret_expr, 1);
+
+           if (!*return_value_p)
+             {
+               if (aggregate_value_p (TREE_TYPE (result),
+                                     TREE_TYPE (current_function_decl)))
+                 /* If this function returns in memory, copy the argument
+                   into the return slot now.  Otherwise, we might need to
+                   worry about magic return semantics, so we need to use a
+                   temporary to hold the value until we're actually ready
+                   to return.  */
+                 new = result;
+               else
+                 new = create_tmp_var (TREE_TYPE (old), "rettmp");
+               *return_value_p = new;
+             }
+           else
+             new = *return_value_p;
+
+           x = build (MODIFY_EXPR, TREE_TYPE (new), new, old);
+           append_to_statement_list (x, &q->repl_stmt);
+
+           if (new == result)
+             x = result;
+           else
+             x = build (MODIFY_EXPR, TREE_TYPE (result), result, new);
+           q->cont_stmt = build1 (RETURN_EXPR, void_type_node, x);
+         }
 
-         if (new == result)
-           x = result;
-         else
-           x = build (MODIFY_EXPR, TREE_TYPE (result), result, new);
-         q->cont_stmt = build1 (RETURN_EXPR, void_type_node, x);
+       default:
+         gcc_unreachable ();
        }
-      else
-       abort ();
     }
   else
     {
@@ -754,7 +755,7 @@ lower_try_finally_fallthru_label (struct leh_tf_state *tf)
    alternative considered below.  For the nonce, we always choose the first
    option.
 
-   THIS_STATE may be null if if this is a try-cleanup, not a try-finally.  */
+   THIS_STATE may be null if this is a try-cleanup, not a try-finally.  */
 
 static void
 honor_protect_cleanup_actions (struct leh_state *outer_state,
@@ -1660,7 +1661,8 @@ struct tree_opt_pass pass_lower_eh =
   PROP_gimple_leh,                     /* properties_provided */
   PROP_gimple_lcf,                     /* properties_destroyed */
   0,                                   /* todo_flags_start */
-  TODO_dump_func                       /* todo_flags_finish */
+  TODO_dump_func,                      /* todo_flags_finish */
+  0                                    /* letter */
 };
 
 \f
@@ -1717,11 +1719,11 @@ tree_could_trap_p (tree expr)
   bool honor_snans = false;
   bool fp_operation = false;
   bool honor_trapv = false;
-  tree t, base, idx;
+  tree t, base;
 
-  if (TREE_CODE_CLASS (code) == '<'
-      || TREE_CODE_CLASS (code) == '1'
-      || TREE_CODE_CLASS (code) == '2')
+  if (TREE_CODE_CLASS (code) == tcc_comparison
+      || TREE_CODE_CLASS (code) == tcc_unary
+      || TREE_CODE_CLASS (code) == tcc_binary)
     {
       t = TREE_TYPE (expr);
       fp_operation = FLOAT_TYPE_P (t);
@@ -1757,7 +1759,6 @@ tree_could_trap_p (tree expr)
 
     case ARRAY_REF:
       base = TREE_OPERAND (expr, 0);
-      idx = TREE_OPERAND (expr, 1);
       if (tree_could_trap_p (base))
        return true;
 
@@ -1767,6 +1768,8 @@ tree_could_trap_p (tree expr)
       return !in_array_bounds_p (expr);
 
     case INDIRECT_REF:
+    case ALIGN_INDIRECT_REF:
+    case MISALIGNED_INDIRECT_REF:
       return !TREE_THIS_NOTRAP (expr);
 
     case ASM_EXPR:
@@ -1836,6 +1839,13 @@ tree_could_trap_p (tree expr)
        return true;
       return false;
 
+    case CALL_EXPR:
+      t = get_callee_fndecl (expr);
+      /* Assume that calls to weak functions may trap.  */
+      if (!t || !DECL_P (t) || DECL_WEAK (t))
+       return true;
+      return false;
+
     default:
       /* Any floating arithmetic may trap.  */
       if (fp_operation && flag_trapping_math)