decl.c, [...]: Add handling of Inline_Always pragma.

	* gcc-interface/decl.c, gcc-interface/trans.c,  
	gcc-interface/gigi.h: Add handling of Inline_Always pragma.  

Co-Authored-By: Eric Botcazou <ebotcazou@adacore.com>

From-SVN: r213354

3 files changed, 56 insertions, 27 deletions

diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index 75940fe..6b89f7f 100644
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -7,6 +7,7 @@
 	* gnat_ugn.texi: Document --test-duration option for gnattest.
 
 2014-07-31  Javier Miranda  <miranda@adacore.com>
+	    Eric Botcazou  <ebotcazou@adacore.com>
 
 	* opt.ads (Back_End_Inlining): New variable which controls
 	activation of inlining by back-end expansion.
@@ -26,6 +27,8 @@
 	* fe.h Import Back_End_Inlining variable.
 	* gcc-interface/utils.c (create_subprog_decl): If Back_End_Inlining is
 	enabled then declare attribute "always inline"
+	* gcc-interface/decl.c, gcc-interface/trans.c,
+	gcc-interface/gigi.h: Add handling of Inline_Always pragma.
 
 2014-07-31  Robert Dewar  <dewar@adacore.com>
 
diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c
index 10eb6cc..795eea3 100644
--- a/gcc/ada/gcc-interface/decl.c
+++ b/gcc/ada/gcc-interface/decl.c
@@ -4146,7 +4146,9 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	enum inline_status_t inline_status
 	  = Has_Pragma_No_Inline (gnat_entity)
 	    ? is_suppressed
-	    : (Is_Inlined (gnat_entity) ? is_enabled : is_disabled);
+	    : Has_Pragma_Inline_Always (gnat_entity)
+	      ? is_required
+	      : (Is_Inlined (gnat_entity) ? is_enabled : is_disabled);
 	bool public_flag = Is_Public (gnat_entity) || imported_p;
 	bool extern_flag
 	  = (Is_Public (gnat_entity) && !definition) || imported_p;
@@ -4701,6 +4703,16 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	  }
 	else
 	  {
+	    /* ??? When only the spec of a package is provided, downgrade
+	       is_required to is_enabled to avoid issuing an error later.  */
+	    if (inline_status == is_required)
+	      {
+		Node_Id gnat_body = Parent (Declaration_Node (gnat_entity));
+		if (Nkind (gnat_body) != N_Subprogram_Body
+		    && No (Corresponding_Body (gnat_body)))
+		  inline_status = is_enabled;
+	      }
+
 	    if (has_stub)
 	      {
 		gnu_stub_name = gnu_ext_name;
@@ -5178,8 +5190,12 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	 The language rules ensure the parent type is already frozen here.  */
       if (Is_Derived_Type (gnat_entity) && !type_annotate_only)
 	{
-	  tree gnu_parent_type = gnat_to_gnu_type (Etype (gnat_entity));
-	  relate_alias_sets (gnu_type, gnu_parent_type,
+	  Entity_Id gnat_parent_type = Underlying_Type (Etype (gnat_entity));
+	  /* For packed array subtypes, the implementation type is used.  */
+	  if (kind == E_Array_Subtype
+	      && Present (Packed_Array_Impl_Type (gnat_parent_type)))
+	    gnat_parent_type = Packed_Array_Impl_Type (gnat_parent_type);
+	  relate_alias_sets (gnu_type, gnat_to_gnu_type (gnat_parent_type),
 			     Is_Composite_Type (gnat_entity)
 			     ? ALIAS_SET_COPY : ALIAS_SET_SUPERSET);
 	}
diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c
index f038910..0e4befb 100644
--- a/gcc/ada/gcc-interface/trans.c
+++ b/gcc/ada/gcc-interface/trans.c
@@ -5051,6 +5051,7 @@ Compilation_Unit_to_gnu (Node_Id gnat_node)
   const bool body_p = (Nkind (gnat_unit) == N_Package_Body
 		       || Nkind (gnat_unit) == N_Subprogram_Body);
   const Entity_Id gnat_unit_entity = Defining_Entity (gnat_unit);
+  Entity_Id gnat_entity;
   Node_Id gnat_pragma;
   /* Make the decl for the elaboration procedure.  */
   tree gnu_elab_proc_decl
@@ -5099,33 +5100,31 @@ Compilation_Unit_to_gnu (Node_Id gnat_node)
   /* Process the unit itself.  */
   add_stmt (gnat_to_gnu (gnat_unit));
 
-  /* If we can inline, generate code for all the inlined subprograms.  */
-  if (optimize)
+  /* Generate code for all the inlined subprograms.  */
+  for (gnat_entity = First_Inlined_Subprogram (gnat_node);
+       Present (gnat_entity);
+       gnat_entity = Next_Inlined_Subprogram (gnat_entity))
     {
-      Entity_Id gnat_entity;
+      Node_Id gnat_body;
 
-      for (gnat_entity = First_Inlined_Subprogram (gnat_node);
-	   Present (gnat_entity);
-	   gnat_entity = Next_Inlined_Subprogram (gnat_entity))
-	{
-	  Node_Id gnat_body = Parent (Declaration_Node (gnat_entity));
+      /* Without optimization, process only the required subprograms.  */
+      if (!optimize && !Has_Pragma_Inline_Always (gnat_entity))
+	continue;
 
-	  if (Nkind (gnat_body) != N_Subprogram_Body)
-	    {
-	      /* ??? This really should always be present.  */
-	      if (No (Corresponding_Body (gnat_body)))
-		continue;
-	      gnat_body
-		= Parent (Declaration_Node (Corresponding_Body (gnat_body)));
-	    }
+      gnat_body = Parent (Declaration_Node (gnat_entity));
+      if (Nkind (gnat_body) != N_Subprogram_Body)
+	{
+	  /* ??? This happens when only the spec of a package is provided.  */
+	  if (No (Corresponding_Body (gnat_body)))
+	    continue;
 
-	  if (Present (gnat_body))
-	    {
-	      /* Define the entity first so we set DECL_EXTERNAL.  */
-	      gnat_to_gnu_entity (gnat_entity, NULL_TREE, 0);
-	      add_stmt (gnat_to_gnu (gnat_body));
-	    }
+	  gnat_body
+	    = Parent (Declaration_Node (Corresponding_Body (gnat_body)));
 	}
+
+      /* Define the entity first so we set DECL_EXTERNAL.  */
+      gnat_to_gnu_entity (gnat_entity, NULL_TREE, 0);
+      add_stmt (gnat_to_gnu (gnat_body));
     }
 
   /* Process any pragmas and actions following the unit.  */
@@ -5818,8 +5817,18 @@ gnat_to_gnu (Node_Id gnat_node)
 		   TYPE_MAX_VALUE (TYPE_INDEX_TYPE (TYPE_DOMAIN (gnu_type))),
 		   gnat_temp);
 
-	    gnu_result = build_binary_op (ARRAY_REF, NULL_TREE,
-					  gnu_result, gnu_expr);
+	    gnu_result
+	      = build_binary_op (ARRAY_REF, NULL_TREE, gnu_result, gnu_expr);
+
+	    /* Array accesses are bound-checked so they cannot trap, but this
+	       is valid only if they are not hoisted ahead of the check.  We
+	       need to mark them as no-trap to get decent loop optimizations
+	       in the presence of -fnon-call-exceptions, so we do it when we
+	       know that the original expression had no side-effects.  */
+	    if (TREE_CODE (gnu_result) == ARRAY_REF
+		&& !(Nkind (gnat_temp) == N_Identifier
+		     && Ekind (Entity (gnat_temp)) == E_Constant))
+	      TREE_THIS_NOTRAP (gnu_result) = 1;
 	  }
 
 	gnu_result_type = get_unpadded_type (Etype (gnat_node));
@@ -9349,6 +9358,7 @@ set_gnu_expr_location_from_node (tree node, Node_Id gnat_node)
     {
     CASE_CONVERT:
     case NON_LVALUE_EXPR:
+    case SAVE_EXPR:
       break;
 
     case COMPOUND_EXPR: