* gcc-interface/decl.c (gnat_to_gnu_entity) <E_Access_Subtype>: Use

	XNEW instead of xmalloc.  Do not build useless pointer type.
	<E_Anonymous_Access_Subprogram_Type>: Use XNEW instead of xmalloc.
	* gcc-interface/trans.c (gnat_to_gnu) <N_Raise_Constraint_Error>: Tidy.
	* gcc-interface/utils2.c (build_unary_op): Remove local variable.

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

diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index 03adb2a..34f6f1d 100644 (file)
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,5 +1,13 @@
 2011-09-25  Eric Botcazou  <ebotcazou@adacore.com>
 
+       * gcc-interface/decl.c (gnat_to_gnu_entity) <E_Access_Subtype>: Use
+       XNEW instead of xmalloc.  Do not build useless pointer type.
+       <E_Anonymous_Access_Subprogram_Type>: Use XNEW instead of xmalloc.
+       * gcc-interface/trans.c (gnat_to_gnu) <N_Raise_Constraint_Error>: Tidy.
+       * gcc-interface/utils2.c (build_unary_op): Remove local variable.
+
+2011-09-25  Eric Botcazou  <ebotcazou@adacore.com>
+
        * gcc-interface/decl.c (gnat_to_gnu_entity) <object>: Do not promote
        the alignment if this doesn't prevent BLKmode access to the object.
 

diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c
index d96f683..fb552ae 100644 (file)
--- a/gcc/ada/gcc-interface/decl.c
+++ b/gcc/ada/gcc-interface/decl.c
@@ -3512,8 +3512,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
         fill it in later.  */
       if (!definition && defer_incomplete_level != 0)
        {
-         struct incomplete *p
-           = (struct incomplete *) xmalloc (sizeof (struct incomplete));
+         struct incomplete *p = XNEW (struct incomplete);
 
          gnu_type
            = build_pointer_type
@@ -3838,15 +3837,15 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
     case E_Access_Subtype:
 
       /* We treat this as identical to its base type; any constraint is
-        meaningful only to the front end.
+        meaningful only to the front-end.
 
         The designated type must be elaborated as well, if it does
         not have its own freeze node.  Designated (sub)types created
         for constrained components of records with discriminants are
-        not frozen by the front end and thus not elaborated by gigi,
+        not frozen by the front-end and thus not elaborated by gigi,
         because their use may appear before the base type is frozen,
         and because it is not clear that they are needed anywhere in
-        Gigi.  With the current model, there is no correct place where
+        gigi.  With the current model, there is no correct place where
         they could be elaborated.  */
 
       gnu_type = gnat_to_gnu_type (Etype (gnat_entity));
@@ -3860,20 +3859,17 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
             elaborate it later.  */
          if (!definition && defer_incomplete_level != 0)
            {
-             struct incomplete *p
-               = (struct incomplete *) xmalloc (sizeof (struct incomplete));
-             tree gnu_ptr_type
-               = build_pointer_type
-                 (make_dummy_type (Directly_Designated_Type (gnat_entity)));
+             struct incomplete *p = XNEW (struct incomplete);
 
-             p->old_type = TREE_TYPE (gnu_ptr_type);
+             p->old_type
+               = make_dummy_type (Directly_Designated_Type (gnat_entity));
              p->full_type = Directly_Designated_Type (gnat_entity);
              p->next = defer_incomplete_list;
              defer_incomplete_list = p;
            }
          else if (!IN (Ekind (Base_Type
-                             (Directly_Designated_Type (gnat_entity))),
-                      Incomplete_Or_Private_Kind))
+                              (Directly_Designated_Type (gnat_entity))),
+                       Incomplete_Or_Private_Kind))
            gnat_to_gnu_entity (Directly_Designated_Type (gnat_entity),
                                NULL_TREE, 0);
        }

diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c
index 27e2402..8a8fef8 100644 (file)
--- a/gcc/ada/gcc-interface/trans.c
+++ b/gcc/ada/gcc-interface/trans.c
@@ -5794,7 +5794,6 @@ gnat_to_gnu (Node_Id gnat_node)
       {
        const int reason = UI_To_Int (Reason (gnat_node));
        const Node_Id cond = Condition (gnat_node);
-       bool handled = false;
 
        if (type_annotate_only)
          {
@@ -5807,65 +5806,58 @@ gnat_to_gnu (Node_Id gnat_node)
        if (Exception_Extra_Info
            && !No_Exception_Handlers_Set ()
            && !get_exception_label (kind)
-           && TREE_CODE (gnu_result_type) == VOID_TYPE
+           && VOID_TYPE_P (gnu_result_type)
            && Present (cond))
-         {
-           if (reason == CE_Access_Check_Failed)
-             {
-               gnu_result = build_call_raise_column (reason, gnat_node);
-               handled = true;
-             }
-           else if ((reason == CE_Index_Check_Failed
-                     || reason == CE_Range_Check_Failed
-                     || reason == CE_Invalid_Data)
-                    && Nkind (cond) == N_Op_Not
-                    && Nkind (Right_Opnd (cond)) == N_In
-                    && Nkind (Right_Opnd (Right_Opnd (cond))) == N_Range)
-             {
-               Node_Id op = Right_Opnd (cond);  /* N_In node */
-               Node_Id index = Left_Opnd (op);
-               Node_Id type = Etype (index);
+         switch (reason)
+           {
+           case CE_Access_Check_Failed:
+             gnu_result = build_call_raise_column (reason, gnat_node);
+             break;
 
-               if (Is_Type (type)
-                   && Known_Esize (type)
-                   && UI_To_Int (Esize (type)) <= 32)
-                 {
-                   Node_Id right_op = Right_Opnd (op);
+           case CE_Index_Check_Failed:
+           case CE_Range_Check_Failed:
+           case CE_Invalid_Data:
+             if (Nkind (cond) == N_Op_Not
+                 && Nkind (Right_Opnd (cond)) == N_In
+                 && Nkind (Right_Opnd (Right_Opnd (cond))) == N_Range)
+               {
+                 Node_Id op = Right_Opnd (cond);  /* N_In node */
+                 Node_Id index = Left_Opnd (op);
+                 Node_Id range = Right_Opnd (op);
+                 Node_Id type = Etype (index);
+                 if (Is_Type (type)
+                     && Known_Esize (type)
+                     && UI_To_Int (Esize (type)) <= 32)
                    gnu_result
-                     = build_call_raise_range
-                       (reason, gnat_node,
-                        gnat_to_gnu (index),                  /* index */
-                        gnat_to_gnu (Low_Bound (right_op)),   /* first */
-                        gnat_to_gnu (High_Bound (right_op))); /* last  */
-                   handled = true;
-                 }
-             }
+                     = build_call_raise_range (reason, gnat_node,
+                                               gnat_to_gnu (index),
+                                               gnat_to_gnu
+                                               (Low_Bound (range)),
+                                               gnat_to_gnu
+                                               (High_Bound (range)));
+               }
+             break;
+
+           default:
+             break;
          }
 
-       if (handled)
+       if (gnu_result == error_mark_node)
+         gnu_result = build_call_raise (reason, gnat_node, kind);
+
+       set_expr_location_from_node (gnu_result, gnat_node);
+
+       /* If the type is VOID, this is a statement, so we need to generate
+          the code for the call.  Handle a condition, if there is one.  */
+       if (VOID_TYPE_P (gnu_result_type))
          {
-           set_expr_location_from_node (gnu_result, gnat_node);
-           gnu_result = build3 (COND_EXPR, void_type_node,
-                                gnat_to_gnu (cond),
-                                gnu_result, alloc_stmt_list ());
+           if (Present (cond))
+             gnu_result
+               = build3 (COND_EXPR, void_type_node, gnat_to_gnu (cond),
+                         gnu_result, alloc_stmt_list ());
          }
        else
-         {
-           gnu_result = build_call_raise (reason, gnat_node, kind);
-
-           /* If the type is VOID, this is a statement, so we need to generate
-              the code for the call.  Handle a Condition, if there is one.  */
-           if (TREE_CODE (gnu_result_type) == VOID_TYPE)
-             {
-               set_expr_location_from_node (gnu_result, gnat_node);
-               if (Present (cond))
-                 gnu_result = build3 (COND_EXPR, void_type_node,
-                                      gnat_to_gnu (cond),
-                                      gnu_result, alloc_stmt_list ());
-             }
-           else
-             gnu_result = build1 (NULL_EXPR, gnu_result_type, gnu_result);
-         }
+         gnu_result = build1 (NULL_EXPR, gnu_result_type, gnu_result);
       }
       break;
 

diff --git a/gcc/ada/gcc-interface/utils2.c b/gcc/ada/gcc-interface/utils2.c
index 87cb269..0849508 100644 (file)
--- a/gcc/ada/gcc-interface/utils2.c
+++ b/gcc/ada/gcc-interface/utils2.c
@@ -1000,7 +1000,6 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand)
   tree base_type = get_base_type (type);
   tree operation_type = result_type;
   tree result;
-  bool side_effects = false;
 
   if (operation_type
       && TREE_CODE (operation_type) == RECORD_TYPE
@@ -1235,8 +1234,12 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand)
          TREE_READONLY (result) = TYPE_READONLY (TREE_TYPE (type));
        }
 
-      side_effects
-       = (!TYPE_IS_FAT_POINTER_P (type) && TYPE_VOLATILE (TREE_TYPE (type)));
+      if (!TYPE_IS_FAT_POINTER_P (type) && TYPE_VOLATILE (TREE_TYPE (type)))
+       {
+         TREE_SIDE_EFFECTS (result) = 1;
+         if (TREE_CODE (result) == INDIRECT_REF)
+           TREE_THIS_VOLATILE (result) = TYPE_VOLATILE (TREE_TYPE (result));
+       }
       break;
 
     case NEGATE_EXPR:
@@ -1322,13 +1325,6 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand)
                            convert (operation_type, operand));
     }
 
-  if (side_effects)
-    {
-      TREE_SIDE_EFFECTS (result) = 1;
-      if (TREE_CODE (result) == INDIRECT_REF)
-       TREE_THIS_VOLATILE (result) = TYPE_VOLATILE (TREE_TYPE (result));
-    }
-
   if (result_type && TREE_TYPE (result) != result_type)
     result = convert (result_type, result);