trans.c (gigi): Don't set 'pure' flag on SJLJ routines.

	* gcc-interface/trans.c (gigi): Don't set 'pure' flag on SJLJ routines.
	* gcc-interface/utils2.c (compare_arrays): Add LOC parameter.  Set it
	directly on all the comparison expressions.
	(build_binary_op): Pass input_location to compare_arrays.

From-SVN: r166533

diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index 477aa984e2bfb97669ddf9de4337f0f12cb93436..ca0ffe92c31c4c8779021ad43e3334cb685f19de 100644 (file)
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,10 @@
+2010-11-10  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * gcc-interface/trans.c (gigi): Don't set 'pure' flag on SJLJ routines.
+       * gcc-interface/utils2.c (compare_arrays): Add LOC parameter.  Set it
+       directly on all the comparison expressions.
+       (build_binary_op): Pass input_location to compare_arrays.
+
 2010-11-10  Eric Botcazou  <ebotcazou@adacore.com>
 
        * gcc-interface/trans.c (lvalue_required_p) <N_Type_Conversion>): Look

diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c
index 5d36595a7d1a31a888e7c4945172ccb200c862d1..1ab0b15e927c3b8f37f467abd75d39b752bfb44d 100644 (file)
--- a/gcc/ada/gcc-interface/trans.c
+++ b/gcc/ada/gcc-interface/trans.c
@@ -399,8 +399,6 @@ gigi (Node_Id gnat_root, int max_gnat_node, int number_name ATTRIBUTE_UNUSED,
     (get_identifier ("system__soft_links__get_jmpbuf_address_soft"),
      NULL_TREE, build_function_type (jmpbuf_ptr_type, NULL_TREE),
      NULL_TREE, false, true, true, NULL, Empty);
-  /* Avoid creating superfluous edges to __builtin_setjmp receivers.  */
-  DECL_PURE_P (get_jmpbuf_decl) = 1;
   DECL_IGNORED_P (get_jmpbuf_decl) = 1;
 
   set_jmpbuf_decl
@@ -502,8 +500,6 @@ gigi (Node_Id gnat_root, int max_gnat_node, int number_name ATTRIBUTE_UNUSED,
      NULL_TREE,
      build_function_type (build_pointer_type (except_type_node), NULL_TREE),
      NULL_TREE, false, true, true, NULL, Empty);
-  /* Avoid creating superfluous edges to __builtin_setjmp receivers.  */
-  DECL_PURE_P (get_excptr_decl) = 1;
 
   raise_nodefer_decl
     = create_subprog_decl

diff --git a/gcc/ada/gcc-interface/utils2.c b/gcc/ada/gcc-interface/utils2.c
index 8088d53a1b048f55082a5cbed16bdf98e9fbeeb2..43599fac5a9e294e911369663a9e48b22ea8f4d3 100644 (file)
--- a/gcc/ada/gcc-interface/utils2.c
+++ b/gcc/ada/gcc-interface/utils2.c
@@ -235,7 +235,7 @@ find_common_type (tree t1, tree t2)
    tests in as efficient a manner as possible.  */
 
 static tree
-compare_arrays (tree result_type, tree a1, tree a2)
+compare_arrays (location_t loc, tree result_type, tree a1, tree a2)
 {
   tree result = convert (result_type, boolean_true_node);
   tree a1_is_null = convert (result_type, boolean_false_node);
@@ -296,10 +296,10 @@ compare_arrays (tree result_type, tree a1, tree a2)
          ub1 = TYPE_MAX_VALUE (TYPE_INDEX_TYPE (TYPE_DOMAIN (t1)));
          lb1 = TYPE_MIN_VALUE (TYPE_INDEX_TYPE (TYPE_DOMAIN (t1)));
 
-         comparison = build_binary_op (LT_EXPR, result_type, ub1, lb1);
+         comparison = fold_build2_loc (loc, LT_EXPR, result_type, ub1, lb1);
          comparison = SUBSTITUTE_PLACEHOLDER_IN_EXPR (comparison, a1);
          if (EXPR_P (comparison))
-           SET_EXPR_LOCATION (comparison, input_location);
+           SET_EXPR_LOCATION (comparison, loc);
 
          this_a1_is_null = comparison;
          this_a2_is_null = convert (result_type, boolean_true_node);
@@ -321,16 +321,15 @@ compare_arrays (tree result_type, tree a1, tree a2)
          bt = get_base_type (TREE_TYPE (ub1));
 
          comparison
-           = build_binary_op (EQ_EXPR, result_type,
+           = fold_build2_loc (loc, EQ_EXPR, result_type,
                               build_binary_op (MINUS_EXPR, bt, ub1, lb1),
                               build_binary_op (MINUS_EXPR, bt, ub2, lb2));
          comparison = SUBSTITUTE_PLACEHOLDER_IN_EXPR (comparison, a1);
          if (EXPR_P (comparison))
-           SET_EXPR_LOCATION (comparison, input_location);
+           SET_EXPR_LOCATION (comparison, loc);
 
-         this_a1_is_null = build_binary_op (LT_EXPR, result_type, ub1, lb1);
-         if (EXPR_P (this_a1_is_null))
-           SET_EXPR_LOCATION (this_a1_is_null, input_location);
+         this_a1_is_null
+           = fold_build2_loc (loc, LT_EXPR, result_type, ub1, lb1);
 
          this_a2_is_null = convert (result_type, boolean_false_node);
        }
@@ -342,31 +341,27 @@ compare_arrays (tree result_type, tree a1, tree a2)
          length2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (length2, a2);
 
          comparison
-           = build_binary_op (EQ_EXPR, result_type, length1, length2);
-         if (EXPR_P (comparison))
-           SET_EXPR_LOCATION (comparison, input_location);
+           = fold_build2_loc (loc, EQ_EXPR, result_type, length1, length2);
 
          /* If the length expression is of the form (cond ? val : 0), assume
             that cond is equivalent to (length != 0).  That's guaranteed by
             construction of the array types in gnat_to_gnu_entity.  */
          if (TREE_CODE (length1) == COND_EXPR
              && integer_zerop (TREE_OPERAND (length1, 2)))
-           this_a1_is_null = invert_truthvalue (TREE_OPERAND (length1, 0));
+           this_a1_is_null
+             = invert_truthvalue_loc (loc, TREE_OPERAND (length1, 0));
          else
-           this_a1_is_null = build_binary_op (EQ_EXPR, result_type, length1,
-                                              size_zero_node);
-          if (EXPR_P (this_a1_is_null))
-           SET_EXPR_LOCATION (this_a1_is_null, input_location);
+           this_a1_is_null = fold_build2_loc (loc, EQ_EXPR, result_type,
+                                              length1, size_zero_node);
 
          /* Likewise for the second array.  */
          if (TREE_CODE (length2) == COND_EXPR
              && integer_zerop (TREE_OPERAND (length2, 2)))
-           this_a2_is_null = invert_truthvalue (TREE_OPERAND (length2, 0));
+           this_a2_is_null
+             = invert_truthvalue_loc (loc, TREE_OPERAND (length2, 0));
          else
-           this_a2_is_null = build_binary_op (EQ_EXPR, result_type, length2,
-                                              size_zero_node);
-          if (EXPR_P (this_a2_is_null))
-           SET_EXPR_LOCATION (this_a2_is_null, input_location);
+           this_a2_is_null = fold_build2_loc (loc, EQ_EXPR, result_type,
+                                              length2, size_zero_node);
        }
 
       /* Append expressions for this dimension to the final expressions.  */
@@ -396,9 +391,7 @@ compare_arrays (tree result_type, tree a1, tree a2)
          a2 = convert (type, a2);
        }
 
-      comparison = fold_build2 (EQ_EXPR, result_type, a1, a2);
-      if (EXPR_P (comparison))
-       SET_EXPR_LOCATION (comparison, input_location);
+      comparison = fold_build2_loc (loc, EQ_EXPR, result_type, a1, a2);
 
       result
        = build_binary_op (TRUTH_ANDIF_EXPR, result_type, result, comparison);
@@ -784,8 +777,8 @@ build_binary_op (enum tree_code op_code, tree result_type,
              || (TREE_CODE (right_type) == INTEGER_TYPE
                  && TYPE_HAS_ACTUAL_BOUNDS_P (right_type))))
        {
-         result = compare_arrays (result_type, left_operand, right_operand);
-
+         result = compare_arrays (input_location,
+                                  result_type, left_operand, right_operand);
          if (op_code == NE_EXPR)
            result = invert_truthvalue_loc (EXPR_LOCATION (result), result);
          else