home *** CD-ROM | disk | FTP | other *** search
/ vsiftp.vmssoftware.com / VSIPUBLIC@vsiftp.vmssoftware.com.tar / FREEWARE / FREEWARE40.ZIP / callmon / src / callmon$private.h < prev    next >
C/C++ Source or Header  |  1996-08-06  |  27KB  |  714 lines
  1. /*  CALLMON - A Call Monitor for OpenVMS Alpha
  2.  *
  3.  *  File:     CALLMON$PRIVATE.H
  4.  *  Author:   Thierry Lelegard
  5.  *  Version:  1.0
  6.  *  Date:     24-JUL-1996
  7.  *
  8.  *  Abstract: Private Interfaces of CALLMON
  9.  */
  10.  
  11.  
  12. #ifndef CALLMON_PRIVATE_H_LOADED
  13. #define CALLMON_PRIVATE_H_LOADED 1
  14.  
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <stdarg.h>
  18. #include <string.h>
  19. #include <errno.h>
  20. #include <ints.h>
  21. #include <builtins.h>
  22. #include <descrip.h>
  23. #include <ssdef.h>
  24. #include <stsdef.h>
  25. #include <chfdef.h>
  26. #include <secdef.h>
  27. #include <psldef.h>
  28. #include <vadef.h>
  29. #include <jpidef.h>
  30. #include <syidef.h>
  31. #include <lnmdef.h>
  32. #include <prtdef.h>
  33. #include <libdef.h>
  34. #include <pdscdef.h>
  35. #include <shldef.h>
  36. #include <imcbdef.h>
  37. #include <eihddef.h>
  38. #include <eisddef.h>
  39. #include <eihsdef.h>
  40. #include <eiafdef.h>
  41. #include <eobjrecdef.h>
  42. #include <egsdef.h>
  43. #include <egstdef.h>
  44. #include <egsydef.h>
  45. #include <starlet.h>
  46. #include <evx_opcodes.h>
  47. #include <lib$routines.h>
  48. #include <ots$routines.h>
  49. #include <rmsdef.h>
  50. #include <rms.h>
  51. #include "callmon.h"
  52.  
  53.  
  54. /*******************************************************************************
  55.  *
  56.  *  These macros compute the offset of a field inside a structure and
  57.  *  the base of the structure from the address of a field.
  58.  */
  59.  
  60. #ifdef offsetof  /* from stddef.h */
  61. #define OFFSET(type,field) offsetof (type, field)
  62. #else
  63. #define OFFSET(type,field) ((size_t) (&((type*) NULL)->field))
  64. #endif
  65.  
  66. #define BASE(type,field,field_addr) \
  67.     ((type*) ((char*) (field_addr) - OFFSET (type, field)))
  68.  
  69. /*
  70.  *  This macro computes the number of elements in an array.
  71.  */
  72.  
  73. #define NUMELEM(array) ((int) (sizeof (array) / sizeof (array [0])))
  74.  
  75.  
  76. /*******************************************************************************
  77.  *
  78.  *  OpenVMS miscellaneous definitions.
  79.  */
  80.  
  81. typedef struct dsc$descriptor_s desc_t; /* String descriptor */
  82. typedef struct pdscdef pdsc_t;          /* Procedure descriptor */
  83. typedef struct _imcb imcb_t;            /* Image control block */
  84. typedef struct _shl shl_t;              /* Shareable image list entry */
  85. typedef struct eobjrecdef eobj_t;       /* Object file record */
  86. typedef struct egstdef egst_t;          /* Global symbol table entry */
  87. typedef struct egsdef egsd_t;           /* Global symbol definition */
  88.  
  89. #define FILE_SPEC_SIZE    256  /* Maximum size + 1 of a file specification */
  90. #define FILE_NAME_SIZE     40  /* Maximum size + 1 of a file name-part */
  91. #define DEVICE_NAME_SIZE   65  /* Maximum size + 1 of a device name */
  92. #define NODE_NAME_SIZE    256  /* Maximum size + 1 of a node name */
  93. #define LINK_SYMBOL_SIZE   32  /* Maximum size + 1 of a linker symbol */
  94. #define USER_NAME_SIZE     13  /* Maximum size + 1 of a user name */
  95. #define LOGNAME_SIZE       65  /* Maximum size + 1 of a logical name */
  96. #define MAX_TRANSLATIONS  128  /* Maximum number of logical name translations */
  97. #define DCL_SYMBOL_SIZE   256  /* Maximum size + 1 of a DCL symbol name */
  98. #define PROCESS_NAME_SIZE  16  /* Maximum size + 1 of a process name */
  99. #define DISK_BLOCK_SIZE   512  /* Size of a disk block */
  100. #define PAGELET_SIZE      512  /* Size memory pagelet (aka VAX page) */
  101. #define MIN_ALPHA_PAGE   8192  /* Minimum size of Alpha memory page */
  102. #define MAX_ALPHA_PAGE  65536  /* Maximum size of Alpha memory page */
  103. #define MAX_ARG           255  /* Maximum number of procedure arguments */
  104.  
  105. #pragma nostandard
  106. #pragma member_alignment save
  107. #pragma nomember_alignment
  108.  
  109. typedef struct {                /* I/O Status block */
  110.     uint16 status;
  111.     uint16 count;
  112.     uint32 info;
  113. } iosb_t;
  114.  
  115. typedef struct {                /* Memory address range */
  116.     char *base;
  117.     char *end;
  118. } range_t;
  119.  
  120. typedef struct {                /* Standard item sor system services */
  121.     uint16  length;
  122.     uint16  code;
  123.     void*   buffer;
  124.     uint16* retlen;
  125. } item_t;
  126.  
  127. typedef struct {                /* Node header for LIB$INSERT_TREE */
  128.     void*  left_link;
  129.     void*  right_link;
  130.     uint16 reserved;
  131.     uint16 pad;
  132. } libtree_t;
  133.  
  134. #ifdef lkp$q_entry
  135. #undef lkp$q_entry
  136. #endif
  137. #ifdef lkp$q_proc_value
  138. #undef lkp$q_proc_value
  139. #endif
  140.  
  141. typedef struct {                /* Linkage pair (better than pdscdef.h) */
  142.     int64 lkp$q_entry;          /* Code entry point */
  143.     int64 lkp$q_proc_value;     /* Address of procedure descriptor */
  144. } lkp_t;
  145.  
  146. typedef struct {                /* Relocation record ($RELDEF in LIB.R64) */
  147.     uint32 rel$l_count;         /* Size of bitmap (in bits) */
  148.     int32  rel$l_addr;          /* Relative base address of code section */
  149.     char   rel$t_bitmap [];     /* Variable size */
  150. } rel_t;
  151.  
  152. typedef struct {                /* Fixup list element ($FXEDEF in LIB.R64) */
  153.     uint32 fxe$l_offset;        /* Offset of reference */
  154.     union {
  155.         int32 fxe$l_usv;        /* Universal symbol value */
  156.         int32 fxe$l_psb;        /* Procedure signature block */
  157.     } fxe$l_usv_overlay;
  158. } fxe_t;
  159.  
  160. #define fxe$l_usv fxe$l_usv_overlay.fxe$l_usv
  161. #define fxe$l_psb fxe$l_usv_overlay.fxe$l_psb
  162.  
  163. typedef struct {                /* Fixup record ($FIXDEF in LIB.R64) */
  164.     uint32 fix$l_count;         /* Number of fixups */
  165.     uint32 fix$l_shlx;          /* Shareable image list index */
  166.     union {
  167.         fxe_t fix$t_fixlst [];  /* Fixup list */
  168.         int32 fix$t_offlst [];  /* Image offset list */
  169.     } fix$t_lst_overlay;
  170. } fix_t;
  171.  
  172. #define fix$t_fixlst fix$t_lst_overlay.fix$t_fixlst
  173. #define fix$t_offlst fix$t_lst_overlay.fix$t_offlst
  174.  
  175. #pragma member_alignment restore
  176. #pragma standard
  177.  
  178.  
  179. /*******************************************************************************
  180.  *
  181.  *  These inlined routines initialize string descriptors.
  182.  */
  183.  
  184. #pragma inline (set_desc, set_str_desc)
  185.  
  186. static desc_t* set_desc (desc_t* desc, void* string, size_t size)
  187. {
  188.     desc->dsc$a_pointer = string;
  189.     desc->dsc$w_length  = size;
  190.     desc->dsc$b_class   = DSC$K_CLASS_S;
  191.     desc->dsc$b_dtype   = DSC$K_DTYPE_T;
  192.     return desc;
  193. }
  194.  
  195. static desc_t* set_str_desc (desc_t* desc, char* string)
  196. {
  197.     desc->dsc$a_pointer = string;
  198.     desc->dsc$w_length  = strlen (string);
  199.     desc->dsc$b_class   = DSC$K_CLASS_S;
  200.     desc->dsc$b_dtype   = DSC$K_DTYPE_T;
  201.     return desc;
  202. }
  203.  
  204. #define set_array_desc(desc,array) \
  205.     set_desc ((desc), (array), sizeof (array) - 1)
  206.  
  207.  
  208. /*******************************************************************************
  209.  *
  210.  *  These inlined routines initialize items for system services.
  211.  */
  212.  
  213. #pragma inline (set_item, set_str_item)
  214.  
  215. static void set_item (
  216.     item_t* item,
  217.     uint16  code,
  218.     void*   buffer,
  219.     uint16  buffer_size,
  220.     uint16* ret_length)
  221. {
  222.     item->code   = code;
  223.     item->buffer = buffer;
  224.     item->length = buffer_size;
  225.     item->retlen = ret_length;
  226. }
  227.  
  228. static void set_str_item (item_t* item, uint16 code, char* string)
  229. {
  230.     item->code   = code;
  231.     item->buffer = string;
  232.     item->length = strlen (string);
  233.     item->retlen = NULL;
  234. }
  235.  
  236. #define set_data_item(item,code,data) \
  237.     set_item (item, code, &(data), sizeof (data), NULL)
  238.  
  239. #define set_final_item(item) \
  240.     set_item (item, 0, NULL, 0, NULL)
  241.  
  242.  
  243. /*******************************************************************************
  244.  *
  245.  *  Layout of an Alpha instruction.
  246.  *  In the Alpha architecture, instructions have a fixed size (32 bits).
  247.  */
  248.  
  249. #define INST_RA_MASK     0x03E00000
  250. #define INST_RB_MASK     0x001F0000
  251. #define INST_RC_MASK     0x0000001F
  252.  
  253. #define INST_LIT_MASK    0x001FE000
  254. #define INST_LITFLG_MASK 0x00001000
  255.  
  256. typedef struct {
  257.     union {
  258.         uint32 instr;                    /* Entire instruction */
  259.         struct {                         /* PALcode format */
  260.             unsigned int number : 26;    /* PAL function */
  261.             unsigned int opcode :  6;    /* Opcode */
  262.         } pal;
  263.         struct {                         /* Branch format */
  264.             signed int   disp   : 21;    /* Displacement */
  265.             unsigned int ra     :  5;    /* Register Ra */
  266.             unsigned int opcode :  6;    /* Opcode */
  267.         } branch;
  268.         struct {                         /* Memory format */
  269.             signed int   disp   : 16;    /* Displacement */
  270.             unsigned int rb     :  5;    /* Register Rb */
  271.             unsigned int ra     :  5;    /* Register Ra */
  272.             unsigned int opcode :  6;    /* Opcode */
  273.         } mem;
  274.         struct {                         /* Memory format with unsigned disp */
  275.             unsigned int func   : 16;    /* Function code */
  276.             unsigned int rb     :  5;    /* Register Rb */
  277.             unsigned int ra     :  5;    /* Register Ra */
  278.             unsigned int opcode :  6;    /* Opcode */
  279.         } umem;
  280.         struct {                         /* Memory format for jump */
  281.             unsigned int predic : 14;    /* Predicted target */
  282.             unsigned int hint   :  2;    /* JSR/JMP/RET/COROUTINE */
  283.             unsigned int rb     :  5;    /* Register Rb */
  284.             unsigned int ra     :  5;    /* Register Ra */
  285.             unsigned int opcode :  6;    /* Opcode */
  286.         } jump;
  287.         struct {                         /* Operate format with register */
  288.             unsigned int rc     :  5;    /* Register Rc */
  289.             unsigned int func   :  7;    /* Instruction class */
  290.             unsigned int litflg :  1;    /* Zero (register) */
  291.             unsigned int sbz    :  3;    /* Should be zero */
  292.             unsigned int rb     :  5;    /* Register Rb */
  293.             unsigned int ra     :  5;    /* Register Ra */
  294.             unsigned int opcode :  6;    /* Opcode */
  295.         } op;
  296.         struct {                         /* Operate format with literal */
  297.             unsigned int rc     :  5;    /* Register Rc */
  298.             unsigned int func   :  7;    /* Instruction class */
  299.             unsigned int litflg :  1;    /* One (literal) */
  300.             unsigned int lit    :  8;    /* Literal */
  301.             unsigned int ra     :  5;    /* Register Ra */
  302.             unsigned int opcode :  6;    /* Opcode */
  303.         } oplit;
  304.         struct {                         /* Floating-point format */
  305.             unsigned int fc     :  5;    /* Register Fc */
  306.             unsigned int func   :  4;    /* Instruction class */
  307.             unsigned int src    :  2;    /* Source data type */
  308.             unsigned int rnd    :  2;    /* Rounding mode */
  309.             unsigned int trp    :  3;    /* Trapping mode */
  310.             unsigned int fb     :  5;    /* Register Fb */
  311.             unsigned int fa     :  5;    /* Register Fa */
  312.             unsigned int opcode :  6;    /* Opcode */
  313.         } fp;
  314.         struct {                         /* Floating-point Aux. format */
  315.             unsigned int fc     :  5;    /* Register Fc */
  316.             unsigned int func   : 11;    /* Instruction class */
  317.             unsigned int fb     :  5;    /* Register Fb */
  318.             unsigned int fa     :  5;    /* Register Fa */
  319.             unsigned int opcode :  6;    /* Opcode */
  320.         } fpaux;
  321.     } u;                                 /* Union name */
  322. } inst_t;
  323.  
  324.  
  325. /*******************************************************************************
  326.  *
  327.  *  The image activator maintains a list of the currently activated
  328.  *  images (called the "done" list). This is a list of Image Control
  329.  *  Blocks (IMCB) starting at IAC$GL_IMAGE_LIST. Note that referencing
  330.  *  this cell requires to link /SYSEXE.
  331.  */
  332.  
  333. #pragma extern_model save
  334. #pragma extern_model strict_refdef
  335. extern imcb_t iac$gl_image_list; /* List head only, not full IMCB */
  336. #pragma extern_model restore
  337.  
  338.  
  339. /*******************************************************************************
  340.  *
  341.  *  CALLMON internal data structure:
  342.  *
  343.  *  There is one image_t structure per main or shareable image in the
  344.  *  current process.
  345.  */
  346.  
  347. typedef struct {
  348.     libtree_t tree_node;     /* Private to lib$insert_tree */
  349.     imcb_t*   imcb;          /* Image control block (never NULL) */
  350.     EIHD*     eihd;          /* Image header (or NULL) */
  351.     EIHS*     eihs;          /* Image symbol table section (or NULL) */
  352.     EIAF*     eiaf;          /* Image activator fixup section (or NULL) */
  353.     EISD*     eisd;          /* First image section descriptor */
  354.     uint16    channel;       /* Channel to the image (or zero) */
  355.     void*     gst;           /* Global symbol table (or NULL) */
  356.     int       file_blocks;   /* File size in blocks (or zero) */
  357.     int       resident;      /* Boolean: image is resident */
  358.     int       protected;     /* Boolean: image is protected */
  359.     int       routine_count; /* Number of routines in this image */
  360.     int       replace_bsr;   /* Boolean: the BSR instr. must be replaced */
  361.     char      logname [FILE_NAME_SIZE];     /* Image logical name */
  362.     char      file_spec [FILE_SPEC_SIZE];   /* Full file specification */
  363. } image_t;
  364.  
  365.  
  366. /*******************************************************************************
  367.  *
  368.  *  CALLMON internal data structure:
  369.  *
  370.  *  Each routine is described by a routine_t structure. These structures
  371.  *  are maintained in several balanced trees. There is one tree for names,
  372.  *  one tree for procedure values and one tree for entry code addresses.
  373.  *  Each routine_t belongs to all trees, using a different libtree_t field.
  374.  *
  375.  *  Duplicate entries: If two routines have the same name (from two
  376.  *  different images), both have a routine_t structure but only one
  377.  *  routine_t is inserted in the tree. This routine_t is the "master
  378.  *  by name". Then, a list of duplicate entries starts at "next by name".
  379.  *  Each duplicate entry points to the "master by name".
  380.  *
  381.  *  The same system applies for the duplication of procedure values and
  382.  *  entries (if one procedure has two names).
  383.  *
  384.  *  A routine is intercepted when its "jacket" field is non-null.
  385.  *  If several routine names share the same value, they point to the
  386.  *  same jacket.
  387.  */
  388.  
  389. typedef struct routine_s routine_t;
  390.  
  391. struct routine_s {
  392.     libtree_t  by_name;         /* Private to lib$insert_tree */
  393.     libtree_t  by_value;        /* Private to lib$insert_tree */
  394.     libtree_t  by_entry;        /* Private to lib$insert_tree */
  395.     image_t*   image;           /* Shareable image of the routine */
  396.     lkp_t      lkp;             /* Linkage pair from the symbol vector */
  397.     int        uninterceptable; /* Don't intercept this routine */
  398.     int        unrelocatable;   /* Don't hook relocation (fixup only) */
  399.     pdsc_t*    jacket;          /* Jacket routine */
  400.     routine_t* master_by_name;  /* Head of list with same name */
  401.     routine_t* next_by_name;    /* Next in list with same name */
  402.     routine_t* master_by_value; /* Head of list with same value */
  403.     routine_t* next_by_value;   /* Next in list with same value */
  404.     routine_t* master_by_entry; /* Head of list with same entry code */
  405.     routine_t* next_by_entry;   /* Next in list with same entry code */
  406.     desc_t     name_d;          /* String descriptor for field "name" */
  407.     char       name [LINK_SYMBOL_SIZE]; /* Routine name */
  408. };
  409.  
  410.  
  411. /*******************************************************************************
  412.  *
  413.  *  This structure defines the association between a name and a value.
  414.  */
  415.  
  416. typedef struct {
  417.     int32 value;
  418.     char* name;
  419. } name_value_t;
  420.  
  421.  
  422. /*******************************************************************************
  423.  *
  424.  *  During interception of routines, any kind of threading must be
  425.  *  disabled. This structure is used to save the previous state.
  426.  */
  427.  
  428. typedef struct {
  429.     uint32 ast_state;   /* SS$_WASCLR or SS$_WASSET */
  430. } thread_state_t;
  431.  
  432.  
  433. /*******************************************************************************
  434.  *
  435.  *  CALLMON own storage.
  436.  *
  437.  *  The CALLMON$OWN area is shared by all modules of CALLMON.
  438.  *
  439.  *  There is no thread-synchronization when accessing this area.
  440.  *  This means that CALLMON's API is not thread-reentrant. However,
  441.  *  the jacket routine is thread reentrant. In other words, if an
  442.  *  intercepted routine is reentrant, it is still reentrant after
  443.  *  interception (in the user-supplied pre-/post-processing routines
  444.  *  are also reentrant).
  445.  */
  446.  
  447. typedef struct {
  448.  
  449.     /* Trace flags are used for troubleshooting purpose. The trace_flags
  450.      * field is a OR of TRACE_* constants as defined below. This field
  451.      * is written during initialization of CALLMON and read-only later. */
  452.  
  453.     uint32 trace_flags;
  454.  
  455.     /* Each time a BSR R26 is found in a code section, an CALLMON attempts
  456.      * to replace it with a JSR R26. If the BSR is not replaced, the target
  457.      * routine cannot be intercepted inside its image. In other words,
  458.      * intra-image calls are not intercepted (although inter-image calls are).
  459.      * It is possible to moderate the way BSR are replaced. */
  460.  
  461.     int bsr_replacement;
  462.  
  463.     #define BSR_OFF    0  /* No BSR replacement allowed */
  464.     #define BSR_IF_R27 1  /* Allow replacement only if a LDx R27 is present */
  465.     #define BSR_ALL    2  /* Allow replacement in all cases */
  466.  
  467.     /* When a BSR is transformed into a JSR, we must find a NOP instruction
  468.      * (that is to say some unused placeholder where to store the appropriate
  469.      * LDQ R26 instruction). The field bsr_depth gives the maximum number of
  470.      * instructions between the NOP and the BSR. */
  471.  
  472.     int bsr_depth;
  473.  
  474.     /* The page size field contains the physical page size of the system.
  475.      * The initial value of this field is zero and is initialized the
  476.      * first time it is used, provided that it is accessed using the
  477.      * macro get_page_size (). */
  478.  
  479.     uint32 page_size;
  480.  
  481.     #define get_page_size() \
  482.         (callmon$$own.page_size != 0 ? callmon$$own.page_size : \
  483.         (callmon$$own.page_size = callmon$$page_size ()))
  484.  
  485.     /* Tree of image_t structures. Each image in the process has one
  486.      * structure in the tree. The tree is indexed using the image
  487.      * logical name. The field image_tree is the head of the tree. */
  488.  
  489.     void* image_tree;
  490.  
  491.     /* Tree of routine_t structures. Each routine in the process has one
  492.      * structure in the tree. The tree is indexed using three criteria:
  493.      * symbol name, procedure value (pdsc_t*) and entry code address.
  494.      * The following three fields are the heads of the tree according
  495.      * to each criteria. */
  496.  
  497.     void* routine_tree_by_name;
  498.     void* routine_tree_by_value;
  499.     void* routine_tree_by_entry;
  500.  
  501.     /* Some low-level RTL routines cannot be intercepted for some reason.
  502.      * The following array is constant and contains a list of routine
  503.      * which should not be intercepted. */
  504.  
  505.     char** uninterceptable_routines;
  506.  
  507.     /* The following array is initially empty. It contains a user-defined
  508.      * list of routines which should not be intercepted. This list is
  509.      * filled during CALLMON initialization. */
  510.  
  511.     char** uninterceptable_routines_sup;
  512.  
  513.     /* Some routine cannot be relocated. This means that CALLMON must not
  514.      * modify the relocations which point to it (but the modification of
  515.      * fixup is still allowed). Any routine which is the target of an
  516.      * unreplaced BSR is unrelocatable. Moreover, some routine are
  517.      * unrelocatable by definition. They are listed in the following table. */
  518.  
  519.     char** unrelocatable_routines;
  520.  
  521.     /* The following array is initially empty. It contains a user-defined
  522.      * list of routines which should not be relocated. This list is
  523.      * filled during CALLMON initialization. */
  524.  
  525.     char** unrelocatable_routines_sup;
  526.  
  527. } callmon$$own_t;
  528.  
  529.  
  530. /*******************************************************************************
  531.  *
  532.  *  Definition and initial value of CALLMON$$OWN.
  533.  *
  534.  *  If symbol DEFINE_CALLMON_OWN_STORAGE is not defined, external reference
  535.  *  are generated. If it is defined, the actual definition is included.
  536.  */
  537.  
  538. #pragma extern_model save
  539. #pragma extern_model strict_refdef
  540. #ifndef DEFINE_CALLMON_OWN_STORAGE
  541. extern callmon$$own_t callmon$$own;
  542. #else
  543.  
  544. static char* uninterceptable_routines [] = {
  545.     "LIB$GET_CURR_INVO_CONTEXT", /* called in callmon$$jacket */
  546.     "LIB$GET_PREV_INVO_CONTEXT", /* called in callmon$$jacket */
  547.     "LIB$GET_INVO_HANDLE",       /* called in callmon$$jacket */
  548.     "OTS$DIV_UI",                /* called by relocation hook sequence */
  549.     "DECC$STRCMP",               /* pragma linkage (notneeded (ai,lp)) */
  550.     "DECC$STRCPY",               /* pragma linkage (notneeded (ai,lp)) */
  551.     "DECC$STRLEN",               /* pragma linkage (notneeded (ai,lp)) */
  552.     "DECC$STRNLEN",              /* pragma linkage (notneeded (ai,lp)) */
  553.     NULL};
  554.  
  555. static char* unrelocatable_routines [] = {
  556.     "DECC$STRCMP",   /* pragma linkage (notneeded (ai,lp)) */
  557.     "DECC$STRCPY",   /* pragma linkage (notneeded (ai,lp)) */
  558.     "DECC$STRLEN",   /* pragma linkage (notneeded (ai,lp)) */
  559.     "DECC$STRNLEN",  /* pragma linkage (notneeded (ai,lp)) */
  560.     NULL};
  561.  
  562. callmon$$own_t callmon$$own = {
  563.     /* trace_flags                  */  0,
  564.     /* bsr_replacement              */  BSR_IF_R27,
  565.     /* bsr_depth                    */  1000,  /* almost unbounded */
  566.     /* page_size                    */  0,
  567.     /* image_tree                   */  NULL,
  568.     /* routine_tree_by_name         */  NULL,
  569.     /* routine_tree_by_value        */  NULL,
  570.     /* routine_tree_by_entry        */  NULL,
  571.     /* uninterceptable_routines     */  uninterceptable_routines,
  572.     /* uninterceptable_routines_sup */  NULL,
  573.     /* unrelocatable_routines       */  unrelocatable_routines,
  574.     /* unrelocatable_routines_sup   */  NULL,
  575. };
  576.  
  577. #endif
  578. #pragma extern_model restore
  579.  
  580.  
  581. /*******************************************************************************
  582.  *
  583.  *  CALLMON trace flags
  584.  */
  585.  
  586. #define TRACE_API           0x00000001  /* Calls to CallMon API */
  587. #define TRACE_IMAGE         0x00000002  /* Loaded images */
  588. #define TRACE_ROUTINE       0x00000004  /* Loaded routines */
  589. #define TRACE_MEMORY        0x00000008  /* Modification of page protection */
  590. #define TRACE_UNRELOCATABLE 0x00000010  /* All unrelocatable routines */
  591. #define TRACE_UNRELOCATED   0x00000020  /* Unrelocated routines */
  592. #define TRACE_DUPLICATE     0x00000040  /* Duplicate routine name or value */
  593. #define TRACE_REFERENCES    0x00000080  /* Fixup and relocation summary */
  594. #define TRACE_RELOCATION    0x00000100  /* All relocations */
  595. #define TRACE_FIXUP         0x00000200  /* All fixups */
  596. #define TRACE_INSTRUCTIONS  0x00000400  /* Instruction processing */
  597. #define TRACE_CONFIGURATION 0x00000800  /* Configuration options */
  598.  
  599. #pragma extern_model save
  600. #pragma extern_model strict_refdef
  601. #ifdef DEFINE_CALLMON_OWN_STORAGE
  602. name_value_t callmon$$trace_flags_names [] = {
  603.     {TRACE_API,           "API"},
  604.     {TRACE_IMAGE,         "LOAD_IMAGE"},
  605.     {TRACE_ROUTINE,       "LOAD_ROUTINE"},
  606.     {TRACE_MEMORY,        "MEMORY"},
  607.     {TRACE_UNRELOCATABLE, "UNRELOCATABLE"},
  608.     {TRACE_UNRELOCATED,   "UNRELOCATED"},
  609.     {TRACE_DUPLICATE,     "DUPLICATE"},
  610.     {TRACE_REFERENCES,    "REFERENCES"},
  611.     {TRACE_RELOCATION,    "RELOCATION"},
  612.     {TRACE_FIXUP,         "FIXUP"},
  613.     {TRACE_INSTRUCTIONS,  "INSTRUCTIONS"},
  614.     {TRACE_CONFIGURATION, "CONFIGURATION"},
  615.     {0xFFFFFFFF,          "ALL"},
  616.     {0,                   NULL}
  617. };
  618. #else
  619. extern name_value_t callmon$$trace_flags_names [];
  620. #endif
  621. #pragma extern_model restore
  622.  
  623.  
  624. /*******************************************************************************
  625.  *
  626.  *  All CALLMON public routines which use nul-terminated strings in their
  627.  *  parameter profile have alternate routines which use class S string
  628.  *  descriptors. These routines are for use by non-C languages.
  629.  */
  630.  
  631. typedef void (*callmon$intercept_dsc_t) (
  632.     callmon$arguments_t*     arguments,
  633.     uint32                   caller_invo_handle,
  634.     struct dsc$descriptor_s* routine_name,
  635.     uint64                   (*intercepted_routine)(),
  636.     uint64                   (*jacket_routine)());
  637.  
  638. typedef void (*callmon$disassemble_output_dsc_t) (
  639.     void*                    pc,
  640.     struct dsc$descriptor_s* opcode,
  641.     struct dsc$descriptor_s* operands,
  642.     void*                    user_data);
  643.  
  644. uint32 callmon$intercept_dsc (
  645.     struct dsc$descriptor_s* routine_name,
  646.     callmon$intercept_t      pre_routine,
  647.     callmon$intercept_t      post_routine);
  648.  
  649. uint32 callmon$intercept_all_dsc (
  650.     struct dsc$descriptor_s* image_name,
  651.     callmon$intercept_t      pre_routine,
  652.     callmon$intercept_t      post_routine,
  653.     callmon$boolean_t        override);
  654.  
  655. void callmon$disassemble_dsc (
  656.     void*                            address,
  657.     size_t                           size_in_bytes,
  658.     void*                            displayed_pc,
  659.     callmon$disassemble_output_dsc_t output_routine,
  660.     void*                            user_data);
  661.  
  662.  
  663. /*******************************************************************************
  664.  *
  665.  *  These macros supplement routines callmon$$read/write_register_mask
  666.  *  They check if a specified register is used by an instruction.
  667.  */
  668.  
  669. #define callmon$$is_read_register(pc,reg) \
  670.     ((callmon$$read_register_mask (pc) & (1 << (reg))) != 0)
  671.  
  672. #define callmon$$is_write_register(pc,reg) \
  673.     ((callmon$$write_register_mask (pc) & (1 << (reg))) != 0)
  674.  
  675.  
  676. /*******************************************************************************
  677.  *
  678.  *  Declarations of CALLMON private routines.
  679.  */
  680.  
  681. void*      callmon$$alloc (size_t);
  682. int        callmon$$branch_instruction (inst_t*);
  683. inst_t*    callmon$$branch_target (inst_t*);
  684. uint32     callmon$$disable_threading (thread_state_t*);
  685. void       callmon$$disassemble (inst_t*, size_t, void*,
  686.                callmon$disassemble_output_t,
  687.                callmon$disassemble_output_dsc_t, void*);
  688. uint32     callmon$$free (void*, size_t);
  689. image_t*   callmon$$get_image (char*);
  690. routine_t* callmon$$get_routine_by_entry (int64);
  691. routine_t* callmon$$get_routine_by_name (char*);
  692. routine_t* callmon$$get_routine_by_value (int64);
  693. image_t*   callmon$$load_image (imcb_t*);
  694. routine_t* callmon$$load_routine (image_t*, egst_t*);
  695. int32      callmon$$name_to_value (name_value_t*, char*, int32);
  696. uint32     callmon$$page_size (void);
  697. void       callmon$$process_fixups (image_t*, routine_t*);
  698. void       callmon$$process_relocations (routine_t*);
  699. void       callmon$$putmsg (uint32, ...);
  700. uint32     callmon$$read_register_mask (inst_t*);
  701. void       callmon$$remove_bsr (image_t*);
  702. uint32     callmon$$restore_threading (thread_state_t*);
  703. char**     callmon$$search_list (char*, char*);
  704. void       callmon$$set_uninterceptable (routine_t*);
  705. void       callmon$$set_unrelocatable (routine_t*);
  706. uint32     callmon$$translate (char*, char*, size_t, char*, int);
  707. int        callmon$$translation_count (char*, char*);
  708. uint32     callmon$$tree_allocate_from_user_data (void*, void**, void*);
  709. int        callmon$$writeable (void*, size_t);
  710. uint32     callmon$$write_register_mask (inst_t*);
  711.  
  712.  
  713. #endif /* CALLMON_PRIVATE_H_LOADED */
  714.