-- --
-- B o d y --
-- --
--- Copyright (C) 2004-2006, Free Software Foundation, Inc. --
+-- Copyright (C) 2004-2007, 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- --
use System.Storage_Elements;
use System;
use System.IO;
-
- procedure Output_Result (Result_Id : Natural; Result : Task_Result);
-
- function Report_Result (Analyzer : Stack_Analyzer) return Natural;
-
- function Inner_Than
+ use Interfaces;
+
+ 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 [min - max]";
+ Pattern_Array_Elem_Size : constant Natural :=
+ (Unsigned_32_Size / Byte_Size);
+
+ 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.
+
+ function Closer_To_Bottom
(A1 : Stack_Address;
A2 : Stack_Address) return Boolean;
- pragma Inline (Inner_Than);
+ pragma Inline (Closer_To_Bottom);
-- Return True if, according to the direction of the stack growth, A1 is
- -- inner than A2. Inlined to reduce the size of the stack used by the
- -- instrumentation code.
+ -- closer to the bottom than A2. Inlined to reduce the size of the stack
+ -- used by the instrumentation code.
- ----------------
- -- Inner_Than --
- ----------------
+ ----------------------
+ -- Closer_To_Bottom --
+ ----------------------
- function Inner_Than
+ function Closer_To_Bottom
(A1 : Stack_Address;
A2 : Stack_Address) return Boolean
is
else
return A2 > A1;
end if;
- end Inner_Than;
+ end Closer_To_Bottom;
----------------
-- Initialize --
----------------
- -- Add comments to this procedure ???
- -- Other subprograms also need more comment in code???
-
procedure Initialize (Buffer_Size : Natural) is
- Bottom_Of_Stack : aliased Integer;
-
+ 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),
- Measure => 0,
- Max_Size => 0));
+ (Task_Name => (others => ASCII.NUL),
+ Measure => 0,
+ Max_Size => 0,
+ Overflow_Guard => 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;
begin
Stack_Size := System.CRTL.atoi (Stack_Size_Chars) * 1024;
- Initialize_Analyzer (Environment_Task_Analyzer,
- "ENVIRONMENT TASK",
- Stack_Size,
- System.Storage_Elements.To_Integer
- (Bottom_Of_Stack'Address));
+ Initialize_Analyzer
+ (Environment_Task_Analyzer,
+ "ENVIRONMENT TASK",
+ Stack_Size,
+ 0,
+ System.Storage_Elements.To_Integer (Bottom_Of_Stack'Address));
Fill_Stack (Environment_Task_Analyzer);
-- big, the more an "instrumentation threshold at writing" error is
-- likely to happen.
- type Word_32_Arr is
- array (1 .. Analyzer.Size / (Word_32_Size / Byte_Size)) of Word_32;
- pragma Pack (Word_32_Arr);
+ type Unsigned_32_Arr is
+ array (1 .. Analyzer.Size / Pattern_Array_Elem_Size) of Unsigned_32;
+ for Unsigned_32_Arr'Component_Size use 32;
package Arr_Addr is
- new System.Address_To_Access_Conversions (Word_32_Arr);
+ new System.Address_To_Access_Conversions (Unsigned_32_Arr);
- Arr : aliased Word_32_Arr;
+ Arr : aliased Unsigned_32_Arr;
begin
- for J in Word_32_Arr'Range loop
+ -- Fill the stack with the pattern
+
+ for J in Unsigned_32_Arr'Range loop
Arr (J) := Analyzer.Pattern;
end loop;
+
+ -- Initialize the analyzer value
+
Analyzer.Array_Address := Arr_Addr.To_Address (Arr'Access);
- Analyzer.Inner_Pattern_Mark := To_Stack_Address (Arr (1)'Address);
- Analyzer.Outer_Pattern_Mark :=
- To_Stack_Address (Arr (Word_32_Arr'Last)'Address);
-
- if Inner_Than (Analyzer.Outer_Pattern_Mark,
- Analyzer.Inner_Pattern_Mark) then
- Analyzer.Inner_Pattern_Mark := Analyzer.Outer_Pattern_Mark;
- Analyzer.Outer_Pattern_Mark := To_Stack_Address (Arr (1)'Address);
- Analyzer.First_Is_Outermost := True;
+ Analyzer.Bottom_Pattern_Mark := To_Stack_Address (Arr (1)'Address);
+ Analyzer.Top_Pattern_Mark :=
+ To_Stack_Address (Arr (Unsigned_32_Arr'Last)'Address);
+
+ if
+ Closer_To_Bottom
+ (Analyzer.Top_Pattern_Mark, Analyzer.Bottom_Pattern_Mark)
+ then
+ Analyzer.Bottom_Pattern_Mark := Analyzer.Top_Pattern_Mark;
+ Analyzer.Top_Pattern_Mark := To_Stack_Address (Arr (1)'Address);
+ Analyzer.First_Is_Topmost := True;
else
- Analyzer.First_Is_Outermost := False;
+ Analyzer.First_Is_Topmost := False;
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.Size =
Stack_Size
- (Analyzer.Outer_Pattern_Mark, Analyzer.Inner_Pattern_Mark) +
- Word_32_Size / Byte_Size);
+ (Analyzer.Top_Pattern_Mark, Analyzer.Bottom_Pattern_Mark));
end Fill_Stack;
-------------------------
-------------------------
procedure Initialize_Analyzer
- (Analyzer : in out Stack_Analyzer;
- Task_Name : String;
- Size : Natural;
- Bottom : Stack_Address;
- Pattern : Word_32 := 16#DEAD_BEEF#)
+ (Analyzer : in out Stack_Analyzer;
+ Task_Name : String;
+ Size : Natural;
+ Overflow_Guard : Natural;
+ Bottom : Stack_Address;
+ Pattern : Unsigned_32 := 16#DEAD_BEEF#)
is
begin
+ -- Initialize the analyzer fields
+
Analyzer.Bottom_Of_Stack := Bottom;
Analyzer.Size := Size;
Analyzer.Pattern := Pattern;
Analyzer.Task_Name := (others => ' ');
+ -- Compute the task name, and truncate it if it's bigger than
+ -- Task_Name_Length
+
if Task_Name'Length <= Task_Name_Length then
Analyzer.Task_Name (1 .. Task_Name'Length) := Task_Name;
else
Task_Name'First + Task_Name_Length - 1);
end if;
- if Next_Id in Result_Array'Range then
- Result_Array (Analyzer.Result_Id).Task_Name := Analyzer.Task_Name;
- end if;
+ Analyzer.Overflow_Guard := Overflow_Guard;
- Result_Array (Analyzer.Result_Id).Max_Size := Size;
Next_Id := Next_Id + 1;
end Initialize_Analyzer;
-- is, the more an "instrumentation threshold at reading" error is
-- likely to happen.
- type Word_32_Arr is
- array (1 .. Analyzer.Size / (Word_32_Size / Byte_Size)) of Word_32;
- pragma Pack (Word_32_Arr);
+ type Unsigned_32_Arr is
+ array (1 .. Analyzer.Size / Pattern_Array_Elem_Size) of Unsigned_32;
+ for Unsigned_32_Arr'Component_Size use 32;
package Arr_Addr is
- new System.Address_To_Access_Conversions (Word_32_Arr);
+ new System.Address_To_Access_Conversions (Unsigned_32_Arr);
Arr_Access : Arr_Addr.Object_Pointer;
begin
Arr_Access := Arr_Addr.To_Pointer (Analyzer.Array_Address);
- Analyzer.Outermost_Touched_Mark := Analyzer.Inner_Pattern_Mark;
+ Analyzer.Topmost_Touched_Mark := Analyzer.Bottom_Pattern_Mark;
+
+ -- Look backward from the end of the stack to the beginning. The first
+ -- index not equals to the patterns marks the beginning of the used
+ -- stack.
- for J in Word_32_Arr'Range loop
+ for J in Unsigned_32_Arr'Range loop
if Arr_Access (J) /= Analyzer.Pattern then
- Analyzer.Outermost_Touched_Mark :=
+ Analyzer.Topmost_Touched_Mark :=
To_Stack_Address (Arr_Access (J)'Address);
- if Analyzer.First_Is_Outermost then
+ if Analyzer.First_Is_Topmost then
exit;
end if;
end if;
end loop;
end Compute_Result;
+ ---------------------
+ -- Get_Usage_Range --
+ ---------------------
+
+ function Get_Usage_Range (Result : Task_Result) return String is
+ Min_Used_Str : constant String :=
+ Natural'Image (Result.Measure);
+ Max_Used_Str : constant String :=
+ Natural'Image (Result.Measure + Result.Overflow_Guard);
+ begin
+ return "[" & Min_Used_Str (2 .. Min_Used_Str'Last) & " -"
+ & Max_Used_Str & "]";
+ end Get_Usage_Range;
+
---------------------
-- Output_Result --
---------------------
- procedure Output_Result (Result_Id : Natural; Result : Task_Result) is
+ 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);
+ 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 - 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 (Natural'Image (Result_Id));
+ Put (Result_Id_Blanks & Natural'Image (Result_Id));
Put (" | ");
Put (Result.Task_Name);
Put (" | ");
- Put (Natural'Image (Result.Max_Size));
+ Put (Stack_Size_Blanks & Stack_Size_Str);
Put (" | ");
- Put (Natural'Image (Result.Measure));
+ Put (Actual_Use_Blanks & Actual_Use_Str);
New_Line;
end Output_Result;
---------------------
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;
- Set_Output (Standard_Error);
- Put ("Index | Task Name | Stack Size | Actual Use");
- New_Line;
+ 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;
+ for J in Result_Array'Range loop
+ exit when J >= Next_Id;
- Output_Result (J, Result_Array (J));
- end loop;
+ if Result_Array (J).Measure
+ > Result_Array (Max_Actual_Use_Result_Id).Measure
+ 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;
+ else
+ -- If there are no result stored, we'll still display the labels
+
+ Put
+ (Index_Str & " | " & Task_Name_Str & Task_Name_Blanks & " | "
+ & Stack_Size_Str & " | " & Actual_Size_Str);
+ New_Line;
+ end if;
end Output_Results;
-------------------
-------------------
procedure Report_Result (Analyzer : Stack_Analyzer) is
+ Result : constant Task_Result :=
+ (Task_Name => Analyzer.Task_Name,
+ Max_Size => Analyzer.Size + Analyzer.Overflow_Guard,
+ Measure => Stack_Size
+ (Analyzer.Topmost_Touched_Mark,
+ Analyzer.Bottom_Of_Stack),
+ Overflow_Guard => Analyzer.Overflow_Guard -
+ Natural (Analyzer.Bottom_Of_Stack -
+ Analyzer.Bottom_Pattern_Mark));
begin
if Analyzer.Result_Id in Result_Array'Range then
- Result_Array (Analyzer.Result_Id).Measure := Report_Result (Analyzer);
- else
- Output_Result
- (Analyzer.Result_Id,
- (Task_Name => Analyzer.Task_Name,
- Max_Size => Analyzer.Size,
- Measure => Report_Result (Analyzer)));
- end if;
- end Report_Result;
- function Report_Result (Analyzer : Stack_Analyzer) return Natural is
- begin
- if Analyzer.Outermost_Touched_Mark = Analyzer.Inner_Pattern_Mark then
- return Stack_Size (Analyzer.Inner_Pattern_Mark,
- Analyzer.Bottom_Of_Stack);
+ -- If the result can be stored, then store it in Result_Array
+
+ Result_Array (Analyzer.Result_Id) := Result;
else
- return Stack_Size (Analyzer.Outermost_Touched_Mark,
- Analyzer.Bottom_Of_Stack);
+
+ -- 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.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".
+
+ if Size_Str_Len > Stack_Size_Str'Length then
+ Max_Stack_Size_Len := Size_Str_Len;
+ else
+ Max_Stack_Size_Len := Stack_Size_Str'Length;
+ end if;
+
+ -- Take either the label size or the number image size for the
+ -- size of the column "Stack Usage"
+
+ if Result_Str_Len > Actual_Size_Str'Length then
+ Max_Actual_Use_Len := Result_Str_Len;
+ else
+ Max_Actual_Use_Len := Actual_Size_Str'Length;
+ end if;
+
+ Output_Result
+ (Analyzer.Result_Id,
+ Result,
+ Max_Stack_Size_Len,
+ Max_Actual_Use_Len);
+ end;
end if;
end Report_Result;
-- --
-- S p e c --
-- --
--- Copyright (C) 2004-2005, Free Software Foundation, Inc. --
+-- Copyright (C) 2004-2007, 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- --
with System;
with System.Storage_Elements;
with System.Address_To_Access_Conversions;
+with Interfaces;
package System.Stack_Usage is
pragma Preelaborate;
package SSE renames System.Storage_Elements;
Byte_Size : constant := 8;
- Word_32_Size : constant := 4 * Byte_Size;
+ Unsigned_32_Size : constant := 4 * Byte_Size;
- type Word_32 is mod 2 ** Word_32_Size;
- for Word_32'Alignment use 4;
+ -- The alignment clause seems dubious, what about architectures where
+ -- the maximum alignment is less than 4???
+ -- Anyway, why not use Interfaces.Unsigned_32???
subtype Stack_Address is SSE.Integer_Address;
-- Address on the stack
- --
- -- Note: in this package, when comparing two addresses on the stack, the
- -- comments use the terms "outer", "inner", "outermost" and "innermost"
- -- instead of the ambigous "higher", "lower", "highest" and "lowest".
- -- "inner" means "closer to the bottom of stack" and is the contrary of
- -- "outer". "innermost" means "closest address to the bottom of stack". The
- -- stack is growing from the inner to the outer.
-
- -- Top/Bottom would be much better than inner and outer ???
- function To_Stack_Address (Value : System.Address) return Stack_Address
- renames System.Storage_Elements.To_Integer;
+ function To_Stack_Address
+ (Value : System.Address) return Stack_Address
+ renames System.Storage_Elements.To_Integer;
type Stack_Analyzer is private;
-- Type of the stack analyzer tool. It is used to fill a portion of
-- Initialize_Analyzer (A,
-- "Task t",
-- A_Storage_Size - A_Guard,
+ -- A_Guard
-- To_Stack_Address (Bottom_Of_Stack'Address));
-- Fill_Stack (A);
-- Some_User_Code;
-- Pattern zone overflow:
- -- Description: The stack grows outer than the outermost bound of the
- -- pattern zone. In that case, the outermost region modified in the
+ -- Description: The stack grows outer than the topmost bound of the
+ -- pattern zone. In that case, the topmost region modified in the
-- pattern is not the maximum value of the stack pointer during the
-- execution.
-- Strategy: At the end of the execution, the difference between the
- -- outermost memory region modified in the pattern zone and the
- -- outermost bound of the pattern zone can be understood as the
+ -- topmost memory region modified in the pattern zone and the
+ -- topmost bound of the pattern zone can be understood as the
-- biggest allocation that the method could have detect, provided
-- that there is no "Untouched allocated zone" error and no "Pattern
-- usage in user code" error. If no object in the user code is likely
-- changes the measure. Note that this error *very* rarely influence
-- the measure of the total stack usage: to have some influence, the
-- pattern has to be used in the object that has been allocated on the
- -- outermost address of the used stack.
+ -- topmost address of the used stack.
-- Stack overflow:
-- error is really rare, and it is most probably a bug in the user
-- code, e.g. some uninitialized variable. It is (most of the time)
-- harmless: it influences the measure only if the untouched allocated
- -- zone happens to be located at the outermost value of the stack
+ -- zone happens to be located at the topmost value of the stack
-- pointer for the whole execution.
procedure Initialize (Buffer_Size : Natural);
-- | the end of the call) | |
-- ^ | |
-- Analyzer.Bottom_Of_Stack ^ |
- -- Analyzer.Inner_Pattern_Mark ^
- -- Analyzer.Outer_Pattern_Mark
+ -- Analyzer.Bottom_Pattern_Mark ^
+ -- Analyzer.Top_Pattern_Mark
procedure Initialize_Analyzer
- (Analyzer : in out Stack_Analyzer;
- Task_Name : String;
- Size : Natural;
- Bottom : Stack_Address;
- Pattern : Word_32 := 16#DEAD_BEEF#);
+ (Analyzer : in out Stack_Analyzer;
+ Task_Name : String;
+ Size : Natural;
+ Overflow_Guard : Natural;
+ Bottom : Stack_Address;
+ Pattern : Interfaces.Unsigned_32 := 16#DEAD_BEEF#);
-- Should be called before any use of a Stack_Analyzer, to initialize it.
-- Size is the size of the pattern zone. Bottom should be a close
-- approximation of the caller base frame address.
procedure Compute_Result (Analyzer : in out Stack_Analyzer);
-- Read the patern zone and deduce the stack usage. It should be called
-- from the same frame as Fill_Stack. If Analyzer.Probe is not null, an
- -- array of Word_32 with Analyzer.Probe elements is allocated on
+ -- array of Unsigned_32 with Analyzer.Probe elements is allocated on
-- Compute_Result's stack frame. Probe can be used to detect the error:
-- "instrumentation threshold at reading". See above. After the call
-- to this procedure, the memory will look like:
-- | (deallocated at | elements | the | with |
-- | the end of the call) | | execution | pattern |
-- | ^ | | |
- -- | Inner_Pattern_Mark | | |
+ -- | Bottom_Pattern_Mark | | |
-- | | |
-- |<----------------------------------------------------> |
-- Stack used ^
- -- Outer_Pattern_Mark
+ -- Top_Pattern_Mark
procedure Report_Result (Analyzer : Stack_Analyzer);
-- Store the results of the computation in memory, at the address
private
Task_Name_Length : constant := 32;
+ -- The maximum length of task name displayed.
+ -- ??? Consider merging this variable with Max_Task_Image_Length.
- package Word_32_Addr is
- new System.Address_To_Access_Conversions (Word_32);
+ package Unsigned_32_Addr is
+ new System.Address_To_Access_Conversions (Interfaces.Unsigned_32);
type Stack_Analyzer is record
Task_Name : String (1 .. Task_Name_Length);
Size : Natural;
-- Size of the pattern zone
- Pattern : Word_32;
+ Pattern : Interfaces.Unsigned_32;
-- Pattern used to recognize untouched memory
- Inner_Pattern_Mark : Stack_Address;
- -- Innermost bound of the pattern area on the stack
+ Bottom_Pattern_Mark : Stack_Address;
+ -- Bound of the pattern area on the stack clostest to the bottom
- Outer_Pattern_Mark : Stack_Address;
- -- Outermost bound of the pattern area on the stack
+ Top_Pattern_Mark : Stack_Address;
+ -- Topmost bound of the pattern area on the stack
- Outermost_Touched_Mark : Stack_Address;
- -- Outermost address of the pattern area whose value it is pointing
+ Topmost_Touched_Mark : Stack_Address;
+ -- Topmost address of the pattern area whose value it is pointing
-- at has been modified during execution. If the systematic error are
- -- compensated, it is the outermost value of the stack pointer during
+ -- compensated, it is the topmost value of the stack pointer during
-- the execution.
Bottom_Of_Stack : Stack_Address;
-- Initialize_Analyzer.
Array_Address : System.Address;
- -- Address of the array of Word_32 that represents the pattern zone
+ -- Address of the array of Unsigned_32 that represents the pattern zone
- First_Is_Outermost : Boolean;
- -- Set to true if the first element of the array of Word_32 that
- -- represents the pattern zone is at the outermost address of the
- -- pattern zone; false if it is the innermost address.
+ First_Is_Topmost : Boolean;
+ -- Set to true if the first element of the array of Unsigned_32 that
+ -- represents the pattern zone is at the topmost address of the
+ -- pattern zone; false if it is the bottommost address.
Result_Id : Positive;
-- Id of the result. If less than value given to gnatbind -u corresponds
-- to the location in the result array of result for the current task.
+
+ Overflow_Guard : Natural;
+ -- The amount of bytes that won't be analyzed in order to prevent
+ -- writing out of the stack
end record;
Environment_Task_Analyzer : Stack_Analyzer;
Compute_Environment_Task : Boolean;
type Task_Result is record
- Task_Name : String (1 .. Task_Name_Length);
- Measure : Natural;
- Max_Size : Natural;
+ Task_Name : String (1 .. Task_Name_Length);
+ Measure : Natural;
+ Max_Size : Natural;
+ Overflow_Guard : Natural;
end record;
type Result_Array_Type is array (Positive range <>) of Task_Result;
projects / gcc.git / commitdiff