COMPILATION LISTING OF SEGMENT db_fill_snt Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Multics Op. - System M Compiled on: 11/05/86 1029.6 mst Wed Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 db_fill_snt: procedure( arg_sp, arg_snt_ptr ); 12 13 14 /* This procedure fills in the SNT table with data from the specified stack frame. */ 15 16 17 18 19 /* PARAMETER DATA */ 20 21 22 dcl arg_sp ptr, /* Pointer to the stack frame where we 23* * will get our data. */ 24 25 arg_snt_ptr ptr; /* Pointer to the SNT table. */ 26 27 28 29 30 31 /* AUTOMATIC DATA */ 32 33 34 dcl code fixed bin, /* Return code. */ 35 36 dummy fixed bin; /* Dummy argument. */ 37 38 39 dcl lot_ptr ptr, /* Pointer to the LOT table. */ 40 isot_ptr ptr, /* Pointer to the ISOT table. */ 41 42 proc_segno fixed bin; /* Segment number of the procedure which 43* * owns the stack frame. */ 44 45 46 dcl procedure_ptr ptr, /* Pointer to the procedure which owns 47* * the stack frame. */ 48 49 dum_string char (32) aligned; /* dummy string used as argument */ 50 51 52 dcl 1 situation aligned, 53 2 bad_frame bit (1) unal, 54 2 pad1 bit (4) unal, 55 2 entry_ptr_bad bit (1) unal, 56 2 pad2 bit (30) unal; 57 58 59 dcl 1 cond_info aligned, 1 1 /* BEGIN INCLUDE FILE ... cond_info.incl.pl1 1 2* coded by M. Weaver 12 July 1973 */ 1 3 1 4 2 mcptr ptr, /* ptr to machine conditions at time of fault */ 1 5 2 version fixed bin, /* version of this structure (now=1) */ 1 6 2 condition_name char(32) var, /* name of condition */ 1 7 2 infoptr ptr, /* ptr to software info structure */ 1 8 2 wcptr ptr, /* ptr to wall crossing machine conditions */ 1 9 2 loc_ptr ptr, /* ptr to location where condition occurred */ 1 10 2 flags aligned, 1 11 3 crawlout bit(1) unal, /* = "1"b if condition occurred in inner ring */ 1 12 3 pad1 bit(35) unal, 1 13 2 pad_word bit(36) aligned, 1 14 2 user_loc_ptr ptr, /* ptr to last non-support loc before condition */ 1 15 2 pad (4) bit(36) aligned; 1 16 1 17 /* END INCLUDE FILE ... cond_info.incl.pl1 */ 60 61 62 63 64 65 66 /* BASED DATA */ 67 68 69 dcl 1 lot_array ( 0:1023 ) aligned based, /* Map of LOT table. Used to reference 70* * specific entries in the LOT. */ 71 72 2 segno bit(18) unaligned, 73 74 2 offset bit(18) unaligned; 75 76 77 dcl based_name_string char(ent_pt_name_len) based; 78 79 80 81 82 /* EXTERNAL DATA */ 83 84 85 dcl db_stack_util$procedure_ptr ext entry ( ptr, ptr, fixed bin ), 86 87 hcs_$fs_get_path_name ext entry ( ptr, char(*) aligned, fixed bin, char(*) aligned, fixed bin ), 88 89 find_condition_info_ ext entry ( ptr, ptr, fixed bin ); 90 91 dcl stack_frame_exit_ ext entry ( ptr, ptr, ptr, 92 bit (1) aligned, ptr, char(32) aligned, 93 ptr ); 94 95 dcl get_entry_name_ ext entry (ptr, char (*) aligned, fixed bin, 96 char (*) aligned, fixed bin ); 97 98 99 100 101 dcl ( addr, 102 baseno, 103 baseptr, 104 fixed, 105 null, 106 ptr, 107 rel ) builtin; 108 /* */ 2 1 /* BEGIN INCLUDE FILE ... db_snt.incl.pl1 Last modified Nov 1972. WSS */ 2 2 /* Modified 8/75 to add internal static pointer by S.E. Barr */ 2 3 2 4 2 5 /* Overlay of segment name table. */ 2 6 2 7 dcl sntp ptr; /* Pointer to segment name table. */ 2 8 2 9 dcl 1 snt based (sntp) aligned, 2 10 2 ent_pt_name char(32), /* Entry point name. */ 2 11 2 ent_name char(32), /* Entry name of segment. */ 2 12 2 dir_name char(168), /* Directory name. */ 2 13 2 pp ptr, /* Pointer to current procedure. */ 2 14 2 sp ptr, /* Pointer to current stack frame. */ 2 15 2 lp ptr, /* Pointer to linkage section. */ 2 16 2 symp ptr, /* Pointer to current symbol table block. */ 2 17 2 symflag bit(1) unal, /* ON => no symbol table defined. */ 2 18 2 std bit(1) unal, /* ON => standard symbol header. */ 2 19 2 headp ptr, /* Pointer to current symbol header. */ 2 20 2 static_ptr ptr; /* Pointer to current static section. */ 2 21 2 22 /* END OF INCLUDE FILE... db_snt.incl.pl1 */ 109 110 /* */ 3 1 /* BEGIN INCLUDE FILE its.incl.pl1 3 2* modified 27 July 79 by JRDavis to add its_unsigned 3 3* Internal format of ITS pointer, including ring-number field for follow-on processor */ 3 4 3 5 dcl 1 its based aligned, /* declaration for ITS type pointer */ 3 6 2 pad1 bit (3) unaligned, 3 7 2 segno bit (15) unaligned, /* segment number within the pointer */ 3 8 2 ringno bit (3) unaligned, /* ring number within the pointer */ 3 9 2 pad2 bit (9) unaligned, 3 10 2 its_mod bit (6) unaligned, /* should be 43(8) */ 3 11 3 12 2 offset bit (18) unaligned, /* word offset within the addressed segment */ 3 13 2 pad3 bit (3) unaligned, 3 14 2 bit_offset bit (6) unaligned, /* bit offset within the word */ 3 15 2 pad4 bit (3) unaligned, 3 16 2 mod bit (6) unaligned; /* further modification */ 3 17 3 18 dcl 1 itp based aligned, /* declaration for ITP type pointer */ 3 19 2 pr_no bit (3) unaligned, /* number of pointer register to use */ 3 20 2 pad1 bit (27) unaligned, 3 21 2 itp_mod bit (6) unaligned, /* should be 41(8) */ 3 22 3 23 2 offset bit (18) unaligned, /* word offset from pointer register word offset */ 3 24 2 pad2 bit (3) unaligned, 3 25 2 bit_offset bit (6) unaligned, /* bit offset relative to new word offset */ 3 26 2 pad3 bit (3) unaligned, 3 27 2 mod bit (6) unaligned; /* further modification */ 3 28 3 29 3 30 dcl 1 its_unsigned based aligned, /* just like its, but with unsigned binary */ 3 31 2 pad1 bit (3) unaligned, 3 32 2 segno fixed bin (15) unsigned unaligned, 3 33 2 ringno fixed bin (3) unsigned unaligned, 3 34 2 pad2 bit (9) unaligned, 3 35 2 its_mod bit (6) unaligned, 3 36 3 37 2 offset fixed bin (18) unsigned unaligned, 3 38 2 pad3 bit (3) unaligned, 3 39 2 bit_offset fixed bin (6) unsigned unaligned, 3 40 2 pad4 bit (3) unaligned, 3 41 2 mod bit (6) unaligned; 3 42 3 43 dcl 1 itp_unsigned based aligned, /* just like itp, but with unsigned binary where appropriate */ 3 44 2 pr_no fixed bin (3) unsigned unaligned, 3 45 2 pad1 bit (27) unaligned, 3 46 2 itp_mod bit (6) unaligned, 3 47 3 48 2 offset fixed bin (18) unsigned unaligned, 3 49 2 pad2 bit (3) unaligned, 3 50 2 bit_offset fixed bin (6) unsigned unaligned, 3 51 2 pad3 bit (3) unaligned, 3 52 2 mod bit (6) unaligned; 3 53 3 54 3 55 dcl ITS_MODIFIER bit (6) unaligned internal static options (constant) init ("43"b3); 3 56 dcl ITP_MODIFIER bit (6) unaligned internal static options (constant) init ("41"b3); 3 57 3 58 /* END INCLUDE FILE its.incl.pl1 */ 111 112 /* */ 4 1 /* BEGIN INCLUDE FILE ... stack_header.incl.pl1 .. 3/72 Bill Silver */ 4 2 /* modified 7/76 by M. Weaver for *system links and more system use of areas */ 4 3 /* modified 3/77 by M. Weaver to add rnt_ptr */ 4 4 /* Modified April 1983 by C. Hornig for tasking */ 4 5 4 6 /****^ HISTORY COMMENTS: 4 7* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), 4 8* audit(86-08-05,Schroth), install(86-11-03,MR12.0-1206): 4 9* added the heap_header_ptr definition. 4 10* 2) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 4 11* audit(86-10-10,Fawcett), install(86-11-03,MR12.0-1206): 4 12* Modified to support control point management. These changes were actually 4 13* made in February 1985 by G. Palter. 4 14* 3) change(86-10-22,Fawcett), approve(86-10-22,MCR7473), 4 15* audit(86-10-22,Farley), install(86-11-03,MR12.0-1206): 4 16* Remove the old_lot pointer and replace it with cpm_data_ptr. Use the 18 4 17* bit pad after cur_lot_size for the cpm_enabled. This was done to save some 4 18* space int the stack header and change the cpd_ptr unal to cpm_data_ptr 4 19* (ITS pair). 4 20* END HISTORY COMMENTS */ 4 21 4 22 /* format: style2 */ 4 23 4 24 dcl sb ptr; /* the main pointer to the stack header */ 4 25 4 26 dcl 1 stack_header based (sb) aligned, 4 27 2 pad1 (4) fixed bin, /* (0) also used as arg list by outward_call_handler */ 4 28 2 cpm_data_ptr ptr, /* (4) pointer to control point which owns this stack */ 4 29 2 combined_stat_ptr ptr, /* (6) pointer to area containing separate static */ 4 30 2 clr_ptr ptr, /* (8) pointer to area containing linkage sections */ 4 31 2 max_lot_size fixed bin (17) unal, /* (10) DU number of words allowed in lot */ 4 32 2 main_proc_invoked fixed bin (11) unal, /* (10) DL nonzero if main procedure invoked in run unit */ 4 33 2 have_static_vlas bit (1) unal, /* (10) DL "1"b if (very) large arrays are being used in static */ 4 34 2 pad4 bit (2) unal, 4 35 2 run_unit_depth fixed bin (2) unal, /* (10) DL number of active run units stacked */ 4 36 2 cur_lot_size fixed bin (17) unal, /* (11) DU number of words (entries) in lot */ 4 37 2 cpm_enabled bit (18) unal, /* (11) DL non-zero if control point management is enabled */ 4 38 2 system_free_ptr ptr, /* (12) pointer to system storage area */ 4 39 2 user_free_ptr ptr, /* (14) pointer to user storage area */ 4 40 2 null_ptr ptr, /* (16) */ 4 41 2 stack_begin_ptr ptr, /* (18) pointer to first stack frame on the stack */ 4 42 2 stack_end_ptr ptr, /* (20) pointer to next useable stack frame */ 4 43 2 lot_ptr ptr, /* (22) pointer to the lot for the current ring */ 4 44 2 signal_ptr ptr, /* (24) pointer to signal procedure for current ring */ 4 45 2 bar_mode_sp ptr, /* (26) value of sp before entering bar mode */ 4 46 2 pl1_operators_ptr ptr, /* (28) pointer to pl1_operators_$operator_table */ 4 47 2 call_op_ptr ptr, /* (30) pointer to standard call operator */ 4 48 2 push_op_ptr ptr, /* (32) pointer to standard push operator */ 4 49 2 return_op_ptr ptr, /* (34) pointer to standard return operator */ 4 50 2 return_no_pop_op_ptr 4 51 ptr, /* (36) pointer to standard return / no pop operator */ 4 52 2 entry_op_ptr ptr, /* (38) pointer to standard entry operator */ 4 53 2 trans_op_tv_ptr ptr, /* (40) pointer to translator operator ptrs */ 4 54 2 isot_ptr ptr, /* (42) pointer to ISOT */ 4 55 2 sct_ptr ptr, /* (44) pointer to System Condition Table */ 4 56 2 unwinder_ptr ptr, /* (46) pointer to unwinder for current ring */ 4 57 2 sys_link_info_ptr ptr, /* (48) pointer to *system link name table */ 4 58 2 rnt_ptr ptr, /* (50) pointer to Reference Name Table */ 4 59 2 ect_ptr ptr, /* (52) pointer to event channel table */ 4 60 2 assign_linkage_ptr ptr, /* (54) pointer to storage for (obsolete) hcs_$assign_linkage */ 4 61 2 heap_header_ptr ptr, /* (56) pointer to the heap header for this ring */ 4 62 2 trace, 4 63 3 frames, 4 64 4 count fixed bin, /* (58) number of trace frames */ 4 65 4 top_ptr ptr unal, /* (59) pointer to last trace frame */ 4 66 3 in_trace bit (36) aligned, /* (60) trace antirecursion flag */ 4 67 2 pad2 bit (36), /* (61) */ 4 68 2 pad5 pointer; /* (62) pointer to future stuff */ 4 69 4 70 /* The following offset refers to a table within the pl1 operator table. */ 4 71 4 72 dcl tv_offset fixed bin init (361) internal static; 4 73 /* (551) octal */ 4 74 4 75 4 76 /* The following constants are offsets within this transfer vector table. */ 4 77 4 78 dcl ( 4 79 call_offset fixed bin init (271), 4 80 push_offset fixed bin init (272), 4 81 return_offset fixed bin init (273), 4 82 return_no_pop_offset fixed bin init (274), 4 83 entry_offset fixed bin init (275) 4 84 ) internal static; 4 85 4 86 4 87 4 88 4 89 4 90 /* The following declaration is an overlay of the whole stack header. Procedures which 4 91* move the whole stack header should use this overlay. 4 92**/ 4 93 4 94 dcl stack_header_overlay (size (stack_header)) fixed bin based (sb); 4 95 4 96 4 97 4 98 /* END INCLUDE FILE ... stack_header.incl.pl1 */ 113 114 /* */ 5 1 /* BEGIN INCLUDE FILE ... stack_frame.incl.pl1 ... */ 5 2 5 3 /* format: off */ 5 4 5 5 /* Modified: 16 Dec 1977, D. Levin - to add fio_ps_ptr and pl1_ps_ptr */ 5 6 /* Modified: 3 Feb 1978, P. Krupp - to add run_unit_manager bit & main_proc bit */ 5 7 /* Modified: 21 March 1978, D. Levin - change fio_ps_ptr to support_ptr */ 5 8 /* Modified: 03/01/84, S. Herbst - Added RETURN_PTR_MASK */ 5 9 5 10 5 11 /****^ HISTORY COMMENTS: 5 12* 1) change(86-09-15,Kissel), approve(86-09-15,MCR7473), 5 13* audit(86-10-01,Fawcett), install(86-11-03,MR12.0-1206): 5 14* Modified to add constants for the translator_id field in the stack_frame 5 15* structure. 5 16* END HISTORY COMMENTS */ 5 17 5 18 5 19 dcl RETURN_PTR_MASK bit (72) int static options (constant) /* mask to be AND'd with stack_frame.return_ptr */ 5 20 init ("777777777777777777000000"b3); /* when copying, to ignore bits that a call fills */ 5 21 /* with indicators (nonzero for Fortran hexfp caller) */ 5 22 /* say: unspec(ptr) = unspec(stack_frame.return_ptr) & RETURN_PTR_MASK; */ 5 23 5 24 dcl TRANSLATOR_ID_PL1V2 bit (18) internal static options (constant) init ("000000"b3); 5 25 dcl TRANSLATOR_ID_ALM bit (18) internal static options (constant) init ("000001"b3); 5 26 dcl TRANSLATOR_ID_PL1V1 bit (18) internal static options (constant) init ("000002"b3); 5 27 dcl TRANSLATOR_ID_SIGNAL_CALLER bit (18) internal static options (constant) init ("000003"b3); 5 28 dcl TRANSLATOR_ID_SIGNALLER bit (18) internal static options (constant) init ("000004"b3); 5 29 5 30 5 31 dcl sp pointer; /* pointer to beginning of stack frame */ 5 32 5 33 dcl stack_frame_min_length fixed bin static init(48); 5 34 5 35 5 36 dcl 1 stack_frame based(sp) aligned, 5 37 2 pointer_registers(0 : 7) ptr, 5 38 2 prev_sp pointer, 5 39 2 next_sp pointer, 5 40 2 return_ptr pointer, 5 41 2 entry_ptr pointer, 5 42 2 operator_and_lp_ptr ptr, /* serves as both */ 5 43 2 arg_ptr pointer, 5 44 2 static_ptr ptr unaligned, 5 45 2 support_ptr ptr unal, /* only used by fortran I/O */ 5 46 2 on_unit_relp1 bit(18) unaligned, 5 47 2 on_unit_relp2 bit(18) unaligned, 5 48 2 translator_id bit(18) unaligned, /* Translator ID (see constants above) 5 49* 0 => PL/I version II 5 50* 1 => ALM 5 51* 2 => PL/I version I 5 52* 3 => signal caller frame 5 53* 4 => signaller frame */ 5 54 2 operator_return_offset bit(18) unaligned, 5 55 2 x(0: 7) bit(18) unaligned, /* index registers */ 5 56 2 a bit(36), /* accumulator */ 5 57 2 q bit(36), /* q-register */ 5 58 2 e bit(36), /* exponent */ 5 59 2 timer bit(27) unaligned, /* timer */ 5 60 2 pad bit(6) unaligned, 5 61 2 ring_alarm_reg bit(3) unaligned; 5 62 5 63 5 64 dcl 1 stack_frame_flags based(sp) aligned, 5 65 2 pad(0 : 7) bit(72), /* skip over prs */ 5 66 2 xx0 bit(22) unal, 5 67 2 main_proc bit(1) unal, /* on if frame belongs to a main procedure */ 5 68 2 run_unit_manager bit(1) unal, /* on if frame belongs to run unit manager */ 5 69 2 signal bit(1) unal, /* on if frame belongs to logical signal_ */ 5 70 2 crawl_out bit(1) unal, /* on if this is a signal caller frame */ 5 71 2 signaller bit(1) unal, /* on if next frame is signaller's */ 5 72 2 link_trap bit(1) unal, /* on if this frame was made by the linker */ 5 73 2 support bit(1) unal, /* on if frame belongs to a support proc */ 5 74 2 condition bit(1) unal, /* on if condition established in this frame */ 5 75 2 xx0a bit(6) unal, 5 76 2 xx1 fixed bin, 5 77 2 xx2 fixed bin, 5 78 2 xx3 bit(25) unal, 5 79 2 old_crawl_out bit (1) unal, /* on if this is a signal caller frame */ 5 80 2 old_signaller bit(1) unal, /* on if next frame is signaller's */ 5 81 2 xx3a bit(9) unaligned, 5 82 2 xx4(9) bit(72) aligned, 5 83 2 v2_pl1_op_ret_base ptr, /* When a V2 PL/I program calls an operator the 5 84* * operator puts a pointer to the base of 5 85* * the calling procedure here. (text base ptr) */ 5 86 2 xx5 bit(72) aligned, 5 87 2 pl1_ps_ptr ptr; /* ptr to ps for this frame; also used by fio. */ 5 88 5 89 /* format: on */ 5 90 5 91 /* END INCLUDE FILE ... stack_frame.incl.pl1 */ 115 116 /* */ 117 sp = arg_sp; /* Copy arguments. */ 118 119 sntp = arg_snt_ptr; 120 121 122 snt.sp = sp; /* Save pointer to this stack frame. */ 123 124 125 call get_proc_ptr; /* get a pointer to the point */ 126 /* where the frame was exited */ 127 128 if procedure_ptr = null() 129 130 /* Pointer is either invalid or is null. Set up null SNT data. */ 131 132 then do; 133 bad_proc_ptr: snt.ent_pt_name, 134 snt.ent_name = "(unknown procedure)"; 135 snt.dir_name = " "; 136 snt.pp, 137 snt.lp, 138 snt.symp = null(); 139 snt.symflag = "0"b; 140 return; 141 end; 142 143 144 145 /* Procedure pointer is OK. Fill with what should be good data. */ 146 147 snt.symflag = "1"b; /* Indicate that we don't have a symbol 148* * table pointer yet. */ 149 150 snt.symp = null(); 151 152 153 /* We will get the lot pointer for this procedure from the actual entry in the 154** lot for this procedure. We can get a pointer to the beginning of the lot from 155** the stack header. 156**/ 157 158 lot_ptr = ptr( sp, 0 ) -> stack_header.lot_ptr; 159 160 proc_segno = fixed ( baseno( procedure_ptr )); 161 162 snt.lp = ptr( baseptr( lot_ptr -> lot_array(proc_segno).segno), 163 lot_ptr -> lot_array(proc_segno).offset ); 164 165 isot_ptr = ptr (sp, 0) -> stack_header.isot_ptr; 166 snt.static_ptr = ptr( baseptr( isot_ptr -> lot_array(proc_segno).segno), 167 isot_ptr -> lot_array(proc_segno).offset ); 168 169 170 snt.pp = procedure_ptr; 171 172 173 /* For crawl-out frame don't try to get pathname, just stuff it in */ 174 175 if fixed( sp -> stack_frame.translator_id, 18) = 3 176 then do; 177 178 snt.ent_pt_name, snt.ent_name = "signal_caller"; 179 180 snt.dir_name = "signal_caller_directory"; 181 182 return; 183 end; 184 185 /* Get the path name of the procedure. If we can't get the path name then see 186** if the frame belongs to the signaller. If it doesn't then we don't know who 187** it belongs to. 188**/ 189 190 call hcs_$fs_get_path_name( procedure_ptr, snt.dir_name, dummy, snt.ent_name, code ); 191 192 if code ^= 0 /* Did we get a path name. */ 193 194 then do; /* NO, check for signaller. */ 195 196 if fixed (sp -> stack_frame.translator_id, 18) = 4 197 198 199 then do; /* It is the signaller. */ 200 201 snt.ent_pt_name, snt.ent_name = "return_to_ring_0_"; 202 203 snt.dir_name = "signaller_directory"; 204 205 return; 206 end; 207 208 209 else do; /* It isn't the signaller. */ 210 211 snt.ent_name = "(unknown procedure)"; 212 213 snt.dir_name = " "; 214 215 end; 216 217 end; 218 219 220 /* Now try to get the entry point name of the procedure. If we can't 221** get it, we'll just use the entry name of the segment. 222**/ 223 224 if ^situation.entry_ptr_bad then do; /* don't bother if we don't have entry ptr */ 225 226 call get_entry_name_ (sp -> stack_frame.entry_ptr, 227 snt.ent_pt_name, proc_segno, 228 dum_string, code ); 229 230 if code = 0 then return; 231 end; 232 233 snt.ent_pt_name = snt.ent_name; /* couldn't get entry name */ 234 235 return; 236 237 238 proc_ptr: entry (arg_sp, arg_pp); 239 240 /* entry to get just a procedure pointer */ 241 242 dcl arg_pp ptr; 243 244 sp = arg_sp; 245 246 call get_proc_ptr; 247 248 arg_pp = procedure_ptr; 249 return; 250 251 252 get_proc_ptr: proc; 253 254 /* internal procedure to figure out where a stack frame comes from */ 255 256 call find_condition_info_ ( sp, addr(cond_info), code); 257 /* get stuff that stack_frame_exit_ wants */ 258 259 /* now let stack_frae_exit_ do the real work */ 260 261 call stack_frame_exit_ (sp, cond_info.mcptr, cond_info.wcptr, 262 (cond_info.crawlout), procedure_ptr, dum_string, 263 addr(situation)); 264 265 if situation.bad_frame | addr (procedure_ptr) -> its.its_mod ^= "100011"b 266 /* no good */ 267 then procedure_ptr = null; 268 269 return; 270 end; 271 272 end db_fill_snt; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/04/86 1033.9 db_fill_snt.pl1 >special_ldd>install>MR12.0-1206>db_fill_snt.pl1 60 1 05/06/74 1741.0 cond_info.incl.pl1 >ldd>include>cond_info.incl.pl1 109 2 11/06/75 1110.0 db_snt.incl.pl1 >ldd>include>db_snt.incl.pl1 111 3 11/26/79 1320.6 its.incl.pl1 >ldd>include>its.incl.pl1 113 4 11/04/86 1324.3 stack_header.incl.pl1 >special_ldd>install>MR12.0-1206>stack_header.incl.pl1 115 5 11/03/86 1114.7 stack_frame.incl.pl1 >special_ldd>install>MR12.0-1206>stack_frame.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. addr builtin function dcl 101 ref 256 256 261 261 265 arg_pp parameter pointer dcl 242 set ref 238 248* arg_snt_ptr parameter pointer dcl 22 ref 11 119 arg_sp parameter pointer dcl 22 ref 11 117 238 244 bad_frame 000122 automatic bit(1) level 2 packed unaligned dcl 52 set ref 265 baseno builtin function dcl 101 ref 160 baseptr builtin function dcl 101 ref 162 166 code 000100 automatic fixed bin(17,0) dcl 34 set ref 190* 192 226* 230 256* cond_info 000124 automatic structure level 1 dcl 59 set ref 256 256 crawlout 22 000124 automatic bit(1) level 3 packed unaligned dcl 59 set ref 261 dir_name 20 based char(168) level 2 dcl 2-9 set ref 135* 180* 190* 203* 213* dum_string 000112 automatic char(32) dcl 46 set ref 226* 261* dummy 000101 automatic fixed bin(17,0) dcl 34 set ref 190* ent_name 10 based char(32) level 2 dcl 2-9 set ref 133* 178* 190* 201* 211* 233 ent_pt_name based char(32) level 2 dcl 2-9 set ref 133* 178* 201* 226* 233* entry_ptr 26 based pointer level 2 dcl 5-36 set ref 226* entry_ptr_bad 0(05) 000122 automatic bit(1) level 2 packed unaligned dcl 52 set ref 224 find_condition_info_ 000012 constant entry external dcl 85 ref 256 fixed builtin function dcl 101 ref 160 175 196 flags 22 000124 automatic structure level 2 dcl 59 get_entry_name_ 000016 constant entry external dcl 95 ref 226 hcs_$fs_get_path_name 000010 constant entry external dcl 85 ref 190 isot_ptr 000104 automatic pointer dcl 39 in procedure "db_fill_snt" set ref 165* 166 166 isot_ptr 52 based pointer level 2 in structure "stack_header" dcl 4-26 in procedure "db_fill_snt" ref 165 its based structure level 1 dcl 3-5 its_mod 0(30) based bit(6) level 2 packed unaligned dcl 3-5 ref 265 lot_array based structure array level 1 dcl 69 lot_ptr 26 based pointer level 2 in structure "stack_header" dcl 4-26 in procedure "db_fill_snt" ref 158 lot_ptr 000102 automatic pointer dcl 39 in procedure "db_fill_snt" set ref 158* 162 162 lp 76 based pointer level 2 dcl 2-9 set ref 136* 162* mcptr 000124 automatic pointer level 2 dcl 59 set ref 261* null builtin function dcl 101 ref 128 136 150 265 offset 0(18) based bit(18) array level 2 packed unaligned dcl 69 ref 162 166 pp 72 based pointer level 2 dcl 2-9 set ref 136* 170* proc_segno 000106 automatic fixed bin(17,0) dcl 39 set ref 160* 162 162 166 166 226* procedure_ptr 000110 automatic pointer dcl 46 set ref 128 160 170 190* 248 261* 265 265* ptr builtin function dcl 101 ref 158 162 165 166 segno based bit(18) array level 2 packed unaligned dcl 69 ref 162 166 situation 000122 automatic structure level 1 dcl 52 set ref 261 261 snt based structure level 1 dcl 2-9 sntp 000156 automatic pointer dcl 2-7 set ref 119* 122 133 133 135 136 136 136 139 147 150 162 166 170 178 178 180 190 190 201 201 203 211 213 226 233 233 sp 74 based pointer level 2 in structure "snt" dcl 2-9 in procedure "db_fill_snt" set ref 122* sp 000160 automatic pointer dcl 5-31 in procedure "db_fill_snt" set ref 117* 122 158 165 175 196 226 244* 256* 261* stack_frame based structure level 1 dcl 5-36 stack_frame_exit_ 000014 constant entry external dcl 91 ref 261 stack_header based structure level 1 dcl 4-26 static_ptr 106 based pointer level 2 dcl 2-9 set ref 166* symflag 102 based bit(1) level 2 packed unaligned dcl 2-9 set ref 139* 147* symp 100 based pointer level 2 dcl 2-9 set ref 136* 150* translator_id 37 based bit(18) level 2 packed unaligned dcl 5-36 ref 175 196 wcptr 16 000124 automatic pointer level 2 dcl 59 set ref 261* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ITP_MODIFIER internal static bit(6) initial unaligned dcl 3-56 ITS_MODIFIER internal static bit(6) initial unaligned dcl 3-55 RETURN_PTR_MASK internal static bit(72) initial unaligned dcl 5-19 TRANSLATOR_ID_ALM internal static bit(18) initial unaligned dcl 5-25 TRANSLATOR_ID_PL1V1 internal static bit(18) initial unaligned dcl 5-26 TRANSLATOR_ID_PL1V2 internal static bit(18) initial unaligned dcl 5-24 TRANSLATOR_ID_SIGNALLER internal static bit(18) initial unaligned dcl 5-28 TRANSLATOR_ID_SIGNAL_CALLER internal static bit(18) initial unaligned dcl 5-27 based_name_string based char unaligned dcl 77 call_offset internal static fixed bin(17,0) initial dcl 4-78 db_stack_util$procedure_ptr 000000 constant entry external dcl 85 entry_offset internal static fixed bin(17,0) initial dcl 4-78 itp based structure level 1 dcl 3-18 itp_unsigned based structure level 1 dcl 3-43 its_unsigned based structure level 1 dcl 3-30 push_offset internal static fixed bin(17,0) initial dcl 4-78 rel builtin function dcl 101 return_no_pop_offset internal static fixed bin(17,0) initial dcl 4-78 return_offset internal static fixed bin(17,0) initial dcl 4-78 sb automatic pointer dcl 4-24 stack_frame_flags based structure level 1 dcl 5-64 stack_frame_min_length internal static fixed bin(17,0) initial dcl 5-33 stack_header_overlay based fixed bin(17,0) array dcl 4-94 tv_offset internal static fixed bin(17,0) initial dcl 4-72 NAMES DECLARED BY EXPLICIT CONTEXT. bad_proc_ptr 000065 constant label dcl 133 db_fill_snt 000043 constant entry external dcl 11 get_proc_ptr 000333 constant entry internal dcl 252 ref 125 246 proc_ptr 000315 constant entry external dcl 238 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 510 530 414 520 Length 1010 414 20 244 74 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME db_fill_snt 172 external procedure is an external procedure. get_proc_ptr internal procedure shares stack frame of external procedure db_fill_snt. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME db_fill_snt 000100 code db_fill_snt 000101 dummy db_fill_snt 000102 lot_ptr db_fill_snt 000104 isot_ptr db_fill_snt 000106 proc_segno db_fill_snt 000110 procedure_ptr db_fill_snt 000112 dum_string db_fill_snt 000122 situation db_fill_snt 000124 cond_info db_fill_snt 000156 sntp db_fill_snt 000160 sp db_fill_snt THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return_mac ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. find_condition_info_ get_entry_name_ hcs_$fs_get_path_name stack_frame_exit_ NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 11 000037 117 000050 119 000054 122 000057 125 000060 128 000061 133 000065 135 000074 136 000077 139 000103 140 000105 147 000106 150 000111 158 000113 160 000116 162 000122 165 000134 166 000136 170 000146 175 000150 178 000156 180 000164 182 000167 190 000170 192 000220 196 000222 201 000227 203 000236 205 000241 211 000242 213 000246 224 000251 226 000254 230 000304 233 000306 235 000312 238 000313 244 000322 246 000326 248 000327 249 000332 252 000333 256 000334 261 000351 265 000401 269 000412 ----------------------------------------------------------- Historical Background This edition of the Multics software materials and documentation is provided and donated to Massachusetts Institute of Technology by Group BULL including BULL HN Information Systems Inc. as a contribution to computer science knowledge. This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology, Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell BULL Inc., Groupe BULL and BULL HN Information Systems Inc. to the development of this operating system. Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970), renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership of Professor Fernando Jose Corbato. Users consider that Multics provided the best software architecture for managing computer hardware properly and for executing programs. Many subsequent operating systems incorporated Multics principles. Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. . ----------------------------------------------------------- Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without fee is hereby granted,provided that the below copyright notice and historical background appear in all copies and that both the copyright notice and historical background and this permission notice appear in supporting documentation, and that the names of MIT, HIS, BULL or BULL HN not be used in advertising or publicity pertaining to distribution of the programs without specific prior written permission. Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc. Copyright 2006 by BULL HN Information Systems Inc. Copyright 2006 by Bull SAS All Rights Reserved