Subversion Repositories openrisc

------------------------------------------------------------------------------
--                                                                          --
--                GNU ADA RUN-TIME LIBRARY (GNARL) COMPONENTS               --
--                                                                          --
--                   S Y S T E M - S T A C K _ U S A G E                    --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--         Copyright (C) 2004-2009, Free Software Foundation, Inc.          --
--                                                                          --
-- GNARL is free software; you can  redistribute it  and/or modify it under --
-- terms of the  GNU General Public License as published  by the Free Soft- --
-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --
--                                                                          --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception,   --
-- version 3.1, as published by the Free Software Foundation.               --
--                                                                          --
-- You should have received a copy of the GNU General Public License and    --
-- a copy of the GCC Runtime Library Exception along with this program;     --
-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
-- <http://www.gnu.org/licenses/>.                                          --
--                                                                          --
-- GNARL was developed by the GNARL team at Florida State University.       --
-- Extensive contributions were provided by Ada Core Technologies, Inc.     --
--                                                                          --
------------------------------------------------------------------------------
 
with System.Parameters;
with System.CRTL;
with System.IO;
 
package body System.Stack_Usage is
   use System.Storage_Elements;
   use System;
   use System.IO;
   use Interfaces;
 
   -----------------
   -- Stack_Slots --
   -----------------
 
   --  Stackl_Slots is an internal data type to represent a sequence of real
   --  stack slots initialized with a provided pattern, with operations to
   --  abstract away the target call stack growth direction.
 
   type Stack_Slots is array (Integer range <>) of Pattern_Type;
   for Stack_Slots'Component_Size use Pattern_Type'Object_Size;
 
   --  We will carefully handle the initializations ourselves and might want
   --  to remap an initialized overlay later on with an address clause.
 
   pragma Suppress_Initialization (Stack_Slots);
 
   --  The abstract Stack_Slots operations all operate over the simple array
   --  memory model:
 
   --  memory addresses increasing ---->
 
   --  Slots('First)                                           Slots('Last)
   --    |                                                             |
   --    V                                                             V
   --  +------------------------------------------------------------------+
   --  |####|                                                        |####|
   --  +------------------------------------------------------------------+
 
   --  What we call Top or Bottom always denotes call chain leaves or entry
   --  points respectively, and their relative positions in the stack array
   --  depends on the target stack growth direction:
 
   --                           Stack_Grows_Down
 
   --                <----- calls push frames towards decreasing addresses
 
   --   Top(most) Slot                                   Bottom(most) Slot
   --    |                                                            |
   --    V                                                            V
   --  +------------------------------------------------------------------+
   --  |####|                            | leaf frame | ... | entry frame |
   --  +------------------------------------------------------------------+
 
   --                           Stack_Grows_Up
 
   --   calls push frames towards increasing addresses ----->
 
   --   Bottom(most) Slot                                    Top(most) Slot
   --    |                                                             |
   --    V                                                             V
   --  +------------------------------------------------------------------+
   --  | entry frame | ... | leaf frame |                            |####|
   --  +------------------------------------------------------------------+
 
   function Top_Slot_Index_In (Stack : Stack_Slots) return Integer;
   --  Index of the stack Top slot in the Slots array, denoting the latest
   --  possible slot available to call chain leaves.
 
   function Bottom_Slot_Index_In (Stack : Stack_Slots) return Integer;
   --  Index of the stack Bottom slot in the Slots array, denoting the first
   --  possible slot available to call chain entry points.
 
   function Push_Index_Step_For (Stack : Stack_Slots) return Integer;
   --  By how much do we need to update a Slots index to Push a single slot on
   --  the stack.
 
   function Pop_Index_Step_For (Stack : Stack_Slots) return Integer;
   --  By how much do we need to update a Slots index to Pop a single slot off
   --  the stack.
 
   pragma Inline_Always (Top_Slot_Index_In);
   pragma Inline_Always (Bottom_Slot_Index_In);
   pragma Inline_Always (Push_Index_Step_For);
   pragma Inline_Always (Pop_Index_Step_For);
 
   -----------------------
   -- Top_Slot_Index_In --
   -----------------------
 
   function Top_Slot_Index_In (Stack : Stack_Slots) return Integer is
   begin
      if System.Parameters.Stack_Grows_Down then
         return Stack'First;
      else
         return Stack'Last;
      end if;
   end Top_Slot_Index_In;
 
   ----------------------------
   --  Bottom_Slot_Index_In  --
   ----------------------------
 
   function Bottom_Slot_Index_In (Stack : Stack_Slots) return Integer is
   begin
      if System.Parameters.Stack_Grows_Down then
         return Stack'Last;
      else
         return Stack'First;
      end if;
   end Bottom_Slot_Index_In;
 
   -------------------------
   -- Push_Index_Step_For --
   -------------------------
 
   function Push_Index_Step_For (Stack : Stack_Slots) return Integer is
      pragma Unreferenced (Stack);
   begin
      if System.Parameters.Stack_Grows_Down then
         return -1;
      else
         return +1;
      end if;
   end Push_Index_Step_For;
 
   ------------------------
   -- Pop_Index_Step_For --
   ------------------------
 
   function Pop_Index_Step_For (Stack : Stack_Slots) return Integer is
   begin
      return -Push_Index_Step_For (Stack);
   end Pop_Index_Step_For;
 
   -------------------
   -- Unit Services --
   -------------------
 
   --  Now the implementation of the services offered by this unit, on top of
   --  the Stack_Slots abstraction above.
 
   Index_Str       : constant String  := "Index";
   Task_Name_Str   : constant String  := "Task Name";
   Stack_Size_Str  : constant String  := "Stack Size";
   Actual_Size_Str : constant String  := "Stack usage";
 
   function Get_Usage_Range (Result : Task_Result) return String;
   --  Return string representing the range of possible result of stack usage
 
   procedure Output_Result
     (Result_Id          : Natural;
      Result             : Task_Result;
      Max_Stack_Size_Len : Natural;
      Max_Actual_Use_Len : Natural);
   --  Prints the result on the standard output. Result Id is the number of
   --  the result in the array, and Result the contents of the actual result.
   --  Max_Stack_Size_Len and Max_Actual_Use_Len are used for displaying the
   --  proper layout. They hold the maximum length of the string representing
   --  the Stack_Size and Actual_Use values.
 
   ----------------
   -- Initialize --
   ----------------
 
   procedure Initialize (Buffer_Size : Natural) is
      Bottom_Of_Stack  : aliased Integer;
      Stack_Size_Chars : System.Address;
 
   begin
      --  Initialize the buffered result array
 
      Result_Array := new Result_Array_Type (1 .. Buffer_Size);
      Result_Array.all :=
        (others =>
           (Task_Name => (others => ASCII.NUL),
            Variation => 0,
            Value     => 0,
            Max_Size  => 0));
 
      --  Set the Is_Enabled flag to true, so that the task wrapper knows that
      --  it has to handle dynamic stack analysis
 
      Is_Enabled := True;
 
      Stack_Size_Chars := System.CRTL.getenv ("GNAT_STACK_LIMIT" & ASCII.NUL);
 
      --  If variable GNAT_STACK_LIMIT is set, then we will take care of the
      --  environment task, using GNAT_STASK_LIMIT as the size of the stack.
      --  It doesn't make sens to process the stack when no bound is set (e.g.
      --  limit is typically up to 4 GB).
 
      if Stack_Size_Chars /= Null_Address then
         declare
            My_Stack_Size : Integer;
 
         begin
            My_Stack_Size := System.CRTL.atoi (Stack_Size_Chars) * 1024;
 
            Initialize_Analyzer
              (Environment_Task_Analyzer,
               "ENVIRONMENT TASK",
               My_Stack_Size,
               My_Stack_Size,
               System.Storage_Elements.To_Integer (Bottom_Of_Stack'Address));
 
            Fill_Stack (Environment_Task_Analyzer);
 
            Compute_Environment_Task := True;
         end;
 
      --  GNAT_STACK_LIMIT not set
 
      else
         Compute_Environment_Task := False;
      end if;
   end Initialize;
 
   ----------------
   -- Fill_Stack --
   ----------------
 
   procedure Fill_Stack (Analyzer : in out Stack_Analyzer) is
      --  Change the local variables and parameters of this function with
      --  super-extra care. The more the stack frame size of this function is
      --  big, the more an "instrumentation threshold at writing" error is
      --  likely to happen.
 
      Stack_Used_When_Filling : Integer;
      Current_Stack_Level     : aliased Integer;
 
   begin
      --  Readjust the pattern size. When we arrive in this function, there is
      --  already a given amount of stack used, that we won't analyze.
 
      Stack_Used_When_Filling :=
        Stack_Size
         (Analyzer.Bottom_Of_Stack,
          To_Stack_Address (Current_Stack_Level'Address))
          + Natural (Current_Stack_Level'Size);
 
      if Stack_Used_When_Filling > Analyzer.Pattern_Size then
         --  In this case, the known size of the stack is too small, we've
         --  already taken more than expected, so there's no possible
         --  computation
 
         Analyzer.Pattern_Size := 0;
      else
         Analyzer.Pattern_Size :=
           Analyzer.Pattern_Size - Stack_Used_When_Filling;
      end if;
 
      declare
         Stack : aliased Stack_Slots
                           (1 .. Analyzer.Pattern_Size / Bytes_Per_Pattern);
 
      begin
         Stack := (others => Analyzer.Pattern);
 
         Analyzer.Stack_Overlay_Address := Stack'Address;
 
         if Analyzer.Pattern_Size /= 0 then
            Analyzer.Bottom_Pattern_Mark :=
              To_Stack_Address (Stack (Bottom_Slot_Index_In (Stack))'Address);
            Analyzer.Top_Pattern_Mark :=
              To_Stack_Address (Stack (Top_Slot_Index_In (Stack))'Address);
         else
            Analyzer.Bottom_Pattern_Mark := To_Stack_Address (Stack'Address);
            Analyzer.Top_Pattern_Mark := To_Stack_Address (Stack'Address);
         end if;
 
         --  If Arr has been packed, the following assertion must be true (we
         --  add the size of the element whose address is:
         --    Min (Analyzer.Inner_Pattern_Mark, Analyzer.Outer_Pattern_Mark)):
 
         pragma Assert
           (Analyzer.Pattern_Size = 0 or else
            Analyzer.Pattern_Size =
              Stack_Size
                (Analyzer.Top_Pattern_Mark, Analyzer.Bottom_Pattern_Mark));
      end;
   end Fill_Stack;
 
   -------------------------
   -- Initialize_Analyzer --
   -------------------------
 
   procedure Initialize_Analyzer
     (Analyzer         : in out Stack_Analyzer;
      Task_Name        : String;
      My_Stack_Size    : Natural;
      Max_Pattern_Size : Natural;
      Bottom           : Stack_Address;
      Pattern          : Unsigned_32 := 16#DEAD_BEEF#)
   is
   begin
      --  Initialize the analyzer fields
 
      Analyzer.Bottom_Of_Stack := Bottom;
      Analyzer.Stack_Size      := My_Stack_Size;
      Analyzer.Pattern_Size    := Max_Pattern_Size;
      Analyzer.Pattern         := Pattern;
      Analyzer.Result_Id       := Next_Id;
      Analyzer.Task_Name       := (others => ' ');
 
      --  Compute the task name, and truncate if bigger than Task_Name_Length
 
      if Task_Name'Length <= Task_Name_Length then
         Analyzer.Task_Name (1 .. Task_Name'Length) := Task_Name;
      else
         Analyzer.Task_Name :=
           Task_Name (Task_Name'First ..
                        Task_Name'First + Task_Name_Length - 1);
      end if;
 
      Next_Id := Next_Id + 1;
   end Initialize_Analyzer;
 
   ----------------
   -- Stack_Size --
   ----------------
 
   function Stack_Size
     (SP_Low  : Stack_Address;
      SP_High : Stack_Address) return Natural
   is
   begin
      if SP_Low > SP_High then
         return Natural (SP_Low - SP_High + 4);
      else
         return Natural (SP_High - SP_Low + 4);
      end if;
   end Stack_Size;
 
   --------------------
   -- Compute_Result --
   --------------------
 
   procedure Compute_Result (Analyzer : in out Stack_Analyzer) is
 
      --  Change the local variables and parameters of this function with
      --  super-extra care. The larger the stack frame size of this function
      --  is, the more an "instrumentation threshold at reading" error is
      --  likely to happen.
 
      Stack : Stack_Slots (1 .. Analyzer.Pattern_Size / Bytes_Per_Pattern);
      for Stack'Address use Analyzer.Stack_Overlay_Address;
 
   begin
      Analyzer.Topmost_Touched_Mark := Analyzer.Bottom_Pattern_Mark;
 
      if Analyzer.Pattern_Size = 0 then
         return;
      end if;
 
      --  Look backward from the topmost possible end of the marked stack to
      --  the bottom of it. The first index not equals to the patterns marks
      --  the beginning of the used stack.
 
      declare
         Top_Index    : constant Integer := Top_Slot_Index_In (Stack);
         Bottom_Index : constant Integer := Bottom_Slot_Index_In (Stack);
         Step         : constant Integer := Pop_Index_Step_For (Stack);
         J            : Integer;
 
      begin
         J := Top_Index;
         loop
            if Stack (J) /= Analyzer.Pattern then
               Analyzer.Topmost_Touched_Mark
                 := To_Stack_Address (Stack (J)'Address);
               exit;
            end if;
 
            exit when J = Bottom_Index;
            J := J + Step;
         end loop;
      end;
   end Compute_Result;
 
   ---------------------
   -- Get_Usage_Range --
   ---------------------
 
   function Get_Usage_Range (Result : Task_Result) return String is
      Variation_Used_Str : constant String :=
                             Natural'Image (Result.Variation);
      Value_Used_Str     : constant String :=
                             Natural'Image (Result.Value);
   begin
      return Value_Used_Str & " +/- " & Variation_Used_Str;
   end Get_Usage_Range;
 
   ---------------------
   --  Output_Result --
   ---------------------
 
   procedure Output_Result
     (Result_Id          : Natural;
      Result             : Task_Result;
      Max_Stack_Size_Len : Natural;
      Max_Actual_Use_Len : Natural)
   is
      Result_Id_Str     : constant String := Natural'Image (Result_Id);
      My_Stack_Size_Str : constant String := Natural'Image (Result.Max_Size);
      Actual_Use_Str    : constant String := Get_Usage_Range (Result);
 
      Result_Id_Blanks  : constant
        String (1 .. Index_Str'Length - Result_Id_Str'Length)    :=
          (others => ' ');
 
      Stack_Size_Blanks : constant
        String (1 .. Max_Stack_Size_Len - My_Stack_Size_Str'Length) :=
          (others => ' ');
 
      Actual_Use_Blanks : constant
        String (1 .. Max_Actual_Use_Len - Actual_Use_Str'Length) :=
          (others => ' ');
 
   begin
      Set_Output (Standard_Error);
      Put (Result_Id_Blanks & Natural'Image (Result_Id));
      Put (" | ");
      Put (Result.Task_Name);
      Put (" | ");
      Put (Stack_Size_Blanks & My_Stack_Size_Str);
      Put (" | ");
      Put (Actual_Use_Blanks & Actual_Use_Str);
      New_Line;
   end Output_Result;
 
   ---------------------
   --  Output_Results --
   ---------------------
 
   procedure Output_Results is
      Max_Stack_Size                         : Natural := 0;
      Max_Actual_Use_Result_Id               : Natural := Result_Array'First;
      Max_Stack_Size_Len, Max_Actual_Use_Len : Natural := 0;
 
      Task_Name_Blanks : constant
        String (1 .. Task_Name_Length - Task_Name_Str'Length) :=
          (others => ' ');
 
   begin
      Set_Output (Standard_Error);
 
      if Compute_Environment_Task then
         Compute_Result (Environment_Task_Analyzer);
         Report_Result (Environment_Task_Analyzer);
      end if;
 
      if Result_Array'Length > 0 then
 
         --  Computes the size of the largest strings that will get displayed,
         --  in order to do correct column alignment.
 
         for J in Result_Array'Range loop
            exit when J >= Next_Id;
 
            if Result_Array (J).Value >
               Result_Array (Max_Actual_Use_Result_Id).Value
            then
               Max_Actual_Use_Result_Id := J;
            end if;
 
            if Result_Array (J).Max_Size > Max_Stack_Size then
               Max_Stack_Size := Result_Array (J).Max_Size;
            end if;
         end loop;
 
         Max_Stack_Size_Len := Natural'Image (Max_Stack_Size)'Length;
 
         Max_Actual_Use_Len :=
           Get_Usage_Range (Result_Array (Max_Actual_Use_Result_Id))'Length;
 
         --  Display the output header. Blanks will be added in front of the
         --  labels if needed.
 
         declare
            Stack_Size_Blanks  : constant
              String (1 .. Max_Stack_Size_Len - Stack_Size_Str'Length) :=
                (others => ' ');
 
            Stack_Usage_Blanks : constant
              String (1 .. Max_Actual_Use_Len - Actual_Size_Str'Length) :=
                (others => ' ');
 
         begin
            if Stack_Size_Str'Length > Max_Stack_Size_Len then
               Max_Stack_Size_Len := Stack_Size_Str'Length;
            end if;
 
            if Actual_Size_Str'Length > Max_Actual_Use_Len then
               Max_Actual_Use_Len := Actual_Size_Str'Length;
            end if;
 
            Put
              (Index_Str & " | " & Task_Name_Str & Task_Name_Blanks & " | "
               & Stack_Size_Str & Stack_Size_Blanks & " | "
               & Stack_Usage_Blanks & Actual_Size_Str);
         end;
 
         New_Line;
 
         --  Now display the individual results
 
         for J in Result_Array'Range loop
            exit when J >= Next_Id;
            Output_Result
              (J, Result_Array (J), Max_Stack_Size_Len, Max_Actual_Use_Len);
         end loop;
 
      --  Case of no result stored, still display the labels
 
      else
         Put
           (Index_Str & " | " & Task_Name_Str & Task_Name_Blanks & " | "
            & Stack_Size_Str & " | " & Actual_Size_Str);
         New_Line;
      end if;
   end Output_Results;
 
   -------------------
   -- Report_Result --
   -------------------
 
   procedure Report_Result (Analyzer : Stack_Analyzer) is
      Result  : Task_Result :=
                  (Task_Name      => Analyzer.Task_Name,
                   Max_Size       => Analyzer.Stack_Size,
                   Variation    => 0,
                   Value    => 0);
 
      Overflow_Guard : constant Integer :=
        Analyzer.Stack_Size
          - Stack_Size (Analyzer.Top_Pattern_Mark, Analyzer.Bottom_Of_Stack);
      Max, Min : Positive;
 
   begin
      if Analyzer.Pattern_Size = 0 then
 
         --  If we have that result, it means that we didn't do any computation
         --  at all. In other words, we used at least everything (and possibly
         --  more).
 
         Min := Analyzer.Stack_Size - Overflow_Guard;
         Max := Analyzer.Stack_Size;
 
      else
         Min :=
           Stack_Size
             (Analyzer.Topmost_Touched_Mark, Analyzer.Bottom_Of_Stack);
         Max := Min + Overflow_Guard;
      end if;
 
      Result.Value := (Max + Min) / 2;
      Result.Variation := (Max - Min) / 2;
 
      if Analyzer.Result_Id in Result_Array'Range then
 
         --  If the result can be stored, then store it in Result_Array
 
         Result_Array (Analyzer.Result_Id) := Result;
 
      else
         --  If the result cannot be stored, then we display it right away
 
         declare
            Result_Str_Len : constant Natural :=
                               Get_Usage_Range (Result)'Length;
            Size_Str_Len   : constant Natural :=
                               Natural'Image (Analyzer.Stack_Size)'Length;
 
            Max_Stack_Size_Len : Natural;
            Max_Actual_Use_Len : Natural;
 
         begin
            --  Take either the label size or the number image size for the
            --  size of the column "Stack Size".
 
            Max_Stack_Size_Len :=
              (if Size_Str_Len > Stack_Size_Str'Length
               then Size_Str_Len
               else Stack_Size_Str'Length);
 
            --  Take either the label size or the number image size for the
            --  size of the column "Stack Usage".
 
            Max_Actual_Use_Len :=
              (if Result_Str_Len > Actual_Size_Str'Length
               then Result_Str_Len
               else Actual_Size_Str'Length);
 
            Output_Result
              (Analyzer.Result_Id,
               Result,
               Max_Stack_Size_Len,
               Max_Actual_Use_Len);
         end;
      end if;
   end Report_Result;
 
end System.Stack_Usage;