decl.c (gnat_to_gnu_entity): Use boolean_type_node in lieu of integer_type_node for boolean operations.

	* gcc-interface/decl.c (gnat_to_gnu_entity): Use boolean_type_node in
	lieu of integer_type_node for boolean operations.
	(choices_to_gnu): Likewise.
	* gcc-interface/trans.c (Attribute_to_gnu): Likewise.
	(Loop_Statement_to_gnu): Likewise.
	(establish_gnat_vms_condition_handler): Likewise.
	(Exception_Handler_to_gnu_sjlj): Likewise.
	(gnat_to_gnu): Likewise.
	(build_unary_op_trapv): Likewise.
	(build_binary_op_trapv): Likewise.
	(emit_range_check): Likewise.
	(emit_index_check): Likewise.
	(convert_with_check): Likewise.
	* gcc-interface/utils.c (convert_vms_descriptor64): Likewise.
	(convert_vms_descriptor32): Likewise.
	(convert_vms_descriptor): Likewise.
	* gcc-interface/utils2.c (nonbinary_modular_operation): Likewise.
	(compare_arrays): Use boolean instead of integer constants.
	(build_binary_op) <TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR, TRUTH_AND_EXPR,
	TRUTH_OR_EXPR, TRUTH_XOR_EXPR>: New case.  Check that the result type
	is a boolean type.
	<GE_EXPR, LE_EXPR, GT_EXPR, LT_EXPR>: Remove obsolete assertion.
	<EQ_EXPR, NE_EXPR>: Check that the result type is a boolean type.
	<PREINC/PREDECREMENT_EXPR, POSTINC/POSTDECREMENT_EXPR>: Delete.
	<TRUTH_NOT_EXPR>: Check that the result type is a boolean type.
	(build_unary_op): Use boolean_type_node in lieu of integer_type_node
	for boolean operations.
	(fill_vms_descriptor): Likewise.  Fix formatting nits.

From-SVN: r158411

1 files changed, 39 insertions, 33 deletions

diff --git a/gcc/ada/gcc-interface/utils2.c b/gcc/ada/gcc-interface/utils2.c
index b6bd268..33f3a61 100644
--- a/gcc/ada/gcc-interface/utils2.c
+++ b/gcc/ada/gcc-interface/utils2.c
@@ -242,11 +242,11 @@ find_common_type (tree t1, tree t2)
 static tree
 compare_arrays (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);
+  tree a2_is_null = convert (result_type, boolean_false_node);
   tree t1 = TREE_TYPE (a1);
   tree t2 = TREE_TYPE (a2);
-  tree result = convert (result_type, integer_one_node);
-  tree a1_is_null = convert (result_type, integer_zero_node);
-  tree a2_is_null = convert (result_type, integer_zero_node);
   bool a1_side_effects_p = TREE_SIDE_EFFECTS (a1);
   bool a2_side_effects_p = TREE_SIDE_EFFECTS (a2);
   bool length_zero_p = false;
@@ -310,7 +310,7 @@ compare_arrays (tree result_type, tree a1, tree a2)
 
 	  length_zero_p = true;
 	  this_a1_is_null = comparison;
-	  this_a2_is_null = convert (result_type, integer_one_node);
+	  this_a2_is_null = convert (result_type, boolean_true_node);
 	}
 
       /* If the length is some other constant value, we know that the
@@ -339,7 +339,7 @@ compare_arrays (tree result_type, tree a1, tree a2)
 	  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_a2_is_null = convert (result_type, integer_zero_node);
+	  this_a2_is_null = convert (result_type, boolean_false_node);
 	}
 
       /* Otherwise compare the computed lengths.  */
@@ -491,7 +491,7 @@ nonbinary_modular_operation (enum tree_code op_code, tree type, tree lhs,
     {
       result = gnat_protect_expr (result);
       result = fold_build3 (COND_EXPR, op_type,
-			    fold_build2 (LT_EXPR, integer_type_node, result,
+			    fold_build2 (LT_EXPR, boolean_type_node, result,
 					 convert (op_type, integer_zero_node)),
 			    fold_build2 (PLUS_EXPR, op_type, result, modulus),
 			    result);
@@ -502,7 +502,7 @@ nonbinary_modular_operation (enum tree_code op_code, tree type, tree lhs,
     {
       result = gnat_protect_expr (result);
       result = fold_build3 (COND_EXPR, op_type,
-			    fold_build2 (GE_EXPR, integer_type_node,
+			    fold_build2 (GE_EXPR, boolean_type_node,
 					 result, modulus),
 			    fold_build2 (MINUS_EXPR, op_type,
 					 result, modulus),
@@ -716,16 +716,28 @@ build_binary_op (enum tree_code op_code, tree result_type,
       modulus = NULL_TREE;
       break;
 
+    case TRUTH_ANDIF_EXPR:
+    case TRUTH_ORIF_EXPR:
+    case TRUTH_AND_EXPR:
+    case TRUTH_OR_EXPR:
+    case TRUTH_XOR_EXPR:
+#ifdef ENABLE_CHECKING
+      gcc_assert (TREE_CODE (get_base_type (result_type)) == BOOLEAN_TYPE);
+#endif
+      operation_type = left_base_type;
+      left_operand = convert (operation_type, left_operand);
+      right_operand = convert (operation_type, right_operand);
+      break;
+
     case GE_EXPR:
     case LE_EXPR:
     case GT_EXPR:
     case LT_EXPR:
-      gcc_assert (!POINTER_TYPE_P (left_type));
-
-      /* ... fall through ... */
-
     case EQ_EXPR:
     case NE_EXPR:
+#ifdef ENABLE_CHECKING
+      gcc_assert (TREE_CODE (get_base_type (result_type)) == BOOLEAN_TYPE);
+#endif
       /* If either operand is a NULL_EXPR, just return a new one.  */
       if (TREE_CODE (left_operand) == NULL_EXPR)
 	return build2 (op_code, result_type,
@@ -842,13 +854,6 @@ build_binary_op (enum tree_code op_code, tree result_type,
       modulus = NULL_TREE;
       break;
 
-    case PREINCREMENT_EXPR:
-    case PREDECREMENT_EXPR:
-    case POSTINCREMENT_EXPR:
-    case POSTDECREMENT_EXPR:
-      /* These operations are not used anymore.  */
-      gcc_unreachable ();
-
     case LSHIFT_EXPR:
     case RSHIFT_EXPR:
     case LROTATE_EXPR:
@@ -1001,7 +1006,9 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand)
       break;
 
     case TRUTH_NOT_EXPR:
-      gcc_assert (result_type == base_type);
+#ifdef ENABLE_CHECKING
+      gcc_assert (TREE_CODE (get_base_type (result_type)) == BOOLEAN_TYPE);
+#endif
       result = invert_truthvalue (operand);
       break;
 
@@ -1259,7 +1266,7 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand)
 
 		result = fold_build3 (COND_EXPR, operation_type,
 				      fold_build2 (NE_EXPR,
-						   integer_type_node,
+						   boolean_type_node,
 						   operand,
 						   convert
 						     (operation_type,
@@ -2088,12 +2095,11 @@ build_allocator (tree type, tree init, tree result_type, Entity_Id gnat_proc,
 tree
 fill_vms_descriptor (tree expr, Entity_Id gnat_formal, Node_Id gnat_actual)
 {
-  tree field;
   tree parm_decl = get_gnu_tree (gnat_formal);
-  tree const_list = NULL_TREE;
   tree record_type = TREE_TYPE (TREE_TYPE (parm_decl));
-  int do_range_check =
-      strcmp ("MBO",
+  tree const_list = NULL_TREE, field;
+  const bool do_range_check
+    = strcmp ("MBO",
 	      IDENTIFIER_POINTER (DECL_NAME (TYPE_FIELDS (record_type))));
 
   expr = maybe_unconstrained_array (expr);
@@ -2105,19 +2111,19 @@ fill_vms_descriptor (tree expr, Entity_Id gnat_formal, Node_Id gnat_actual)
 			      SUBSTITUTE_PLACEHOLDER_IN_EXPR
 			      (DECL_INITIAL (field), expr));
 
-      /* Check to ensure that only 32bit pointers are passed in
-	 32bit descriptors */
-      if (do_range_check &&
-          strcmp (IDENTIFIER_POINTER (DECL_NAME (field)), "POINTER") == 0)
+      /* Check to ensure that only 32-bit pointers are passed in
+	 32-bit descriptors */
+      if (do_range_check
+          && strcmp (IDENTIFIER_POINTER (DECL_NAME (field)), "POINTER") == 0)
         {
-	  tree pointer64type =
-	     build_pointer_type_for_mode (void_type_node, DImode, false);
+	  tree pointer64type
+	    = build_pointer_type_for_mode (void_type_node, DImode, false);
 	  tree addr64expr = build_unary_op (ADDR_EXPR, pointer64type, expr);
-	  tree malloc64low =
-	     build_int_cstu (long_integer_type_node, 0x80000000);
+	  tree malloc64low
+	    = build_int_cstu (long_integer_type_node, 0x80000000);
 
 	  add_stmt (build3 (COND_EXPR, void_type_node,
-			    build_binary_op (GE_EXPR, long_integer_type_node,
+			    build_binary_op (GE_EXPR, boolean_type_node,
 					     convert (long_integer_type_node,
 						      addr64expr),
 					     malloc64low),