COMPILATION LISTING OF SEGMENT lot_fault_handler_ Compiled by: Multics PL/I Compiler, Release 32f, of October 9, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 11/11/89 0956.9 mst Sat Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 13 lot_fault_handler_: 14 proc (mcptr, condname, infoptr, wcptr, continue_sw); 15 16 /* This procedure is invoked when a reference to the LOT causes a lot_fault. This usually happens in a run 17* unit when a segment has had its LOT entry reset to a lot_fault but there are already snapped links to it, 18* so that it gets executed without the intervention of the linker. 19**/ 20 21 /* coded March 1977 by Melanie Weaver */ 22 /* modified October 1979 by Melanie Weaver to call link_trap_caller_ */ 23 24 25 26 dcl (mcptr, infoptr, wcptr) 27 ptr; 28 dcl condname char (*); 29 dcl continue_sw bit (1) aligned; 30 31 dcl (ring, level) fixed bin; 32 33 dcl segno fixed bin (18); 34 dcl header_ptr ptr; 35 dcl segptr ptr; 36 dcl code fixed bin (35); 37 dcl (addr, baseptr, bin, null, ptr, rel) 38 builtin; 39 40 dcl get_ring_ entry () returns (fixed bin); 41 dcl hcs_$combine_linkage entry (ptr, fixed bin, fixed bin (35)); 42 dcl hcs_$level_get entry () returns (fixed bin); 43 dcl hcs_$level_set entry (fixed bin); 44 dcl link_trap_caller_ entry (ptr, ptr, ptr, ptr, ptr, ptr, ptr); 45 dcl pds$stacks (0:7) ptr ext; 46 47 48 scup = addr (mcptr -> mc.scu (0)); 49 ring = bin (scup -> scu.trr, 3); 50 if bin (scup -> scu.prr, 3) = 0 51 then do; 52 if get_ring_ () = 0 53 then sb = pds$stacks (ring); /* can only reference pds in ring 0 */ 54 else do; /* shouldn't happen--would be crawlout from ring 0 */ 55 continue_sw = "1"b; 56 return; 57 end; 58 end; 59 else sb = ptr (mcptr -> mc.prs (6), 0); 60 61 level = hcs_$level_get (); 62 if level > ring 63 then call hcs_$level_set (ring); 64 65 segno = bin (scup -> scu.ca, 18) - bin (rel (sb -> stack_header.lot_ptr), 18); 66 segptr = baseptr (segno); 67 68 call hcs_$combine_linkage (segptr, ring, code); 69 70 if level ^= ring 71 then call hcs_$level_set (level); 72 73 if code ^= 0 74 then continue_sw = "1"b; 75 76 else if (level = ring) & (ring ^= 0) 77 then do; 78 79 /* If there is a trap at first reference and we are not in ring 0, 80* call link_trap_caller_ to handle it. If it becomes necessary to handle 81* this in ring 0, hcs_$combine_linkage will have to be changed to 82* call trap_caller_caller_ when there is a trap at first reference. */ 83 84 header_ptr = sb -> stack_header.lot_ptr -> lot.lp (segno); 85 /* get ptr to beginning of linkage section */ 86 if header_ptr -> virgin_linkage_header.first_ref_relp ^= "0"b 87 then call link_trap_caller_ (null, mcptr, header_ptr, null, null, null, null); 88 end; 89 90 return; 91 92 /* */ 1 1 /* */ 1 2 /* BEGIN INCLUDE FILE mc.incl.pl1 Created Dec 72 for 6180 - WSS. */ 1 3 /* Modified 06/07/76 by Greenberg for mc.resignal */ 1 4 /* Modified 07/07/76 by Morris for fault register data */ 1 5 /* Modified 08/28/80 by J. A. Bush for the DPS8/70M CVPU */ 1 6 /* Modified '82 to make values constant */ 1 7 1 8 /* words 0-15 pointer registers */ 1 9 1 10 dcl mcp ptr; 1 11 1 12 dcl 1 mc based (mcp) aligned, 1 13 2 prs (0:7) ptr, /* POINTER REGISTERS */ 1 14 (2 regs, /* registers */ 1 15 3 x (0:7) bit (18), /* index registers */ 1 16 3 a bit (36), /* accumulator */ 1 17 3 q bit (36), /* q-register */ 1 18 3 e bit (8), /* exponent */ 1 19 3 pad1 bit (28), 1 20 3 t bit (27), /* timer register */ 1 21 3 pad2 bit (6), 1 22 3 ralr bit (3), /* ring alarm register */ 1 23 1 24 2 scu (0:7) bit (36), 1 25 1 26 2 mask bit (72), /* mem controller mask at time of fault */ 1 27 2 ips_temp bit (36), /* Temporary storage for IPS info */ 1 28 2 errcode fixed bin (35), /* fault handler's error code */ 1 29 2 fim_temp, 1 30 3 unique_index bit (18) unal, /* unique index for restarting faults */ 1 31 3 resignal bit (1) unal, /* recompute signal name with fcode below */ 1 32 3 fcode bit (17) unal, /* fault code used as index to FIM table and SCT */ 1 33 2 fault_reg bit (36), /* fault register */ 1 34 2 pad2 bit (1), 1 35 2 cpu_type fixed bin (2) unsigned, /* L68 = 0, DPS8/70M = 1 */ 1 36 2 ext_fault_reg bit (15), /* extended fault reg for DPS8/70M CPU */ 1 37 2 fault_time bit (54), /* time of fault */ 1 38 1 39 2 eis_info (0:7) bit (36)) unaligned; 1 40 1 41 1 42 dcl (apx fixed bin init (0), 1 43 abx fixed bin init (1), 1 44 bpx fixed bin init (2), 1 45 bbx fixed bin init (3), 1 46 lpx fixed bin init (4), 1 47 lbx fixed bin init (5), 1 48 spx fixed bin init (6), 1 49 sbx fixed bin init (7)) internal static options (constant); 1 50 1 51 1 52 1 53 1 54 dcl scup ptr; 1 55 1 56 dcl 1 scu based (scup) aligned, /* SCU DATA */ 1 57 1 58 1 59 /* WORD (0) */ 1 60 1 61 (2 ppr, /* PROCEDURE POINTER REGISTER */ 1 62 3 prr bit (3), /* procedure ring register */ 1 63 3 psr bit (15), /* procedure segment register */ 1 64 3 p bit (1), /* procedure privileged bit */ 1 65 1 66 2 apu, /* APPENDING UNIT STATUS */ 1 67 3 xsf bit (1), /* ext seg flag - IT modification */ 1 68 3 sdwm bit (1), /* match in SDW Ass. Mem. */ 1 69 3 sd_on bit (1), /* SDW Ass. Mem. ON */ 1 70 3 ptwm bit (1), /* match in PTW Ass. Mem. */ 1 71 3 pt_on bit (1), /* PTW Ass. Mem. ON */ 1 72 3 pi_ap bit (1), /* Instr Fetch or Append cycle */ 1 73 3 dsptw bit (1), /* Fetch of DSPTW */ 1 74 3 sdwnp bit (1), /* Fetch of SDW non paged */ 1 75 3 sdwp bit (1), /* Fetch of SDW paged */ 1 76 3 ptw bit (1), /* Fetch of PTW */ 1 77 3 ptw2 bit (1), /* Fetch of pre-paged PTW */ 1 78 3 fap bit (1), /* Fetch of final address paged */ 1 79 3 fanp bit (1), /* Fetch of final address non-paged */ 1 80 3 fabs bit (1), /* Fetch of final address absolute */ 1 81 1 82 2 fault_cntr bit (3), /* number of retrys of EIS instructions */ 1 83 1 84 1 85 /* WORD (1) */ 1 86 1 87 2 fd, /* FAULT DATA */ 1 88 3 iro bit (1), /* illegal ring order */ 1 89 3 oeb bit (1), /* out of execute bracket */ 1 90 3 e_off bit (1), /* no execute */ 1 91 3 orb bit (1), /* out of read bracket */ 1 92 3 r_off bit (1), /* no read */ 1 93 3 owb bit (1), /* out of write bracket */ 1 94 3 w_off bit (1), /* no write */ 1 95 3 no_ga bit (1), /* not a gate */ 1 96 3 ocb bit (1), /* out of call bracket */ 1 97 3 ocall bit (1), /* outward call */ 1 98 3 boc bit (1), /* bad outward call */ 1 99 3 inret bit (1), /* inward return */ 1 100 3 crt bit (1), /* cross ring transfer */ 1 101 3 ralr bit (1), /* ring alarm register */ 1 102 3 am_er bit (1), /* associative memory fault */ 1 103 3 oosb bit (1), /* out of segment bounds */ 1 104 3 paru bit (1), /* processor parity upper */ 1 105 3 parl bit (1), /* processor parity lower */ 1 106 3 onc_1 bit (1), /* op not complete type 1 */ 1 107 3 onc_2 bit (1), /* op not complete type 2 */ 1 108 1 109 2 port_stat, /* PORT STATUS */ 1 110 3 ial bit (4), /* illegal action lines */ 1 111 3 iac bit (3), /* illegal action channel */ 1 112 3 con_chan bit (3), /* connect channel */ 1 113 1 114 2 fi_num bit (5), /* (fault/interrupt) number */ 1 115 2 fi_flag bit (1), /* 1 => fault, 0 => interrupt */ 1 116 1 117 1 118 /* WORD (2) */ 1 119 1 120 2 tpr, /* TEMPORARY POINTER REGISTER */ 1 121 3 trr bit (3), /* temporary ring register */ 1 122 3 tsr bit (15), /* temporary segment register */ 1 123 1 124 2 pad2 bit (9), 1 125 1 126 2 cpu_no bit (3), /* CPU number */ 1 127 1 128 2 delta bit (6), /* tally modification DELTA */ 1 129 1 130 1 131 /* WORD (3) */ 1 132 1 133 2 word3 bit (18), 1 134 1 135 2 tsr_stat, /* TSR STATUS for 1,2,&3 word instructions */ 1 136 3 tsna, /* Word 1 status */ 1 137 4 prn bit (3), /* Word 1 PR number */ 1 138 4 prv bit (1), /* Word 1 PR valid bit */ 1 139 3 tsnb, /* Word 2 status */ 1 140 4 prn bit (3), /* Word 2 PR number */ 1 141 4 prv bit (1), /* Word 2 PR valid bit */ 1 142 3 tsnc, /* Word 3 status */ 1 143 4 prn bit (3), /* Word 3 PR number */ 1 144 4 prv bit (1), /* Word 3 PR valid bit */ 1 145 1 146 2 tpr_tbr bit (6), /* TPR.TBR field */ 1 147 1 148 1 149 /* WORD (4) */ 1 150 1 151 2 ilc bit (18), /* INSTRUCTION COUNTER */ 1 152 1 153 2 ir, /* INDICATOR REGISTERS */ 1 154 3 zero bit (1), /* zero indicator */ 1 155 3 neg bit (1), /* negative indicator */ 1 156 3 carry bit (1), /* carryry indicator */ 1 157 3 ovfl bit (1), /* overflow indicator */ 1 158 3 eovf bit (1), /* eponent overflow */ 1 159 3 eufl bit (1), /* exponent underflow */ 1 160 3 oflm bit (1), /* overflow mask */ 1 161 3 tro bit (1), /* tally runout */ 1 162 3 par bit (1), /* parity error */ 1 163 3 parm bit (1), /* parity mask */ 1 164 3 bm bit (1), /* ^bar mode */ 1 165 3 tru bit (1), /* truncation mode */ 1 166 3 mif bit (1), /* multi-word instruction mode */ 1 167 3 abs bit (1), /* absolute mode */ 1 168 3 hex bit (1), /* hexadecimal exponent mode */ 1 169 3 pad bit (3), 1 170 1 171 1 172 /* WORD (5) */ 1 173 1 174 2 ca bit (18), /* COMPUTED ADDRESS */ 1 175 1 176 2 cu, /* CONTROL UNIT STATUS */ 1 177 3 rf bit (1), /* on first cycle of repeat instr */ 1 178 3 rpt bit (1), /* repeat instruction */ 1 179 3 rd bit (1), /* repeat double instruction */ 1 180 3 rl bit (1), /* repeat link instruciton */ 1 181 3 pot bit (1), /* IT modification */ 1 182 3 pon bit (1), /* return type instruction */ 1 183 3 xde bit (1), /* XDE from Even location */ 1 184 3 xdo bit (1), /* XDE from Odd location */ 1 185 3 poa bit (1), /* operation preparation */ 1 186 3 rfi bit (1), /* tells CPU to refetch instruction */ 1 187 3 its bit (1), /* ITS modification */ 1 188 3 if bit (1), /* fault occured during instruction fetch */ 1 189 1 190 2 cpu_tag bit (6)) unaligned, /* computed tag field */ 1 191 1 192 1 193 /* WORDS (6,7) */ 1 194 1 195 2 even_inst bit (36), /* even instruction of faulting pair */ 1 196 1 197 2 odd_inst bit (36); /* odd instruction of faulting pair */ 1 198 1 199 1 200 1 201 1 202 1 203 1 204 /* ALTERNATE SCU DECLARATION */ 1 205 1 206 1 207 dcl 1 scux based (scup) aligned, 1 208 1 209 (2 pad0 bit (36), 1 210 1 211 2 fd, /* GROUP II FAULT DATA */ 1 212 3 isn bit (1), /* illegal segment number */ 1 213 3 ioc bit (1), /* illegal op code */ 1 214 3 ia_am bit (1), /* illegal address - modifier */ 1 215 3 isp bit (1), /* illegal slave procedure */ 1 216 3 ipr bit (1), /* illegal procedure */ 1 217 3 nea bit (1), /* non existent address */ 1 218 3 oobb bit (1), /* out of bounds */ 1 219 3 pad bit (29), 1 220 1 221 2 pad2 bit (36), 1 222 1 223 2 pad3a bit (18), 1 224 1 225 2 tsr_stat (0:2), /* TSR STATUS as an ARRAY */ 1 226 3 prn bit (3), /* PR number */ 1 227 3 prv bit (1), /* PR valid bit */ 1 228 1 229 2 pad3b bit (6)) unaligned, 1 230 1 231 2 pad45 (0:1) bit (36), 1 232 1 233 2 instr (0:1) bit (36); /* Instruction ARRAY */ 1 234 1 235 1 236 1 237 /* END INCLUDE FILE mc.incl.pl1 */ 93 94 2 1 /* BEGIN INCLUDE FILE ... stack_header.incl.pl1 .. 3/72 Bill Silver */ 2 2 /* modified 7/76 by M. Weaver for *system links and more system use of areas */ 2 3 /* modified 3/77 by M. Weaver to add rnt_ptr */ 2 4 /* Modified April 1983 by C. Hornig for tasking */ 2 5 2 6 /****^ HISTORY COMMENTS: 2 7* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), 2 8* audit(86-08-05,Schroth), install(86-11-03,MR12.0-1206): 2 9* added the heap_header_ptr definition. 2 10* 2) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 2 11* audit(86-10-10,Fawcett), install(86-11-03,MR12.0-1206): 2 12* Modified to support control point management. These changes were actually 2 13* made in February 1985 by G. Palter. 2 14* 3) change(86-10-22,Fawcett), approve(86-10-22,MCR7473), 2 15* audit(86-10-22,Farley), install(86-11-03,MR12.0-1206): 2 16* Remove the old_lot pointer and replace it with cpm_data_ptr. Use the 18 2 17* bit pad after cur_lot_size for the cpm_enabled. This was done to save some 2 18* space int the stack header and change the cpd_ptr unal to cpm_data_ptr 2 19* (ITS pair). 2 20* END HISTORY COMMENTS */ 2 21 2 22 /* format: style2 */ 2 23 2 24 dcl sb ptr; /* the main pointer to the stack header */ 2 25 2 26 dcl 1 stack_header based (sb) aligned, 2 27 2 pad1 (4) fixed bin, /* (0) also used as arg list by outward_call_handler */ 2 28 2 cpm_data_ptr ptr, /* (4) pointer to control point which owns this stack */ 2 29 2 combined_stat_ptr ptr, /* (6) pointer to area containing separate static */ 2 30 2 clr_ptr ptr, /* (8) pointer to area containing linkage sections */ 2 31 2 max_lot_size fixed bin (17) unal, /* (10) DU number of words allowed in lot */ 2 32 2 main_proc_invoked fixed bin (11) unal, /* (10) DL nonzero if main procedure invoked in run unit */ 2 33 2 have_static_vlas bit (1) unal, /* (10) DL "1"b if (very) large arrays are being used in static */ 2 34 2 pad4 bit (2) unal, 2 35 2 run_unit_depth fixed bin (2) unal, /* (10) DL number of active run units stacked */ 2 36 2 cur_lot_size fixed bin (17) unal, /* (11) DU number of words (entries) in lot */ 2 37 2 cpm_enabled bit (18) unal, /* (11) DL non-zero if control point management is enabled */ 2 38 2 system_free_ptr ptr, /* (12) pointer to system storage area */ 2 39 2 user_free_ptr ptr, /* (14) pointer to user storage area */ 2 40 2 null_ptr ptr, /* (16) */ 2 41 2 stack_begin_ptr ptr, /* (18) pointer to first stack frame on the stack */ 2 42 2 stack_end_ptr ptr, /* (20) pointer to next useable stack frame */ 2 43 2 lot_ptr ptr, /* (22) pointer to the lot for the current ring */ 2 44 2 signal_ptr ptr, /* (24) pointer to signal procedure for current ring */ 2 45 2 bar_mode_sp ptr, /* (26) value of sp before entering bar mode */ 2 46 2 pl1_operators_ptr ptr, /* (28) pointer to pl1_operators_$operator_table */ 2 47 2 call_op_ptr ptr, /* (30) pointer to standard call operator */ 2 48 2 push_op_ptr ptr, /* (32) pointer to standard push operator */ 2 49 2 return_op_ptr ptr, /* (34) pointer to standard return operator */ 2 50 2 return_no_pop_op_ptr 2 51 ptr, /* (36) pointer to standard return / no pop operator */ 2 52 2 entry_op_ptr ptr, /* (38) pointer to standard entry operator */ 2 53 2 trans_op_tv_ptr ptr, /* (40) pointer to translator operator ptrs */ 2 54 2 isot_ptr ptr, /* (42) pointer to ISOT */ 2 55 2 sct_ptr ptr, /* (44) pointer to System Condition Table */ 2 56 2 unwinder_ptr ptr, /* (46) pointer to unwinder for current ring */ 2 57 2 sys_link_info_ptr ptr, /* (48) pointer to *system link name table */ 2 58 2 rnt_ptr ptr, /* (50) pointer to Reference Name Table */ 2 59 2 ect_ptr ptr, /* (52) pointer to event channel table */ 2 60 2 assign_linkage_ptr ptr, /* (54) pointer to storage for (obsolete) hcs_$assign_linkage */ 2 61 2 heap_header_ptr ptr, /* (56) pointer to the heap header for this ring */ 2 62 2 trace, 2 63 3 frames, 2 64 4 count fixed bin, /* (58) number of trace frames */ 2 65 4 top_ptr ptr unal, /* (59) pointer to last trace frame */ 2 66 3 in_trace bit (36) aligned, /* (60) trace antirecursion flag */ 2 67 2 pad2 bit (36), /* (61) */ 2 68 2 pad5 pointer; /* (62) pointer to future stuff */ 2 69 2 70 /* The following offset refers to a table within the pl1 operator table. */ 2 71 2 72 dcl tv_offset fixed bin init (361) internal static; 2 73 /* (551) octal */ 2 74 2 75 2 76 /* The following constants are offsets within this transfer vector table. */ 2 77 2 78 dcl ( 2 79 call_offset fixed bin init (271), 2 80 push_offset fixed bin init (272), 2 81 return_offset fixed bin init (273), 2 82 return_no_pop_offset fixed bin init (274), 2 83 entry_offset fixed bin init (275) 2 84 ) internal static; 2 85 2 86 2 87 2 88 2 89 2 90 /* The following declaration is an overlay of the whole stack header. Procedures which 2 91* move the whole stack header should use this overlay. 2 92**/ 2 93 2 94 dcl stack_header_overlay (size (stack_header)) fixed bin based (sb); 2 95 2 96 2 97 2 98 /* END INCLUDE FILE ... stack_header.incl.pl1 */ 95 96 97 3 1 /* BEGIN INCLUDE FILE -- lot.incl.pl1 S.Webber 9/74, Modified by R. Bratt 04/76, modified by M. Weaver 7/76 */ 3 2 /* modified by M. Weaver 3/77 */ 3 3 3 4 dcl lotp ptr; 3 5 3 6 dcl 1 lot based (lotp) aligned, 3 7 2 lp (0:9999) ptr unaligned; /* array of packed pointers to linkage sections */ 3 8 3 9 dcl lot_fault bit (36) aligned static options (constant) init ("111000000000000000000000000000000000"b); 3 10 /* lot fault has fault code = 0 and offset = 0 */ 3 11 3 12 dcl isotp ptr; 3 13 dcl 1 isot based (isotp) aligned, 3 14 2 isp (0:9999) ptr unaligned; 3 15 3 16 dcl 1 isot1 (0 :9999) aligned based, 3 17 2 flags unaligned, 3 18 3 fault bit (2) unaligned, 3 19 3 system bit (1) unaligned, 3 20 3 mbz bit (6) unaligned, 3 21 2 fault_code fixed bin (8) unaligned, 3 22 2 static_offset bit (18) unaligned; 3 23 3 24 3 25 /* END INCLUDE FILE lot.incl.pl1 */ 98 99 4 1 /* BEGIN INCLUDE FILE linkdcl.incl.pl1 --- last modified 15 Nov 1971 by C Garman */ 4 2 4 3 /* Last Modified (Date and Reason): 4 4* 6/75 by M.Weaver to add virgin_linkage_header declaration 4 5* 6/75 by S.Webber to comment existing structures better 4 6* 9/77 by M. Weaver to add run_depth to link 4 7* 2/83 by M. Weaver to add linkage header flags and change run_depth precision 4 8**/ 4 9 4 10 /* format: style3 */ 4 11 dcl 1 link based aligned, /* link pair in linkage section */ 4 12 2 head_ptr bit (18) unal, /* rel pointer to beginning of linkage section */ 4 13 2 ringno bit (3) unal, 4 14 2 mbz bit (6) unal, 4 15 2 run_depth fixed bin (2) unal, /* run unit depth, filled when link is snapped */ 4 16 2 ft2 bit (6) unal, /* fault tag. 46(8) if not snapped, 43(8) if snapped */ 4 17 2 exp_ptr bit (18) unal, /* pointer (rel to defs) of expression word */ 4 18 2 mbz2 bit (12) unal, 4 19 2 modifier bit (6) unal; /* modifier to be left in snapped link */ 4 20 4 21 dcl 1 exp_word based aligned, /* expression word in link definition */ 4 22 2 type_ptr bit (18) unal, /* pointer (rel to defs) of type pair structure */ 4 23 2 exp bit (18) unal; /* constant expression to be added in when snapping link */ 4 24 4 25 dcl 1 type_pair based aligned, /* type pair in link definition */ 4 26 2 type bit (18) unal, /* type of link. may be 1,2,3,4,5, or 6 */ 4 27 2 trap_ptr bit (18) unal, /* pointer (rel to defs) to the trap word */ 4 28 2 seg_ptr bit (18) unal, /* pointer to ACC reference name for segment referenced */ 4 29 2 ext_ptr bit (18) unal; /* pointer (rel to defs) of ACC segdef name */ 4 30 4 31 dcl 1 header based aligned, /* linkage block header */ 4 32 2 def_ptr ptr, /* pointer to definition section */ 4 33 2 symbol_ptr ptr unal, /* pointer to symbol section in object segment */ 4 34 2 original_linkage_ptr 4 35 ptr unal, /* pointer to linkage section in object segment */ 4 36 2 unused bit (72), 4 37 2 stats, 4 38 3 begin_links bit (18) unal, /* offset (rel to this section) of first link */ 4 39 3 block_length bit (18) unal, /* number of words in this linkage section */ 4 40 3 segment_number 4 41 bit (18) unal, /* text segment number associated with this section */ 4 42 3 static_length bit (18) unal; /* number of words of static for this segment */ 4 43 4 44 dcl 1 linkage_header_flags 4 45 aligned based, /* overlay of def_ptr for flags */ 4 46 2 pad1 bit (28) unaligned, /* flags are in first word */ 4 47 2 static_vlas bit (1) unaligned, /* static section "owns" some LA/VLA segments */ 4 48 2 perprocess_static 4 49 bit (1) unaligned, /* 1 copy of static section is used by all tasks/run units */ 4 50 2 pad2 bit (6) unaligned; 4 51 4 52 dcl 1 virgin_linkage_header 4 53 aligned based, /* template for linkage header in object segment */ 4 54 2 pad bit (30) unaligned, /* is filled in by linker */ 4 55 2 defs_in_link bit (6) unaligned, /* =o20 if defs in linkage (nonstandard) */ 4 56 2 def_offset bit (18) unaligned, /* offset of definition section */ 4 57 2 first_ref_relp bit (18) unaligned, /* offset of trap-at-first-reference offset array */ 4 58 2 filled_in_later bit (144), 4 59 2 link_begin bit (18) unaligned, /* offset of first link */ 4 60 2 linkage_section_lng 4 61 bit (18) unaligned, /* length of linkage section */ 4 62 2 segno_pad bit (18) unaligned, /* will be segment number of copied linkage */ 4 63 2 static_length bit (18) unaligned; /* length of static section */ 4 64 4 65 4 66 dcl 1 trap_word based aligned, /* trap word in link definition */ 4 67 2 call_ptr bit (18) unal, /* pointer (rel to link) of link to trap procedure */ 4 68 2 arg_ptr bit (18) unal; /* pointer (rel to link) of link to arg info for trap proc */ 4 69 4 70 dcl 1 name based aligned, /* storage of ASCII names in definitions */ 4 71 2 nchars bit (9) unaligned, /* number of characters in name */ 4 72 2 char_string char (31) unaligned; /* 31-character name */ 4 73 4 74 /* END INCLUDE FILE linkdcl.incl.pl1 */ 100 101 102 103 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/11/89 0804.9 lot_fault_handler_.pl1 >spec>install>1110>lot_fault_handler_.pl1 93 1 12/15/83 1100.4 mc.incl.pl1 >ldd>include>mc.incl.pl1 95 2 11/07/86 1550.3 stack_header.incl.pl1 >ldd>include>stack_header.incl.pl1 98 3 08/05/77 1022.4 lot.incl.pl1 >ldd>include>lot.incl.pl1 100 4 07/27/83 0910.0 linkdcl.incl.pl1 >ldd>include>linkdcl.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 37 ref 48 baseptr builtin function dcl 37 ref 66 bin builtin function dcl 37 ref 49 50 65 65 ca 5 based bit(18) level 2 packed packed unaligned dcl 1-56 ref 65 code 000110 automatic fixed bin(35,0) dcl 36 set ref 68* 73 condname parameter char packed unaligned dcl 28 ref 13 continue_sw parameter bit(1) dcl 29 set ref 13 55* 73* first_ref_relp 1(18) based bit(18) level 2 packed packed unaligned dcl 4-52 ref 86 get_ring_ 000010 constant entry external dcl 40 ref 52 hcs_$combine_linkage 000012 constant entry external dcl 41 ref 68 hcs_$level_get 000014 constant entry external dcl 42 ref 61 hcs_$level_set 000016 constant entry external dcl 43 ref 62 70 header_ptr 000104 automatic pointer dcl 34 set ref 84* 86 86* infoptr parameter pointer dcl 26 ref 13 level 000101 automatic fixed bin(17,0) dcl 31 set ref 61* 62 70 70* 76 link_trap_caller_ 000020 constant entry external dcl 44 ref 86 lot based structure level 1 dcl 3-6 lot_ptr 26 based pointer level 2 dcl 2-26 ref 65 84 lp based pointer array level 2 packed packed unaligned dcl 3-6 ref 84 mc based structure level 1 dcl 1-12 mcptr parameter pointer dcl 26 set ref 13 48 59 86* null builtin function dcl 37 ref 86 86 86 86 86 86 86 86 86 86 pds$stacks 000022 external static pointer array dcl 45 ref 52 ppr based structure level 2 packed packed unaligned dcl 1-56 prr based bit(3) level 3 packed packed unaligned dcl 1-56 ref 50 prs based pointer array level 2 dcl 1-12 ref 59 ptr builtin function dcl 37 ref 59 rel builtin function dcl 37 ref 65 ring 000100 automatic fixed bin(17,0) dcl 31 set ref 49* 52 62 62* 68* 70 76 76 sb 000114 automatic pointer dcl 2-24 set ref 52* 59* 65 84 scu based structure level 1 dcl 1-56 in procedure "lot_fault_handler_" scu 30 based bit(36) array level 2 in structure "mc" packed packed unaligned dcl 1-12 in procedure "lot_fault_handler_" set ref 48 scup 000112 automatic pointer dcl 1-54 set ref 48* 49 50 65 segno 000102 automatic fixed bin(18,0) dcl 33 set ref 65* 66 84 segptr 000106 automatic pointer dcl 35 set ref 66* 68* stack_header based structure level 1 dcl 2-26 tpr 2 based structure level 2 packed packed unaligned dcl 1-56 trr 2 based bit(3) level 3 packed packed unaligned dcl 1-56 ref 49 virgin_linkage_header based structure level 1 dcl 4-52 wcptr parameter pointer dcl 26 ref 13 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. abx internal static fixed bin(17,0) initial dcl 1-42 apx internal static fixed bin(17,0) initial dcl 1-42 bbx internal static fixed bin(17,0) initial dcl 1-42 bpx internal static fixed bin(17,0) initial dcl 1-42 call_offset internal static fixed bin(17,0) initial dcl 2-78 entry_offset internal static fixed bin(17,0) initial dcl 2-78 exp_word based structure level 1 dcl 4-21 header based structure level 1 dcl 4-31 isot based structure level 1 dcl 3-13 isot1 based structure array level 1 dcl 3-16 isotp automatic pointer dcl 3-12 lbx internal static fixed bin(17,0) initial dcl 1-42 link based structure level 1 dcl 4-11 linkage_header_flags based structure level 1 dcl 4-44 lot_fault internal static bit(36) initial dcl 3-9 lotp automatic pointer dcl 3-4 lpx internal static fixed bin(17,0) initial dcl 1-42 mcp automatic pointer dcl 1-10 name based structure level 1 dcl 4-70 push_offset internal static fixed bin(17,0) initial dcl 2-78 return_no_pop_offset internal static fixed bin(17,0) initial dcl 2-78 return_offset internal static fixed bin(17,0) initial dcl 2-78 sbx internal static fixed bin(17,0) initial dcl 1-42 scux based structure level 1 dcl 1-207 spx internal static fixed bin(17,0) initial dcl 1-42 stack_header_overlay based fixed bin(17,0) array dcl 2-94 trap_word based structure level 1 dcl 4-66 tv_offset internal static fixed bin(17,0) initial dcl 2-72 type_pair based structure level 1 dcl 4-25 NAME DECLARED BY EXPLICIT CONTEXT. lot_fault_handler_ 000013 constant entry external dcl 13 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 326 352 226 336 Length 606 226 24 220 77 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME lot_fault_handler_ 118 external procedure is an external procedure. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME lot_fault_handler_ 000100 ring lot_fault_handler_ 000101 level lot_fault_handler_ 000102 segno lot_fault_handler_ 000104 header_ptr lot_fault_handler_ 000106 segptr lot_fault_handler_ 000110 code lot_fault_handler_ 000112 scup lot_fault_handler_ 000114 sb lot_fault_handler_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out return_mac ext_entry_desc THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. get_ring_ hcs_$combine_linkage hcs_$level_get hcs_$level_set link_trap_caller_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. pds$stacks LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 13 000006 48 000026 49 000033 50 000036 52 000041 55 000060 56 000063 58 000064 59 000065 61 000067 62 000076 65 000110 66 000121 68 000124 70 000137 73 000151 76 000157 84 000164 86 000170 90 000225 ----------------------------------------------------------- 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