home *** CD-ROM | disk | FTP | other *** search
/ vsiftp.vmssoftware.com / VSIPUBLIC@vsiftp.vmssoftware.com.tar / FREEWARE / FREEWARE40.ZIP / callmon / callmon_.ada < prev    next >
Text File  |  1996-08-06  |  8KB  |  260 lines
  1. --  CALLMON - A Call Monitor for OpenVMS Alpha
  2. --
  3. --  File:     CALLMON_.ADA
  4. --  Author:   Thierry Lelegard
  5. --  Version:  1.0
  6. --  Date:     24-JUL-1996
  7. --
  8. --  Abstract: Public Interface of CALLMON
  9. --
  10.  
  11.  
  12. with Lib;
  13. with System;
  14. with Condition_Handling;
  15.  
  16. package Callmon is
  17.  
  18.     subtype Cond_Value_Type is Condition_Handling.Cond_Value_Type;
  19.  
  20.     subtype Address is System.Address;
  21.  
  22.     subtype Integer_8  is System.Integer_8;
  23.     subtype Integer_16 is System.Integer_16;
  24.     subtype Integer_32 is System.Integer_32;
  25.     subtype Integer_64 is System.Integer_64;
  26.  
  27.     subtype Invo_Handle_Type is Lib.Invo_Handle_Type;
  28.  
  29.     --
  30.     -- Procedure argument list.
  31.     -- According to OpenVMS Alpha Calling Standard, an argument list
  32.     -- is made of 0 to 255 64-bits arguments.
  33.     --
  34.  
  35.     subtype Argument_Count is Natural range 0..255;
  36.     subtype Argument_Index is Argument_Count range 1..Argument_Count'Last;
  37.  
  38.     type Argument_List_Type is array (Argument_Index range <>) of Integer_64;
  39.     subtype Maximum_Argument_List_Type is Argument_List_Type (Argument_Index);
  40.  
  41.     --
  42.     -- Argument to pre-processing and post-processing procedure.
  43.     --
  44.  
  45.     type Arguments_Type is
  46.     record
  47.         Post_Processing : Boolean;
  48.         Call_It         : Boolean;
  49.         Result_R0       : Integer_64;
  50.         Result_R1       : Integer_64;
  51.         Result_F0       : Integer_64;
  52.         Result_F1       : Integer_64;
  53.         Arg_Count       : Integer_64;
  54.         Arg_List        : Maximum_Argument_List_Type;
  55.     end record;
  56.  
  57.     for Arguments_Type use
  58.     record
  59.         Post_Processing at  0 range 0 .. 0;
  60.         Call_It         at  4 range 0 .. 0;
  61.         Result_R0       at  8 range 0 .. 63;
  62.         Result_R1       at 16 range 0 .. 63;
  63.         Result_F0       at 24 range 0 .. 63;
  64.         Result_F1       at 32 range 0 .. 63;
  65.         Arg_Count       at 40 range 0 .. 63;
  66.         Arg_List        at 48 range 0 .. 255 * 64 - 1;
  67.     end record;
  68.  
  69.     for Arguments_Type'Size use 261 * 64;
  70.  
  71.     --
  72.     --  CALLMON Initialization (optional, automatically done otherwise)
  73.     --
  74.  
  75.     procedure Initialize (Status : out Cond_Value_Type);
  76.     procedure Initialize;
  77.  
  78.     pragma Interface (C, Initialize);
  79.  
  80.     pragma Import_Valued_Procedure (
  81.         Internal        => Initialize,
  82.         External        => "CALLMON$INITIALIZE",
  83.         Parameter_Types => (Cond_Value_Type),
  84.         Mechanism       => (Value));
  85.  
  86.     pragma Import_Procedure (
  87.         Internal        => Initialize,
  88.         External        => "CALLMON$INITIALIZE",
  89.         Parameter_Types => (null));
  90.  
  91.     --
  92.     --  Intercept a routine.
  93.     --
  94.  
  95.     procedure Intercept (
  96.         Status       : out Cond_Value_Type;
  97.         Routine_Name : in  String;
  98.         Pre_Routine  : in  Address := System.Null_Address;
  99.         Post_Routine : in  Address := System.Null_Address);
  100.  
  101.     procedure Intercept (
  102.         Routine_Name : in  String;
  103.         Pre_Routine  : in  Address := System.Null_Address;
  104.         Post_Routine : in  Address := System.Null_Address);
  105.  
  106.     pragma Interface (C, Intercept);
  107.  
  108.     pragma Import_Valued_Procedure (
  109.         Internal        => Intercept,
  110.         External        => "CALLMON$INTERCEPT_DSC",
  111.         Parameter_Types => (Cond_Value_Type, String, Address, Address),
  112.         Mechanism       => (Value, Descriptor (S), Value, Value));
  113.  
  114.     pragma Import_Procedure (
  115.         Internal        => Intercept,
  116.         External        => "CALLMON$INTERCEPT_DSC",
  117.         Parameter_Types => (String, Address, Address),
  118.         Mechanism       => (Descriptor (S), Value, Value));
  119.  
  120.     --
  121.     -- Declaring a pre-/post-processing routine:
  122.     --
  123.     -- procedure Interceptor (
  124.     --     Arguments           : in out Callmon.Arguments_Type;
  125.     --     Caller              : in     Callmon.Invo_Handle_Type;
  126.     --     Routine_Name        : in     String;
  127.     --     Intercepted_Routine : in     Callmon.Address;
  128.     --     Jacket_Routine      : in     Callmon.Address);
  129.     --
  130.     -- pragma Export_Procedure (
  131.     --     Internal  => Interceptor,
  132.     --     External  => "",
  133.     --     Mechanism => (Reference, Value, Descriptor (S), Value, Value));
  134.     --
  135.  
  136.     --
  137.     -- Intercept all routines in an image.
  138.     --
  139.  
  140.     procedure Intercept_All (
  141.         Status       : out Cond_Value_Type;
  142.         Image_Name   : in  String;
  143.         Pre_Routine  : in  Address := System.Null_Address;
  144.         Post_Routine : in  Address := System.Null_Address;
  145.         Override     : in  Boolean := True);
  146.  
  147.     procedure Intercept_All (
  148.         Image_Name   : in  String;
  149.         Pre_Routine  : in  Address := System.Null_Address;
  150.         Post_Routine : in  Address := System.Null_Address;
  151.         Override     : in  Boolean := True);
  152.  
  153.     pragma Interface (C, Intercept_All);
  154.  
  155.     pragma Import_Valued_Procedure (
  156.         Internal        => Intercept_All,
  157.         External        => "CALLMON$INTERCEPT_ALL_DSC",
  158.         Parameter_Types => (Cond_Value_Type, String, Address, Address, Boolean),
  159.         Mechanism       => (Value, Descriptor (S), Value, Value, Value));
  160.  
  161.     pragma Import_Procedure (
  162.         Internal        => Intercept_All,
  163.         External        => "CALLMON$INTERCEPT_ALL_DSC",
  164.         Parameter_Types => (String, Address, Address, Boolean),
  165.         Mechanism       => (Descriptor (S), Value, Value, Value));
  166.  
  167.     --
  168.     -- Disassemble a range of instructions.
  169.     --
  170.  
  171.     procedure Disassemble (
  172.         Start_Address  : in Address;
  173.         Size_In_Bytes  : in Natural;
  174.         Displayed_PC   : in Address;
  175.         Output_Routine : in Address := System.Null_Address;
  176.         User_Data      : in Address := System.Null_Address);
  177.  
  178.     pragma Interface (C, Disassemble);
  179.  
  180.     pragma Import_Procedure (
  181.         Internal        => Disassemble,
  182.         External        => "CALLMON$DISASSEMBLE_DSC",
  183.         Parameter_Types => (Address, Natural, Address, Address, Address),
  184.         Mechanism       => (Value, Value, Value, Value, Value));
  185.  
  186.     --
  187.     -- Declaring an output routine for the disassembler.
  188.     --
  189.     -- procedure Output (
  190.     --     PC        : in Callmon.Address;
  191.     --     Opcode    : in String;
  192.     --     Operands  : in String;
  193.     --     User_Data : in Callmon.Address);
  194.     --
  195.     -- pragma Export_Procedure (
  196.     --     Internal  => Output,
  197.     --     External  => "",
  198.     --     Mechanism => (Value, Descriptor (S), Descriptor (S), Value));
  199.     --
  200.  
  201.     --
  202.     -- Dumping the list of active images.
  203.     --
  204.  
  205.     procedure Dump_Image_Tree (Status : out Cond_Value_Type);
  206.     procedure Dump_Image_Tree;
  207.  
  208.     pragma Interface (C, Dump_Image_Tree);
  209.  
  210.     pragma Import_Valued_Procedure (
  211.         Internal        => Dump_Image_Tree,
  212.         External        => "CALLMON$DUMP_IMAGE_TREE",
  213.         Parameter_Types => (Cond_Value_Type),
  214.         Mechanism       => (Value));
  215.  
  216.     pragma Import_Procedure (
  217.         Internal        => Dump_Image_Tree,
  218.         External        => "CALLMON$DUMP_IMAGE_TREE",
  219.         Parameter_Types => (null));
  220.  
  221.  
  222.     --
  223.     -- Dumping the list of known routines.
  224.     --
  225.  
  226.     type Dump_Routine_Type is (
  227.         All_Routines,
  228.         Intercepted_Only,
  229.         Uninterceptable_Only,
  230.         Unrelocatable_Only);
  231.  
  232.     for Dump_Routine_Type use (
  233.         All_Routines         => 0,
  234.         Intercepted_Only     => 1,
  235.         Uninterceptable_Only => 2,
  236.         Unrelocatable_Only   => 3);
  237.  
  238.     procedure Dump_Routine_Tree (
  239.         Status : out Cond_Value_Type;
  240.         Class  : in  Dump_Routine_Type);
  241.  
  242.     procedure Dump_Routine_Tree (
  243.         Class  : in  Dump_Routine_Type);
  244.  
  245.     pragma Interface (C, Dump_Routine_Tree);
  246.  
  247.     pragma Import_Valued_Procedure (
  248.         Internal        => Dump_Routine_Tree,
  249.         External        => "CALLMON$DUMP_ROUTINE_TREE",
  250.         Parameter_Types => (Cond_Value_Type, Dump_Routine_Type),
  251.         Mechanism       => (Value, Value));
  252.  
  253.     pragma Import_Procedure (
  254.         Internal        => Dump_Routine_Tree,
  255.         External        => "CALLMON$DUMP_ROUTINE_TREE",
  256.         Parameter_Types => (Dump_Routine_Type),
  257.         Mechanism       => (Value));
  258.  
  259. end Callmon;
  260.