DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download

⟦aea8be768⟧ Ada Source

    Length: 29696 (0x7400)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, package V_I_Trace, seg_04ce1d

Derivation

└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
    └─ ⟦cfc2e13cd⟧ »Space Info Vol 2« 
        └─⟦this⟧ 

E3 Source Code



with System;
with Unchecked_Conversion;
with Unsigned_Types;
with V_I_Krn_Trace;
with V_I_Types;
use V_I_Types;

package V_I_Trace is

    pragma Suppress (All_Checks);
    pragma Suppress (Exception_Tables);
    pragma Not_Elaborated;
    pragma Local_Access;

    subtype Address_Sized_Type is V_I_Krn_Trace.Address_Sized_Type;
    subtype Microseconds is V_I_Types.Universal_Scalar;
    type Byte is range 0 .. 255;
    for Byte'Size use 8;

----------------------------------------------------------------------------
--  Help in logging arguments.
    function To_A is new Unchecked_Conversion
                            (Address_Sized_Type, System.Address);
    function To_Us is new Unchecked_Conversion
                             (System.Address, Address_Sized_Type);
    function To_Us is new Unchecked_Conversion (Duration, Address_Sized_Type);
    function To_Us is new Unchecked_Conversion (Integer, Address_Sized_Type);

    function From_Us is new Unchecked_Conversion
                               (Address_Sized_Type, System.Address);
    function From_Us is new Unchecked_Conversion (Address_Sized_Type, Duration);
    function From_Us is new Unchecked_Conversion (Address_Sized_Type, Integer);

    Zero : constant Address_Sized_Type := V_I_Krn_Trace.Zero;
----------------------------------------------------------------------------

-- Services needed by the Event_Log_Manager for the user and the
-- logging of runtime events by the kernel

    type Kind_Of_Event is (No_Event, Header_Event, Runtime_Event,
                           User_Defined_Event, User_Defined_Integer_Event,
                           Kernel_Event, Profile_Event);

    -- Event Logging Operations

    type User_Events is
       (Start_Of_Sequence,
        Start_Process,              -- Application initiates a process
        End_Process,                -- Task completes a process
        Start_Buffer_Flush,         -- Automatic, when full or at user request
        End_Buffer_Flush,
        Process_Base_Time,          -- Process established base time
        Event1, Event1a, Event2, Event2a, Event3, Event3a, Event4,
        Event4a, Event5, Event5a, Event6, Event6a, Event7, Event7a,
        Event8, Event8a, Event9, Event9a, Event10, Event10a, No_Event);

    type Runtime_Events is
       (Task_Creation_Begin,  
        Task_Creation_End, Simple_Entry_Call_Req, Simple_Entry_Call_End,
        Timed_Entry_Call_Req, Timed_Entry_Call_End, Timed_Entry_Call_Timeout,
        Cond_Entry_Call_Req, Cond_Entry_Call_End, Simple_Accept_Req,
        Simple_Accept_End, Select_Req, Select_Else_Req, Select_Delay_Req,
        Select_Terminate_Req, Select_End, Select_Else_End,
        Select_Delay_End, Select_Terminate_End, Delay_Req, Delay_Expired,
        Continue_From_Delay, Delay_Until_Req, Delay_Until_Expired,
        Continue_From_Delay_Until, Rte_Exception, Raise_Req,
        Exception_Handler, Task_Begin_Req, Task_Begin_Begin,
        Task_Terminate_Req, Task_Terminate, Task_Abort_Req, Task_Abort,

        Task_Semaphore_Wait, Task_Semaphore_Wait_Complete,
        Task_Semaphore_Wait_Timeout, Task_Semaphore_Signal,

        Memory_Allocate,  
        Memory_Deallocate,

        -- Non-threaded run-time scheduling events
        Switch_To,  
        Switch_To_Idle_Task, Switch_To_Rendezvous_In_Called,

        -- Threaded run-time scheduling events
        Kernel_Signal,  
        Kernel_Wait, Kernel_Wait_Complete, Kernel_Signal_Wait,
        Kernel_Signal_Wait_Complete, Kernel_Timed_Wait,
        Kernel_Timed_Wait_Complete, Kernel_Timed_Wait_Timeout,

        Interrupt_Entry, Interrupt_Exit,

        Set_Priority, Reevaluate_Priority, Ceiling_Set_Priority,

        Cache_Flush,

        -- Passive tasks
        Passive_Task_Enter, Passive_Task_Leave, Passive_Task_Cond_Enter,
        Passive_Task_Cond_Fail, Passive_Task_Timed_Enter,
        Passive_Task_Timed_Timeout, Passive_Ceiling_Set_Priority,

        Breakpoint,       -- Inserted by a.db to explain large time gap

        Da_First,          -- marker: FIRST DA event

        -- Distributed Ada           -- TYPE           SIDE   START/END
        Da_First_Parent_Sur,         -- marker:  FIRST parent-sur event
        Da_Simple_Entry_Req,         -- simple entry   parent     start
        Da_Simple_Entry_End,         -- simple entry   parent     end
        Da_Conditional_Entry_Req,    -- cond entry     parent     start
        Da_Conditional_Entry_End,    -- cond entry     parent     end
        Da_Timed_Entry_Req,          -- timed entry    parent     start
        Da_Timed_Entry_End,          -- timed entry    parent     end
        Da_Simple_Entry_Sur_Req,     -- simple entry   sur        start
        Da_Simple_Entry_Sur_End,     -- simple entry   sur        end
        Da_Conditional_Entry_Sur_Req,-- cond entry     sur        start
        Da_Conditional_Entry_Sur_End,-- cond entry     sur        end
        Da_Timed_Entry_Sur_Req,      -- timed entry    sur        start
        Da_Timed_Entry_Sur_End,      -- timed entry    sur        end
        Da_Dt_Read_Req,              -- read           parent     start
        Da_Dt_Read_End,              -- read           parent     end
        Da_Dt_Write_Req,             -- write          parent     start
        Da_Dt_Write_End,             -- write          parent     end
        Da_Stub_Read_Req,            -- read           sur        start
        Da_Stub_Read_End,            -- read           sur        end
        Da_Stub_Write_Req,           -- write          sur        start
        Da_Stub_Write_End,           -- write          sur        end
        Da_Rem_Subp_Req,             -- rpc            parent     start
        Da_Rem_Subp_End,             -- rpc            parent     end
        Da_Rem_Subp_Sur_Req,         -- rpc            sur        start
        Da_Rem_Subp_Sur_End,         -- rpc            sur        end
        Da_Last_Parent_Sur,          -- marker: LAST   parent-sur event

        -- non-parent-sur da events
        Da_Local_New_Req, Da_Global_Free_Req, Da_Local_Free_Req,
        Da_Station_Info, Da_Task_Activated_As_Sur,
        Da_Last    -- marker: LAST DA event

        );

    type Profile_Events is (Calls, Returns, Basic_Block, Exceptions,
                            Interrupts, Cache_Flushes, Operand_Changed_Address,
                            Operand_Changed_Value, Program_Generated_Value);

    type Runtime_Enables is array (Runtime_Events) of Boolean;

    Log_String_Size : constant Integer :=
       Address_Sized_Type'Size * 4 / Character'Size;
    subtype Log_String is String (1 .. Log_String_Size);

    --
    -- Raw event used in log routine
    type Event is
        record
            Logged_Event : Kind_Of_Event;
            Node : Integer;  
            Task_Seqnum : Integer;  
            Time_Stamp : Microseconds;
            Arg1 : Address_Sized_Type;  
            Arg2 : Address_Sized_Type;  
            Arg3 : Address_Sized_Type;  
            Arg4 : Address_Sized_Type;  
        end record;
    Event_Size : constant Integer := Event'Size;

    -- The use of variant records leads to problems when programs that do not
    -- explicitly with v_i_trace are linked with an instrumented run-time.
    -- These are the variants
    type Header_Event_Record is
        record
            Logged_Event : Kind_Of_Event;
            Priority : Byte;
            Node : Integer;  
            Task_Seqnum : Integer;  
            Time_Stamp : Microseconds;
            Task_Name : Address_Sized_Type;
            Phase : Address_Sized_Type;  
            Period : Address_Sized_Type;
            Execution_Time : Microseconds;
        end record;
    -- On some systems, duration is 64 bits. Phase and period are converted.
    --for header_event_record'size use event_size;
    function To_Event is new Unchecked_Conversion (Header_Event_Record, Event);
    function To_Header_Event is new Unchecked_Conversion
                                       (Event, Header_Event_Record);

    type Runtime_Event_Record is
        record
            Logged_Event : Kind_Of_Event;
            Rts_Event : Runtime_Events;
            Node : Integer;  
            Task_Seqnum : Integer;  
            Time_Stamp : Microseconds;
            Arg1 : Address_Sized_Type;  
            Arg2 : Address_Sized_Type;  
            Arg3 : Address_Sized_Type;  
            Arg4 : Address_Sized_Type;  
        end record;
    --for runtime_event_record'size use event_size;
    function To_Event is new Unchecked_Conversion (Runtime_Event_Record, Event);
    function To_Runtime_Event is new Unchecked_Conversion
                                        (Event, Runtime_Event_Record);

    type Kernel_Event_Record is
        record
            Logged_Event : Kind_Of_Event;
            Krn_Event : Byte;
            Node : Integer;  
            Task_Seqnum : Integer;  
            Time_Stamp : Microseconds;
            Arg1 : Address_Sized_Type;  
            Arg2 : Address_Sized_Type;  
            Arg3 : Address_Sized_Type;  
            Arg4 : Address_Sized_Type;  
        end record;
    --for kernel_event_record'size use event_size;
    function To_Event is new Unchecked_Conversion (Kernel_Event_Record, Event);
    function To_Kernel_Event is new Unchecked_Conversion
                                       (Event, Kernel_Event_Record);

    type User_Event_Record is
        record
            Logged_Event : Kind_Of_Event;
            User_Event : User_Events;
            Node : Integer;  
            Task_Seqnum : Integer;  
            Time_Stamp : Microseconds;
            Comment : Log_String;
        end record;
    --for user_event_record'size use event_size;
    function To_Event is new Unchecked_Conversion (User_Event_Record, Event);
    function To_User_Event is new Unchecked_Conversion
                                     (Event, User_Event_Record);
    type User_Int_Event_Record is
        record
            Logged_Event : Kind_Of_Event;
            User_Event : User_Events;
            Node : Integer;  
            Task_Seqnum : Integer;  
            Time_Stamp : Microseconds;
            P1 : Address_Sized_Type;
            P2 : Address_Sized_Type;
            P3 : Address_Sized_Type;
            P4 : Address_Sized_Type;
        end record;
    --for user_int_event_record'size use event_size;
    function To_Event is new Unchecked_Conversion
                                (User_Int_Event_Record, Event);
    function To_User_Int_Event is new Unchecked_Conversion
                                         (Event, User_Int_Event_Record);

    type Profile_Event_Record is
        record
            Logged_Event : Kind_Of_Event;
            Prof_Event : Profile_Events;
            Node : Integer;  
            Task_Seqnum : Integer;  
            Time_Stamp : Microseconds;
            Location : Address_Sized_Type;
            Word1 : Address_Sized_Type;
            Word2 : Address_Sized_Type;
            Word3 : Address_Sized_Type;
        end record;
    --for profile_event_record'size use event_size;
    function To_Event is new Unchecked_Conversion (Profile_Event_Record, Event);
    function To_Profile_Event is new Unchecked_Conversion
                                        (Event, Profile_Event_Record);

    Event_Record_Size : Integer;
    pragma Interface_Name (Event_Record_Size, "__V_I_TRACE_EVENT_RECORD_SIZE");
    --
    Auto_Trace : Boolean;
    pragma Interface_Name (Auto_Trace, "__V_I_TRACE_AUTO_TRACE");
    --
    Runtime_Log : Runtime_Enables;
    pragma Interface_Name (Runtime_Log, "__V_I_TRACE_RUNTIME_LOG");
    Runtime_Setup : Runtime_Enables;

    -- Deliberately using constrained array. Allows use of
    -- unchecked_conversion from address to pointer and back. (Vads
    -- specific)
    pragma Warnings (Off);
    type Event_Buffer_T is array (Positive) of V_I_Trace.Event;
    type A_Event_Buffer_T is access Event_Buffer_T;
    pragma Warnings (On);
    Event_Buffer : A_Event_Buffer_T;
    Event_Buffer_Size : Integer; -- 4096 Default unless overridden by user
    Event_Buffer_Index : Integer;

    pragma Interface_Name (Event_Buffer, "__V_I_TRACE_EVENT_BUFFER");
    pragma Interface_Name (Event_Buffer_Size,  
                           "__V_I_TRACE_EVENT_BUFFER_SIZE");
    pragma Interface_Name (Event_Buffer_Index,
                           "__V_I_TRACE_EVENT_BUFFER_INDEX");


    Wrap_Around : Boolean;
    Log_Overflowed : Boolean;
    Disable_Locking : Boolean;
    Hardware_Logging : Boolean;
    pragma Interface_Name (Wrap_Around, "__V_I_TRACE_WRAP_AROUND");
    pragma Interface_Name (Log_Overflowed, "__V_I_TRACE_LOG_OVERFLOWED");
    pragma Interface_Name (Disable_Locking, "__V_I_TRACE_DISABLE_LOCKING");
    pragma Interface_Name (Hardware_Logging, "__V_I_TRACE_HARDWARE_LOGGING");

    -- We can't call system services in preemption callout.
    -- Unless the user supplies a get_time callout, we will log using the
    -- last event's time. Only a problem in MP Ada.
    Last_Secs : Microseconds;
    pragma Interface_Name (Last_Secs, "__V_I_TRACE_LAST_SECS");

    type A_Boolean is access Boolean;
    type A_Integer is access Integer;
    type A_Uinteger is access Unsigned_Types.Unsigned_Integer;

    type Trace_Configuration_T is
        record
            -- User configurable
            Runtime_Log : Runtime_Enables;
            Event_Buffer_Size : Integer;          -- number of records
            Event_Buffer : A_Event_Buffer_T; -- null is don't care
            Wrap_Around : Boolean;
            Hardware_Logging : Boolean;
            Disable_Locking : Boolean;  -- single processor,
                                        -- not logging interrupts
            Nearly_Full_Callout : System.Address;  -- no_addr is don't care
            Nearly_Full_Index : Integer;

            Get_Time_Callout : System.Address;  -- used in user code and
                                                -- task services
            Krn_Get_Time_Callout : System.Address;  -- callable from kernel
            Log_Callout : System.Address;

            Krn_Log_Enables : V_I_Krn_Trace.Kernel_Enables;

            -- Should not be modified by user
            -- Communication with kernel on cross systems
            Event_Buffer_Index : A_Integer;  
            Log_Overflowed : A_Boolean;
            Init_Logging_Address : System.Address;
            Hardware_Logging_1 : A_Uinteger;
            Hardware_Logging_2 : A_Uinteger;
            Hardware_Logging_3 : A_Uinteger;
            Hardware_Logging_4 : A_Uinteger;
        end record;
    type A_Trace_Configuration_T is access Trace_Configuration_T;

    type Arg_Type is (Arg_Tsn, Arg_Tsa, Arg_Ra, Arg_Pc, Arg_Time,
                      Arg_Entry, Arg_Priority, Arg_Exid, Arg_Sema,
                      Arg_Boolean, Arg_Integer, Arg_Address, Arg_Size,
                      Arg_Intid, Arg_Status, Arg_Cause, -- MIPS registers
                      Arg_Station, Arg_Seq,  -- for DA
                      Arg_Id, Arg_Value, Arg_Null);

    type Arg_Descriptor is
        record
            Arg1_Type : Arg_Type;
            Arg2_Type : Arg_Type;
            Arg3_Type : Arg_Type;
            Arg4_Type : Arg_Type;
        end record;


    Arg_Descriptors : array (Runtime_Events) of Arg_Descriptor :=
       (Task_Creation_Begin => (Arg_Priority, Arg_Ra, Arg_Null, Arg_Null),
        Task_Creation_End => (Arg_Tsn, Arg_Ra, Arg_Tsa, Arg_Null),
        Simple_Entry_Call_Req => (Arg_Tsn, Arg_Entry, Arg_Ra, Arg_Null),
        Simple_Entry_Call_End => (Arg_Tsn, Arg_Tsa, Arg_Null, Arg_Null),
        Timed_Entry_Call_Req => (Arg_Tsn, Arg_Entry, Arg_Ra, Arg_Null),
        Timed_Entry_Call_End => (Arg_Tsn, Arg_Boolean, Arg_Tsa, Arg_Null),
        Timed_Entry_Call_Timeout => (Arg_Null, Arg_Null, Arg_Null, Arg_Null),
        Cond_Entry_Call_Req => (Arg_Tsn, Arg_Entry, Arg_Ra, Arg_Null),
        Cond_Entry_Call_End => (Arg_Tsn, Arg_Boolean, Arg_Tsa, Arg_Null),
        Simple_Accept_Req => (Arg_Entry, Arg_Ra, Arg_Null, Arg_Null),
        Simple_Accept_End => (Arg_Ra, Arg_Tsa, Arg_Null, Arg_Null),
        Select_Req => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Select_Else_Req => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Select_Delay_Req => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Select_Terminate_Req => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Select_End => (Arg_Entry, Arg_Null, Arg_Null, Arg_Null),
        Select_Else_End => (Arg_Entry, Arg_Null, Arg_Null, Arg_Null),
        Select_Delay_End => (Arg_Entry, Arg_Null, Arg_Null, Arg_Null),
        Select_Terminate_End => (Arg_Entry, Arg_Null, Arg_Null, Arg_Null),
        Delay_Req => (Arg_Ra, Arg_Time, Arg_Null, Arg_Null),
        Delay_Expired => (Arg_Null, Arg_Null, Arg_Null, Arg_Null),
        Continue_From_Delay => (Arg_Tsa, Arg_Null, Arg_Null, Arg_Null),
        Delay_Until_Req => (Arg_Ra, Arg_Time, Arg_Null, Arg_Null),
        Delay_Until_Expired => (Arg_Null, Arg_Null, Arg_Null, Arg_Null),
        Continue_From_Delay_Until => (Arg_Tsa, Arg_Null, Arg_Null, Arg_Null),
        Rte_Exception => (Arg_Exid, Arg_Ra, Arg_Null, Arg_Null),
        Raise_Req => (Arg_Exid, Arg_Ra, Arg_Null, Arg_Null),
        Exception_Handler => (Arg_Exid, Arg_Pc, Arg_Null, Arg_Null),
        Task_Begin_Req => (Arg_Tsn, Arg_Ra, Arg_Null, Arg_Null),
        Task_Begin_Begin => (Arg_Tsn, Arg_Tsn, Arg_Null, Arg_Null),
        Task_Terminate_Req => (Arg_Tsn, Arg_Ra, Arg_Null, Arg_Null),
        Task_Terminate => (Arg_Null, Arg_Null, Arg_Null, Arg_Null),
        Task_Abort_Req => (Arg_Tsn, Arg_Ra, Arg_Null, Arg_Null),
        Task_Abort => (Arg_Tsn, Arg_Null, Arg_Null, Arg_Null),

        Task_Semaphore_Wait => (Arg_Sema, Arg_Time, Arg_Null, Arg_Null),
        Task_Semaphore_Wait_Complete =>
           (Arg_Sema, Arg_Null, Arg_Null, Arg_Null),
        Task_Semaphore_Wait_Timeout => (Arg_Sema, Arg_Null, Arg_Null, Arg_Null),
        Task_Semaphore_Signal => (Arg_Sema, Arg_Null, Arg_Null, Arg_Null),

        Memory_Allocate => (Arg_Address, Arg_Size, Arg_Ra, Arg_Null),
        Memory_Deallocate => (Arg_Address, Arg_Ra, Arg_Null, Arg_Null),

        Switch_To => (Arg_Tsn, Arg_Null, Arg_Null, Arg_Null),  
        Switch_To_Idle_Task => (Arg_Null, Arg_Null, Arg_Null, Arg_Null),
        Switch_To_Rendezvous_In_Called =>
           (Arg_Tsn, Arg_Tsa, Arg_Null, Arg_Null),

        Kernel_Signal => (Arg_Tsn, Arg_Null, Arg_Null, Arg_Null),  
        Kernel_Wait => (Arg_Tsn, Arg_Null, Arg_Null, Arg_Null),
        Kernel_Wait_Complete => (Arg_Tsn, Arg_Null, Arg_Null, Arg_Null),
        Kernel_Signal_Wait => (Arg_Tsn, Arg_Null, Arg_Null, Arg_Null),
        Kernel_Signal_Wait_Complete => (Arg_Tsn, Arg_Null, Arg_Null, Arg_Null),
        Kernel_Timed_Wait => (Arg_Tsn, Arg_Time, Arg_Null, Arg_Null),
        Kernel_Timed_Wait_Complete => (Arg_Tsn, Arg_Null, Arg_Null, Arg_Null),
        Kernel_Timed_Wait_Timeout => (Arg_Tsn, Arg_Null, Arg_Null, Arg_Null),

        Interrupt_Entry => (Arg_Intid, Arg_Pc, Arg_Status, Arg_Cause),
        Interrupt_Exit => (Arg_Intid, Arg_Pc, Arg_Null, Arg_Null),

        Set_Priority => (Arg_Tsn, Arg_Priority, Arg_Null, Arg_Null),
        Reevaluate_Priority => (Arg_Tsn, Arg_Priority, Arg_Null, Arg_Null),
        Ceiling_Set_Priority => (Arg_Tsn, Arg_Priority, Arg_Null, Arg_Null),

        Cache_Flush => (Arg_Ra, Arg_Address, Arg_Size, Arg_Integer),

        Passive_Task_Enter => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Passive_Task_Leave => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Passive_Task_Cond_Enter => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Passive_Task_Cond_Fail => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Passive_Task_Timed_Enter => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Passive_Task_Timed_Timeout => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Passive_Ceiling_Set_Priority =>
           (Arg_Priority, Arg_Ra, Arg_Null, Arg_Null),

        Breakpoint => (Arg_Null, Arg_Null, Arg_Null, Arg_Null),

        -- Distributed Ada

        -- NOTE:  Any da events which have components logged both on the
        -- parent and the surrogate should be added between
        -- da_first_parent_sur and da_last_parent_sur.
        -- They should have an arg_station as their FIRST arg.  On the
        -- parent, this should be the surrogate's station number and
        -- visa versa.

        Da_First => (Arg_Null, Arg_Null, Arg_Null, Arg_Null),

        -- parent-surrogate paired da events
        Da_First_Parent_Sur => (Arg_Null, Arg_Null, Arg_Null, Arg_Null),
        Da_Simple_Entry_Req => (Arg_Station, Arg_Seq, Arg_Pc, Arg_Entry),
        Da_Simple_Entry_End => (Arg_Station, Arg_Seq, Arg_Pc, Arg_Entry),
        Da_Conditional_Entry_Req => (Arg_Station, Arg_Seq, Arg_Pc, Arg_Entry),
        Da_Conditional_Entry_End => (Arg_Station, Arg_Seq, Arg_Pc, Arg_Boolean),
        Da_Timed_Entry_Req => (Arg_Station, Arg_Seq, Arg_Pc, Arg_Entry),
        Da_Timed_Entry_End => (Arg_Station, Arg_Seq, Arg_Pc, Arg_Boolean),
        Da_Simple_Entry_Sur_Req => (Arg_Station, Arg_Seq, Arg_Tsn, Arg_Entry),
        Da_Simple_Entry_Sur_End => (Arg_Station, Arg_Seq, Arg_Tsn, Arg_Entry),
        Da_Conditional_Entry_Sur_Req =>
           (Arg_Station, Arg_Seq, Arg_Tsn, Arg_Entry),
        Da_Conditional_Entry_Sur_End =>
           (Arg_Station, Arg_Seq, Arg_Tsn, Arg_Entry),
        Da_Timed_Entry_Sur_Req => (Arg_Station, Arg_Seq, Arg_Tsn, Arg_Entry),
        Da_Timed_Entry_Sur_End => (Arg_Station, Arg_Seq, Arg_Tsn, Arg_Entry),
        Da_Dt_Read_Req => (Arg_Station, Arg_Seq, Arg_Pc, Arg_Size),
        Da_Dt_Read_End => (Arg_Station, Arg_Seq, Arg_Pc, Arg_Size),
        Da_Dt_Write_Req => (Arg_Station, Arg_Seq, Arg_Pc, Arg_Size),
        Da_Dt_Write_End => (Arg_Station, Arg_Seq, Arg_Pc, Arg_Size),
        Da_Stub_Read_Req => (Arg_Station, Arg_Seq, Arg_Address, Arg_Null),
        Da_Stub_Read_End => (Arg_Station, Arg_Seq, Arg_Address, Arg_Null),
        Da_Stub_Write_Req => (Arg_Station, Arg_Seq, Arg_Address, Arg_Null),
        Da_Stub_Write_End => (Arg_Station, Arg_Seq, Arg_Address, Arg_Null),
        Da_Rem_Subp_Req => (Arg_Station, Arg_Seq, Arg_Pc, Arg_Null),
        Da_Rem_Subp_End => (Arg_Station, Arg_Seq, Arg_Pc, Arg_Null),
        Da_Rem_Subp_Sur_Req => (Arg_Station, Arg_Seq, Arg_Pc, Arg_Null),
        Da_Rem_Subp_Sur_End => (Arg_Station, Arg_Seq, Arg_Pc, Arg_Null),
        Da_Last_Parent_Sur => (Arg_Null, Arg_Null, Arg_Null, Arg_Null),

        -- non parent-surrogate paired da events
        Da_Local_New_Req => (Arg_Pc, Arg_Size, Arg_Null, Arg_Null),
        Da_Global_Free_Req => (Arg_Station, Arg_Pc, Arg_Tsn, Arg_Null),
        Da_Local_Free_Req => (Arg_Station, Arg_Pc, Arg_Tsn, Arg_Null),
        Da_Station_Info => (Arg_Station, Arg_Value, Arg_Value, Arg_Value),
        Da_Task_Activated_As_Sur => (Arg_Tsn, Arg_Boolean, Arg_Null, Arg_Null),
        Da_Last => (Arg_Null, Arg_Null, Arg_Null, Arg_Null)

        );

    Profile_Arg_Descriptors : array (Profile_Events) of Arg_Descriptor :=
       (Calls => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Returns => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Basic_Block => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Exceptions => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Interrupts => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Cache_Flushes => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null),
        Operand_Changed_Address => (Arg_Ra, Arg_Id, Arg_Address, Arg_Null),
        Operand_Changed_Value => (Arg_Ra, Arg_Id, Arg_Value, Arg_Value),
        Program_Generated_Value => (Arg_Ra, Arg_Null, Arg_Null, Arg_Null));

    procedure Rte_Log (Kind : Runtime_Events;
                       P1 : Address_Sized_Type := Zero;
                       P2 : Address_Sized_Type := Zero;
                       P3 : Address_Sized_Type := Zero;
                       P4 : Address_Sized_Type := Zero);
    pragma Interface (Ada, Rte_Log);
    pragma Interface_Name (Rte_Log, "__TS_DEBUG_RTE_LOG");

    procedure User_Log (Kind : User_Events; Comment : V_I_Trace.Log_String);
    pragma Interface (Ada, User_Log);
    pragma Interface_Name (User_Log, "__TS_DEBUG_USER_LOG");

    procedure User_Log_Int (Kind : User_Events;
                            P1 : Address_Sized_Type := Zero;
                            P2 : Address_Sized_Type := Zero;
                            P3 : Address_Sized_Type := Zero;
                            P4 : Address_Sized_Type := Zero);
    pragma Interface (Ada, User_Log_Int);
    pragma Interface_Name (User_Log_Int, "__TS_DEBUG_USER_LOG_INT");

    procedure Header_Log (Event_Rec : in out Header_Event_Record);
    pragma Interface (Ada, Header_Log);
    pragma Interface_Name (Header_Log, "__TS_DEBUG_HEADER_LOG");

    ------------------------------------------------------------------

    procedure Log_Call;
    pragma Interface (Ada, Log_Call);
    pragma Interface_Name (Log_Call, "__TRACE_LOG_CALL");

    procedure Log_Return;
    pragma Interface (Ada, Log_Return);
    pragma Interface_Name (Log_Return, "__TRACE_LOG_RETURN");

    procedure Log_Basic_Block;
    pragma Interface (Ada, Log_Basic_Block);
    pragma Interface_Name (Log_Basic_Block, "__TRACE_LOG_BLOCK");

    procedure Log_Variable_Word (Id : Integer; Value : Integer);
    pragma Interface (Ada, Log_Variable_Word);
    pragma Interface_Name (Log_Variable_Word, "__TRACE_LOG_VARIABLE_WORD");

    procedure Log_Variable
                 (Id : Integer; Location : Integer; Bit_Size : Integer);
    pragma Interface (Ada, Log_Variable);
    pragma Interface_Name (Log_Variable, "__TRACE_LOG_VARIABLE");


    ------------------------------------------------------------------

    -- DA related sub-routines

    function Seq_Num_For_Sur_Req (Station : Integer) return Integer;
    pragma Interface (Ada, Seq_Num_For_Sur_Req);
    pragma Interface_Name (Seq_Num_For_Sur_Req, "__SEQ_NUM_FOR_SUR_REQ");

    function Seq_Num_For_Parent_Req (Station : Integer) return Integer;
    pragma Interface (Ada, Seq_Num_For_Parent_Req);
    pragma Interface_Name (Seq_Num_For_Parent_Req, "__SEQ_NUM_FOR_PARENT_REQ");

    ------------------------------------------------------------------

    procedure Init_Logging (Configuration : A_Trace_Configuration_T);
    pragma Interface (Ada, Init_Logging);
    pragma Interface_Name (Init_Logging, "__TS_DEBUG_INIT_LOGGING");

end V_I_Trace;

E3 Meta Data

    nblk1=1c
    nid=0
    hdr6=38
        [0x00] rec0=1e rec1=00 rec2=01 rec3=02a
        [0x01] rec0=15 rec1=00 rec2=02 rec3=062
        [0x02] rec0=11 rec1=00 rec2=03 rec3=04a
        [0x03] rec0=1c rec1=00 rec2=04 rec3=01c
        [0x04] rec0=11 rec1=00 rec2=05 rec3=026
        [0x05] rec0=0e rec1=00 rec2=06 rec3=01c
        [0x06] rec0=1a rec1=00 rec2=07 rec3=044
        [0x07] rec0=19 rec1=00 rec2=08 rec3=022
        [0x08] rec0=17 rec1=00 rec2=09 rec3=01c
        [0x09] rec0=1a rec1=00 rec2=0a rec3=01a
        [0x0a] rec0=17 rec1=00 rec2=0b rec3=046
        [0x0b] rec0=19 rec1=00 rec2=0c rec3=00e
        [0x0c] rec0=17 rec1=00 rec2=0d rec3=050
        [0x0d] rec0=16 rec1=00 rec2=0e rec3=032
        [0x0e] rec0=15 rec1=00 rec2=0f rec3=020
        [0x0f] rec0=17 rec1=00 rec2=10 rec3=042
        [0x10] rec0=0e rec1=00 rec2=11 rec3=04a
        [0x11] rec0=0e rec1=00 rec2=12 rec3=082
        [0x12] rec0=14 rec1=00 rec2=13 rec3=020
        [0x13] rec0=11 rec1=00 rec2=14 rec3=05a
        [0x14] rec0=15 rec1=00 rec2=15 rec3=056
        [0x15] rec0=0f rec1=00 rec2=16 rec3=03c
        [0x16] rec0=0f rec1=00 rec2=17 rec3=00c
        [0x17] rec0=11 rec1=00 rec2=18 rec3=076
        [0x18] rec0=14 rec1=00 rec2=19 rec3=044
        [0x19] rec0=19 rec1=00 rec2=1a rec3=000
        [0x1a] rec0=19 rec1=00 rec2=1b rec3=006
        [0x1b] rec0=01 rec1=00 rec2=1c rec3=000
    tail 0x217542450874f7c2c97d1 0x42a00088462060003