[Ada] Deconstruct a VMS utility routine which is only used by GNATprove

gcc/ada/

	* sem_eval.ads (Compile_Time_Known_Value_Or_Aggr): Remove spec.
	* sem_eval.adb (Compile_Time_Known_Value_Or_Aggr): Remove body.

diff --git a/gcc/ada/sem_eval.adb b/gcc/ada/sem_eval.adb
index 2a6ca78..2881a14 100644 (file)
--- a/gcc/ada/sem_eval.adb
+++ b/gcc/ada/sem_eval.adb
@@ -1916,90 +1916,6 @@ package body Sem_Eval is
          return False;
    end Compile_Time_Known_Value;
 
-   --------------------------------------
-   -- Compile_Time_Known_Value_Or_Aggr --
-   --------------------------------------
-
-   function Compile_Time_Known_Value_Or_Aggr (Op : Node_Id) return Boolean is
-   begin
-      --  If we have an entity name, then see if it is the name of a constant
-      --  and if so, test the corresponding constant value, or the name of
-      --  an enumeration literal, which is always a constant.
-
-      if Is_Entity_Name (Op) then
-         declare
-            E : constant Entity_Id := Entity (Op);
-            V : Node_Id;
-
-         begin
-            if Ekind (E) = E_Enumeration_Literal then
-               return True;
-
-            elsif Ekind (E) /= E_Constant then
-               return False;
-
-            else
-               V := Constant_Value (E);
-               return Present (V)
-                 and then Compile_Time_Known_Value_Or_Aggr (V);
-            end if;
-         end;
-
-      --  We have a value, see if it is compile-time-known
-
-      else
-         if Compile_Time_Known_Value (Op) then
-            return True;
-
-         elsif Nkind (Op) = N_Aggregate then
-
-            if Present (Expressions (Op)) then
-               declare
-                  Expr : Node_Id;
-               begin
-                  Expr := First (Expressions (Op));
-                  while Present (Expr) loop
-                     if not Compile_Time_Known_Value_Or_Aggr (Expr) then
-                        return False;
-                     else
-                        Next (Expr);
-                     end if;
-                  end loop;
-               end;
-            end if;
-
-            if Present (Component_Associations (Op)) then
-               declare
-                  Cass : Node_Id;
-
-               begin
-                  Cass := First (Component_Associations (Op));
-                  while Present (Cass) loop
-                     if not
-                       Compile_Time_Known_Value_Or_Aggr (Expression (Cass))
-                     then
-                        return False;
-                     end if;
-
-                     Next (Cass);
-                  end loop;
-               end;
-            end if;
-
-            return True;
-
-         elsif Nkind (Op) = N_Qualified_Expression then
-            return Compile_Time_Known_Value_Or_Aggr (Expression (Op));
-
-         --  All other types of values are not known at compile time
-
-         else
-            return False;
-         end if;
-
-      end if;
-   end Compile_Time_Known_Value_Or_Aggr;
-
    ---------------------------------------
    -- CRT_Safe_Compile_Time_Known_Value --
    ---------------------------------------

diff --git a/gcc/ada/sem_eval.ads b/gcc/ada/sem_eval.ads
index cacbd1f..eb919f1 100644 (file)
--- a/gcc/ada/sem_eval.ads
+++ b/gcc/ada/sem_eval.ads
@@ -236,15 +236,6 @@ package Sem_Eval is
 
    --  WARNING: There is a matching C declaration of this subprogram in fe.h
 
-   function Compile_Time_Known_Value_Or_Aggr (Op : Node_Id) return Boolean;
-   --  Similar to Compile_Time_Known_Value, but also returns True if the value
-   --  is a compile-time-known aggregate, i.e. an aggregate all of whose
-   --  constituent expressions are either compile-time-known values (based on
-   --  calling Compile_Time_Known_Value) or compile-time-known aggregates.
-   --  Note that the aggregate could still involve run-time checks that might
-   --  fail (such as for subtype checks in component associations), but the
-   --  evaluation of the expressions themselves will not raise an exception.
-
    function CRT_Safe_Compile_Time_Known_Value (Op : Node_Id) return Boolean;
    --  In the case of configurable run-times, there may be an issue calling
    --  Compile_Time_Known_Value with non-static expressions where the legality