COMPILATION LISTING OF SEGMENT trap_caller_caller_ Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: CGI Compiled on: 2000-06-29_1714.92_Thu_mdt Options: optimize list 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 trap_caller_caller_: proc (mcptr, header_ptr, def_ptr, type_ptr, link_ptr, ecode_ptr, code); 14 15 /* This procedure is called by the linker (link_snap) when a trap-before-link or 16* trap-at-first-reference is to be satisfied. It creates a frame in the stack 17* of the faulting ring, putting machine conditions there (with the help of the signaller), 18* sets up an argument list in that frame, and "calls" trap caller in the 19* outer ring. The pointer to trap_caller's entry point is obtained via 20* link_snap$make_ptr so that its linkage section will be properly set up in the outer ring. 21* 22* The "call" will wipe out the stack we are running on, and the return from trap_caller 23* will actually go to the return point in restart_fault so that the machine conditions 24* can be restarted. 25* 26* The entry "for_linker" in signaller is used to perform some of the necessary "secure" features 27* of the restart such as saving a copy of the machine conditions in ring 0 and setting up a 28* cleanup handler to discard these saved machine conditions if they are not to be restarted. 29* 30* Initially coded by M Weaver June 1973 31* Revised: 32* April 75 by S. Webber to add "secure restart" features. 33**/ 34 35 declare (mcptr, header_ptr, def_ptr, type_ptr, link_ptr, entry_ptr, old_sp, ecode_ptr) ptr; 36 37 declare i fixed bin; 38 39 declare link_snap$make_ptr entry (ptr, char (*), char (*), ptr, fixed bin (35)); 40 declare signaller$for_linker entry (ptr, ptr); 41 declare level$get entry () returns (fixed bin); 42 43 declare code fixed bin (35); 44 declare level fixed bin (18); 45 declare (frame_add, temp) fixed bin (19); 46 declare pds$signal_data (48) fixed bin ext; 47 declare m_c (48) fixed bin based; 48 declare based_fixed based fixed bin; 49 declare error_table_$no_trap_proc ext fixed bin (35); 50 51 declare label_var label; 52 declare 1 label_temp aligned based, /* label template */ 53 2 (locp, stackp) ptr; 54 55 declare (addr, addrel, baseno, baseptr, bin, bit, divide, null, ptr, rel) builtin; 56 57 declare 1 trap_return_frame aligned based (sp), /* template for frame we will build */ 58 2 frame_header (40) fixed bin, 59 2 pad (8) fixed bin, 60 2 mach_cond (48) fixed bin, /* put in same place that signaller would */ 61 2 arg (7) ptr, /* are the arguments: 62* mcptr, header_ptr, def_ptr, type_ptr, link_ptr; 63* mcptr must stay where it is because 64* signaller may need it for illegal_return */ 65 2 arglist, 66 3 arg_count bit (18) unaligned, 67 3 code bit (18) unaligned, 68 3 desc_count bit (18) unaligned, 69 3 pad bit (18) unaligned, 70 3 arg_ptrs (7) ptr, 71 2 pad1 (2) fixed bin, 72 2 on_unit (16) fixed bin; 73 74 /* The variables mach_cond and on_unit in the above structure must start at 48 and 128 words 75* from the beginning of the structure respectively because the signaller uses these regions 76* of the stack frame set up by trap_caller_caller_. */ 77 /* */ 1 1 /* BEGIN INCLUDE FILE ... stack_header.incl.pl1 .. 3/72 Bill Silver */ 1 2 /* modified 7/76 by M. Weaver for *system links and more system use of areas */ 1 3 /* modified 3/77 by M. Weaver to add rnt_ptr */ 1 4 /* Modified April 1983 by C. Hornig for tasking */ 1 5 1 6 /****^ HISTORY COMMENTS: 1 7* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), 1 8* audit(86-08-05,Schroth), install(86-11-03,MR12.0-1206): 1 9* added the heap_header_ptr definition. 1 10* 2) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 1 11* audit(86-10-10,Fawcett), install(86-11-03,MR12.0-1206): 1 12* Modified to support control point management. These changes were actually 1 13* made in February 1985 by G. Palter. 1 14* 3) change(86-10-22,Fawcett), approve(86-10-22,MCR7473), 1 15* audit(86-10-22,Farley), install(86-11-03,MR12.0-1206): 1 16* Remove the old_lot pointer and replace it with cpm_data_ptr. Use the 18 1 17* bit pad after cur_lot_size for the cpm_enabled. This was done to save some 1 18* space int the stack header and change the cpd_ptr unal to cpm_data_ptr 1 19* (ITS pair). 1 20* END HISTORY COMMENTS */ 1 21 1 22 /* format: style2 */ 1 23 1 24 dcl sb ptr; /* the main pointer to the stack header */ 1 25 1 26 dcl 1 stack_header based (sb) aligned, 1 27 2 pad1 (4) fixed bin, /* (0) also used as arg list by outward_call_handler */ 1 28 2 cpm_data_ptr ptr, /* (4) pointer to control point which owns this stack */ 1 29 2 combined_stat_ptr ptr, /* (6) pointer to area containing separate static */ 1 30 2 clr_ptr ptr, /* (8) pointer to area containing linkage sections */ 1 31 2 max_lot_size fixed bin (17) unal, /* (10) DU number of words allowed in lot */ 1 32 2 main_proc_invoked fixed bin (11) unal, /* (10) DL nonzero if main procedure invoked in run unit */ 1 33 2 have_static_vlas bit (1) unal, /* (10) DL "1"b if (very) large arrays are being used in static */ 1 34 2 pad4 bit (2) unal, 1 35 2 run_unit_depth fixed bin (2) unal, /* (10) DL number of active run units stacked */ 1 36 2 cur_lot_size fixed bin (17) unal, /* (11) DU number of words (entries) in lot */ 1 37 2 cpm_enabled bit (18) unal, /* (11) DL non-zero if control point management is enabled */ 1 38 2 system_free_ptr ptr, /* (12) pointer to system storage area */ 1 39 2 user_free_ptr ptr, /* (14) pointer to user storage area */ 1 40 2 null_ptr ptr, /* (16) */ 1 41 2 stack_begin_ptr ptr, /* (18) pointer to first stack frame on the stack */ 1 42 2 stack_end_ptr ptr, /* (20) pointer to next useable stack frame */ 1 43 2 lot_ptr ptr, /* (22) pointer to the lot for the current ring */ 1 44 2 signal_ptr ptr, /* (24) pointer to signal procedure for current ring */ 1 45 2 bar_mode_sp ptr, /* (26) value of sp before entering bar mode */ 1 46 2 pl1_operators_ptr ptr, /* (28) pointer to pl1_operators_$operator_table */ 1 47 2 call_op_ptr ptr, /* (30) pointer to standard call operator */ 1 48 2 push_op_ptr ptr, /* (32) pointer to standard push operator */ 1 49 2 return_op_ptr ptr, /* (34) pointer to standard return operator */ 1 50 2 return_no_pop_op_ptr 1 51 ptr, /* (36) pointer to standard return / no pop operator */ 1 52 2 entry_op_ptr ptr, /* (38) pointer to standard entry operator */ 1 53 2 trans_op_tv_ptr ptr, /* (40) pointer to translator operator ptrs */ 1 54 2 isot_ptr ptr, /* (42) pointer to ISOT */ 1 55 2 sct_ptr ptr, /* (44) pointer to System Condition Table */ 1 56 2 unwinder_ptr ptr, /* (46) pointer to unwinder for current ring */ 1 57 2 sys_link_info_ptr ptr, /* (48) pointer to *system link name table */ 1 58 2 rnt_ptr ptr, /* (50) pointer to Reference Name Table */ 1 59 2 ect_ptr ptr, /* (52) pointer to event channel table */ 1 60 2 assign_linkage_ptr ptr, /* (54) pointer to storage for (obsolete) hcs_$assign_linkage */ 1 61 2 heap_header_ptr ptr, /* (56) pointer to the heap header for this ring */ 1 62 2 trace, 1 63 3 frames, 1 64 4 count fixed bin, /* (58) number of trace frames */ 1 65 4 top_ptr ptr unal, /* (59) pointer to last trace frame */ 1 66 3 in_trace bit (36) aligned, /* (60) trace antirecursion flag */ 1 67 2 pad2 bit (36), /* (61) */ 1 68 2 pad5 pointer; /* (62) pointer to future stuff */ 1 69 1 70 /* The following offset refers to a table within the pl1 operator table. */ 1 71 1 72 dcl tv_offset fixed bin init (361) internal static; 1 73 /* (551) octal */ 1 74 1 75 1 76 /* The following constants are offsets within this transfer vector table. */ 1 77 1 78 dcl ( 1 79 call_offset fixed bin init (271), 1 80 push_offset fixed bin init (272), 1 81 return_offset fixed bin init (273), 1 82 return_no_pop_offset fixed bin init (274), 1 83 entry_offset fixed bin init (275) 1 84 ) internal static; 1 85 1 86 1 87 1 88 1 89 1 90 /* The following declaration is an overlay of the whole stack header. Procedures which 1 91* move the whole stack header should use this overlay. 1 92**/ 1 93 1 94 dcl stack_header_overlay (size (stack_header)) fixed bin based (sb); 1 95 1 96 1 97 1 98 /* END INCLUDE FILE ... stack_header.incl.pl1 */ 78 2 1 /* BEGIN INCLUDE FILE its.incl.pl1 2 2* modified 27 July 79 by JRDavis to add its_unsigned 2 3* Internal format of ITS pointer, including ring-number field for follow-on processor */ 2 4 2 5 dcl 1 its based aligned, /* declaration for ITS type pointer */ 2 6 2 pad1 bit (3) unaligned, 2 7 2 segno bit (15) unaligned, /* segment number within the pointer */ 2 8 2 ringno bit (3) unaligned, /* ring number within the pointer */ 2 9 2 pad2 bit (9) unaligned, 2 10 2 its_mod bit (6) unaligned, /* should be 43(8) */ 2 11 2 12 2 offset bit (18) unaligned, /* word offset within the addressed segment */ 2 13 2 pad3 bit (3) unaligned, 2 14 2 bit_offset bit (6) unaligned, /* bit offset within the word */ 2 15 2 pad4 bit (3) unaligned, 2 16 2 mod bit (6) unaligned; /* further modification */ 2 17 2 18 dcl 1 itp based aligned, /* declaration for ITP type pointer */ 2 19 2 pr_no bit (3) unaligned, /* number of pointer register to use */ 2 20 2 pad1 bit (27) unaligned, 2 21 2 itp_mod bit (6) unaligned, /* should be 41(8) */ 2 22 2 23 2 offset bit (18) unaligned, /* word offset from pointer register word offset */ 2 24 2 pad2 bit (3) unaligned, 2 25 2 bit_offset bit (6) unaligned, /* bit offset relative to new word offset */ 2 26 2 pad3 bit (3) unaligned, 2 27 2 mod bit (6) unaligned; /* further modification */ 2 28 2 29 2 30 dcl 1 its_unsigned based aligned, /* just like its, but with unsigned binary */ 2 31 2 pad1 bit (3) unaligned, 2 32 2 segno fixed bin (15) unsigned unaligned, 2 33 2 ringno fixed bin (3) unsigned unaligned, 2 34 2 pad2 bit (9) unaligned, 2 35 2 its_mod bit (6) unaligned, 2 36 2 37 2 offset fixed bin (18) unsigned unaligned, 2 38 2 pad3 bit (3) unaligned, 2 39 2 bit_offset fixed bin (6) unsigned unaligned, 2 40 2 pad4 bit (3) unaligned, 2 41 2 mod bit (6) unaligned; 2 42 2 43 dcl 1 itp_unsigned based aligned, /* just like itp, but with unsigned binary where appropriate */ 2 44 2 pr_no fixed bin (3) unsigned unaligned, 2 45 2 pad1 bit (27) unaligned, 2 46 2 itp_mod bit (6) unaligned, 2 47 2 48 2 offset fixed bin (18) unsigned unaligned, 2 49 2 pad2 bit (3) unaligned, 2 50 2 bit_offset fixed bin (6) unsigned unaligned, 2 51 2 pad3 bit (3) unaligned, 2 52 2 mod bit (6) unaligned; 2 53 2 54 2 55 dcl ITS_MODIFIER bit (6) unaligned internal static options (constant) init ("43"b3); 2 56 dcl ITP_MODIFIER bit (6) unaligned internal static options (constant) init ("41"b3); 2 57 2 58 /* END INCLUDE FILE its.incl.pl1 */ 79 3 1 /* BEGIN INCLUDE FILE ... stack_frame.incl.pl1 ... */ 3 2 3 3 /* format: off */ 3 4 3 5 /* Modified: 16 Dec 1977, D. Levin - to add fio_ps_ptr and pl1_ps_ptr */ 3 6 /* Modified: 3 Feb 1978, P. Krupp - to add run_unit_manager bit & main_proc bit */ 3 7 /* Modified: 21 March 1978, D. Levin - change fio_ps_ptr to support_ptr */ 3 8 /* Modified: 03/01/84, S. Herbst - Added RETURN_PTR_MASK */ 3 9 3 10 3 11 /****^ HISTORY COMMENTS: 3 12* 1) change(86-09-15,Kissel), approve(86-09-15,MCR7473), 3 13* audit(86-10-01,Fawcett), install(86-11-03,MR12.0-1206): 3 14* Modified to add constants for the translator_id field in the stack_frame 3 15* structure. 3 16* END HISTORY COMMENTS */ 3 17 3 18 3 19 dcl RETURN_PTR_MASK bit (72) int static options (constant) /* mask to be AND'd with stack_frame.return_ptr */ 3 20 init ("777777777777777777000000"b3); /* when copying, to ignore bits that a call fills */ 3 21 /* with indicators (nonzero for Fortran hexfp caller) */ 3 22 /* say: unspec(ptr) = unspec(stack_frame.return_ptr) & RETURN_PTR_MASK; */ 3 23 3 24 dcl TRANSLATOR_ID_PL1V2 bit (18) internal static options (constant) init ("000000"b3); 3 25 dcl TRANSLATOR_ID_ALM bit (18) internal static options (constant) init ("000001"b3); 3 26 dcl TRANSLATOR_ID_PL1V1 bit (18) internal static options (constant) init ("000002"b3); 3 27 dcl TRANSLATOR_ID_SIGNAL_CALLER bit (18) internal static options (constant) init ("000003"b3); 3 28 dcl TRANSLATOR_ID_SIGNALLER bit (18) internal static options (constant) init ("000004"b3); 3 29 3 30 3 31 dcl sp pointer; /* pointer to beginning of stack frame */ 3 32 3 33 dcl stack_frame_min_length fixed bin static init(48); 3 34 3 35 3 36 dcl 1 stack_frame based(sp) aligned, 3 37 2 pointer_registers(0 : 7) ptr, 3 38 2 prev_sp pointer, 3 39 2 next_sp pointer, 3 40 2 return_ptr pointer, 3 41 2 entry_ptr pointer, 3 42 2 operator_and_lp_ptr ptr, /* serves as both */ 3 43 2 arg_ptr pointer, 3 44 2 static_ptr ptr unaligned, 3 45 2 support_ptr ptr unal, /* only used by fortran I/O */ 3 46 2 on_unit_relp1 bit(18) unaligned, 3 47 2 on_unit_relp2 bit(18) unaligned, 3 48 2 translator_id bit(18) unaligned, /* Translator ID (see constants above) 3 49* 0 => PL/I version II 3 50* 1 => ALM 3 51* 2 => PL/I version I 3 52* 3 => signal caller frame 3 53* 4 => signaller frame */ 3 54 2 operator_return_offset bit(18) unaligned, 3 55 2 x(0: 7) bit(18) unaligned, /* index registers */ 3 56 2 a bit(36), /* accumulator */ 3 57 2 q bit(36), /* q-register */ 3 58 2 e bit(36), /* exponent */ 3 59 2 timer bit(27) unaligned, /* timer */ 3 60 2 pad bit(6) unaligned, 3 61 2 ring_alarm_reg bit(3) unaligned; 3 62 3 63 3 64 dcl 1 stack_frame_flags based(sp) aligned, 3 65 2 pad(0 : 7) bit(72), /* skip over prs */ 3 66 2 xx0 bit(22) unal, 3 67 2 main_proc bit(1) unal, /* on if frame belongs to a main procedure */ 3 68 2 run_unit_manager bit(1) unal, /* on if frame belongs to run unit manager */ 3 69 2 signal bit(1) unal, /* on if frame belongs to logical signal_ */ 3 70 2 crawl_out bit(1) unal, /* on if this is a signal caller frame */ 3 71 2 signaller bit(1) unal, /* on if next frame is signaller's */ 3 72 2 link_trap bit(1) unal, /* on if this frame was made by the linker */ 3 73 2 support bit(1) unal, /* on if frame belongs to a support proc */ 3 74 2 condition bit(1) unal, /* on if condition established in this frame */ 3 75 2 xx0a bit(6) unal, 3 76 2 xx1 fixed bin, 3 77 2 xx2 fixed bin, 3 78 2 xx3 bit(25) unal, 3 79 2 old_crawl_out bit (1) unal, /* on if this is a signal caller frame */ 3 80 2 old_signaller bit(1) unal, /* on if next frame is signaller's */ 3 81 2 xx3a bit(9) unaligned, 3 82 2 xx4(9) bit(72) aligned, 3 83 2 v2_pl1_op_ret_base ptr, /* When a V2 PL/I program calls an operator the 3 84* * operator puts a pointer to the base of 3 85* * the calling procedure here. (text base ptr) */ 3 86 2 xx5 bit(72) aligned, 3 87 2 pl1_ps_ptr ptr; /* ptr to ps for this frame; also used by fio. */ 3 88 3 89 /* format: on */ 3 90 3 91 /* END INCLUDE FILE ... stack_frame.incl.pl1 */ 80 4 1 /* */ 4 2 /* BEGIN INCLUDE FILE mc.incl.pl1 Created Dec 72 for 6180 - WSS. */ 4 3 /* Modified 06/07/76 by Greenberg for mc.resignal */ 4 4 /* Modified 07/07/76 by Morris for fault register data */ 4 5 /* Modified 08/28/80 by J. A. Bush for the DPS8/70M CVPU */ 4 6 /* Modified '82 to make values constant */ 4 7 4 8 /* words 0-15 pointer registers */ 4 9 4 10 dcl mcp ptr; 4 11 4 12 dcl 1 mc based (mcp) aligned, 4 13 2 prs (0:7) ptr, /* POINTER REGISTERS */ 4 14 (2 regs, /* registers */ 4 15 3 x (0:7) bit (18), /* index registers */ 4 16 3 a bit (36), /* accumulator */ 4 17 3 q bit (36), /* q-register */ 4 18 3 e bit (8), /* exponent */ 4 19 3 pad1 bit (28), 4 20 3 t bit (27), /* timer register */ 4 21 3 pad2 bit (6), 4 22 3 ralr bit (3), /* ring alarm register */ 4 23 4 24 2 scu (0:7) bit (36), 4 25 4 26 2 mask bit (72), /* mem controller mask at time of fault */ 4 27 2 ips_temp bit (36), /* Temporary storage for IPS info */ 4 28 2 errcode fixed bin (35), /* fault handler's error code */ 4 29 2 fim_temp, 4 30 3 unique_index bit (18) unal, /* unique index for restarting faults */ 4 31 3 resignal bit (1) unal, /* recompute signal name with fcode below */ 4 32 3 fcode bit (17) unal, /* fault code used as index to FIM table and SCT */ 4 33 2 fault_reg bit (36), /* fault register */ 4 34 2 pad2 bit (1), 4 35 2 cpu_type fixed bin (2) unsigned, /* L68 = 0, DPS8/70M = 1 */ 4 36 2 ext_fault_reg bit (15), /* extended fault reg for DPS8/70M CPU */ 4 37 2 fault_time bit (54), /* time of fault */ 4 38 4 39 2 eis_info (0:7) bit (36)) unaligned; 4 40 4 41 4 42 dcl (apx fixed bin init (0), 4 43 abx fixed bin init (1), 4 44 bpx fixed bin init (2), 4 45 bbx fixed bin init (3), 4 46 lpx fixed bin init (4), 4 47 lbx fixed bin init (5), 4 48 spx fixed bin init (6), 4 49 sbx fixed bin init (7)) internal static options (constant); 4 50 4 51 4 52 4 53 4 54 dcl scup ptr; 4 55 4 56 dcl 1 scu based (scup) aligned, /* SCU DATA */ 4 57 4 58 4 59 /* WORD (0) */ 4 60 4 61 (2 ppr, /* PROCEDURE POINTER REGISTER */ 4 62 3 prr bit (3), /* procedure ring register */ 4 63 3 psr bit (15), /* procedure segment register */ 4 64 3 p bit (1), /* procedure privileged bit */ 4 65 4 66 2 apu, /* APPENDING UNIT STATUS */ 4 67 3 xsf bit (1), /* ext seg flag - IT modification */ 4 68 3 sdwm bit (1), /* match in SDW Ass. Mem. */ 4 69 3 sd_on bit (1), /* SDW Ass. Mem. ON */ 4 70 3 ptwm bit (1), /* match in PTW Ass. Mem. */ 4 71 3 pt_on bit (1), /* PTW Ass. Mem. ON */ 4 72 3 pi_ap bit (1), /* Instr Fetch or Append cycle */ 4 73 3 dsptw bit (1), /* Fetch of DSPTW */ 4 74 3 sdwnp bit (1), /* Fetch of SDW non paged */ 4 75 3 sdwp bit (1), /* Fetch of SDW paged */ 4 76 3 ptw bit (1), /* Fetch of PTW */ 4 77 3 ptw2 bit (1), /* Fetch of pre-paged PTW */ 4 78 3 fap bit (1), /* Fetch of final address paged */ 4 79 3 fanp bit (1), /* Fetch of final address non-paged */ 4 80 3 fabs bit (1), /* Fetch of final address absolute */ 4 81 4 82 2 fault_cntr bit (3), /* number of retrys of EIS instructions */ 4 83 4 84 4 85 /* WORD (1) */ 4 86 4 87 2 fd, /* FAULT DATA */ 4 88 3 iro bit (1), /* illegal ring order */ 4 89 3 oeb bit (1), /* out of execute bracket */ 4 90 3 e_off bit (1), /* no execute */ 4 91 3 orb bit (1), /* out of read bracket */ 4 92 3 r_off bit (1), /* no read */ 4 93 3 owb bit (1), /* out of write bracket */ 4 94 3 w_off bit (1), /* no write */ 4 95 3 no_ga bit (1), /* not a gate */ 4 96 3 ocb bit (1), /* out of call bracket */ 4 97 3 ocall bit (1), /* outward call */ 4 98 3 boc bit (1), /* bad outward call */ 4 99 3 inret bit (1), /* inward return */ 4 100 3 crt bit (1), /* cross ring transfer */ 4 101 3 ralr bit (1), /* ring alarm register */ 4 102 3 am_er bit (1), /* associative memory fault */ 4 103 3 oosb bit (1), /* out of segment bounds */ 4 104 3 paru bit (1), /* processor parity upper */ 4 105 3 parl bit (1), /* processor parity lower */ 4 106 3 onc_1 bit (1), /* op not complete type 1 */ 4 107 3 onc_2 bit (1), /* op not complete type 2 */ 4 108 4 109 2 port_stat, /* PORT STATUS */ 4 110 3 ial bit (4), /* illegal action lines */ 4 111 3 iac bit (3), /* illegal action channel */ 4 112 3 con_chan bit (3), /* connect channel */ 4 113 4 114 2 fi_num bit (5), /* (fault/interrupt) number */ 4 115 2 fi_flag bit (1), /* 1 => fault, 0 => interrupt */ 4 116 4 117 4 118 /* WORD (2) */ 4 119 4 120 2 tpr, /* TEMPORARY POINTER REGISTER */ 4 121 3 trr bit (3), /* temporary ring register */ 4 122 3 tsr bit (15), /* temporary segment register */ 4 123 4 124 2 pad2 bit (9), 4 125 4 126 2 cpu_no bit (3), /* CPU number */ 4 127 4 128 2 delta bit (6), /* tally modification DELTA */ 4 129 4 130 4 131 /* WORD (3) */ 4 132 4 133 2 word3 bit (18), 4 134 4 135 2 tsr_stat, /* TSR STATUS for 1,2,&3 word instructions */ 4 136 3 tsna, /* Word 1 status */ 4 137 4 prn bit (3), /* Word 1 PR number */ 4 138 4 prv bit (1), /* Word 1 PR valid bit */ 4 139 3 tsnb, /* Word 2 status */ 4 140 4 prn bit (3), /* Word 2 PR number */ 4 141 4 prv bit (1), /* Word 2 PR valid bit */ 4 142 3 tsnc, /* Word 3 status */ 4 143 4 prn bit (3), /* Word 3 PR number */ 4 144 4 prv bit (1), /* Word 3 PR valid bit */ 4 145 4 146 2 tpr_tbr bit (6), /* TPR.TBR field */ 4 147 4 148 4 149 /* WORD (4) */ 4 150 4 151 2 ilc bit (18), /* INSTRUCTION COUNTER */ 4 152 4 153 2 ir, /* INDICATOR REGISTERS */ 4 154 3 zero bit (1), /* zero indicator */ 4 155 3 neg bit (1), /* negative indicator */ 4 156 3 carry bit (1), /* carryry indicator */ 4 157 3 ovfl bit (1), /* overflow indicator */ 4 158 3 eovf bit (1), /* eponent overflow */ 4 159 3 eufl bit (1), /* exponent underflow */ 4 160 3 oflm bit (1), /* overflow mask */ 4 161 3 tro bit (1), /* tally runout */ 4 162 3 par bit (1), /* parity error */ 4 163 3 parm bit (1), /* parity mask */ 4 164 3 bm bit (1), /* ^bar mode */ 4 165 3 tru bit (1), /* truncation mode */ 4 166 3 mif bit (1), /* multi-word instruction mode */ 4 167 3 abs bit (1), /* absolute mode */ 4 168 3 hex bit (1), /* hexadecimal exponent mode */ 4 169 3 pad bit (3), 4 170 4 171 4 172 /* WORD (5) */ 4 173 4 174 2 ca bit (18), /* COMPUTED ADDRESS */ 4 175 4 176 2 cu, /* CONTROL UNIT STATUS */ 4 177 3 rf bit (1), /* on first cycle of repeat instr */ 4 178 3 rpt bit (1), /* repeat instruction */ 4 179 3 rd bit (1), /* repeat double instruction */ 4 180 3 rl bit (1), /* repeat link instruciton */ 4 181 3 pot bit (1), /* IT modification */ 4 182 3 pon bit (1), /* return type instruction */ 4 183 3 xde bit (1), /* XDE from Even location */ 4 184 3 xdo bit (1), /* XDE from Odd location */ 4 185 3 poa bit (1), /* operation preparation */ 4 186 3 rfi bit (1), /* tells CPU to refetch instruction */ 4 187 3 its bit (1), /* ITS modification */ 4 188 3 if bit (1), /* fault occured during instruction fetch */ 4 189 4 190 2 cpu_tag bit (6)) unaligned, /* computed tag field */ 4 191 4 192 4 193 /* WORDS (6,7) */ 4 194 4 195 2 even_inst bit (36), /* even instruction of faulting pair */ 4 196 4 197 2 odd_inst bit (36); /* odd instruction of faulting pair */ 4 198 4 199 4 200 4 201 4 202 4 203 4 204 /* ALTERNATE SCU DECLARATION */ 4 205 4 206 4 207 dcl 1 scux based (scup) aligned, 4 208 4 209 (2 pad0 bit (36), 4 210 4 211 2 fd, /* GROUP II FAULT DATA */ 4 212 3 isn bit (1), /* illegal segment number */ 4 213 3 ioc bit (1), /* illegal op code */ 4 214 3 ia_am bit (1), /* illegal address - modifier */ 4 215 3 isp bit (1), /* illegal slave procedure */ 4 216 3 ipr bit (1), /* illegal procedure */ 4 217 3 nea bit (1), /* non existent address */ 4 218 3 oobb bit (1), /* out of bounds */ 4 219 3 pad bit (29), 4 220 4 221 2 pad2 bit (36), 4 222 4 223 2 pad3a bit (18), 4 224 4 225 2 tsr_stat (0:2), /* TSR STATUS as an ARRAY */ 4 226 3 prn bit (3), /* PR number */ 4 227 3 prv bit (1), /* PR valid bit */ 4 228 4 229 2 pad3b bit (6)) unaligned, 4 230 4 231 2 pad45 (0:1) bit (36), 4 232 4 233 2 instr (0:1) bit (36); /* Instruction ARRAY */ 4 234 4 235 4 236 4 237 /* END INCLUDE FILE mc.incl.pl1 */ 81 82 /* */ 83 /* get ptr to trap caller proc in outer ring */ 84 /* validation level has already been set correctly */ 85 86 begin: call link_snap$make_ptr (null, "link_trap_caller_", "link_trap_caller_", entry_ptr, code); 87 if code ^= 0 then do; /* have linker return linkage_error */ 88 code = error_table_$no_trap_proc; 89 return; 90 end; 91 92 if mcptr ^= null then old_sp = mcptr -> mc.prs (6); /* get ptr to proper stack */ 93 else do; /* no mc; get old_sp by tracing threads */ 94 label_var = begin; /* use big kludge to get sp */ 95 sp = addr (label_var) -> label_temp.stackp; /* labels have stack ptrs */ 96 97 /* get frame of caller of link_snap */ 98 /* look for last sp in stack of validation level because */ 99 /* external reference is being processed for ring of validation level */ 100 101 level = level$get (); /* get validation level */ 102 i = 0; /* initialize */ 103 if level = 0 then old_sp = sp; /* we are the last frame */ 104 else do; 105 do while (baseno (sp -> stack_frame.prev_sp) = baseno (sp)); 106 sp = sp -> stack_frame.prev_sp; /* try previous one */ 107 i = i + 1; 108 if i = 2000 then do; /* don't loop in ring 0 */ 109 code = error_table_$no_trap_proc; 110 return; 111 end; 112 end; 113 if bin (addr (sp -> stack_frame.prev_sp) -> its.ringno, 3) ^= level then do; 114 115 /* there are stacks in rings between r0 and target ring which 116* we are not prepared to handle, so we will abort with a 117* linkage_error and let the condition mechanism clean up */ 118 119 code = error_table_$no_trap_proc; 120 return; 121 end; 122 old_sp = sp -> stack_frame.prev_sp; /* we found the most recent frame in target ring */ 123 end; 124 end; 125 126 127 sb = ptr (old_sp, 0); /* get ptr to base of new stack */ 128 temp = bin (rel (sb -> stack_header.stack_end_ptr), 18); /* find starting offset */ 129 if mcptr ^= null then do; /* get ring number from mc */ 130 frame_add = temp + stack_frame_min_length; 131 old_sp -> stack_frame_flags.signaller = "1"b; /* set appropiate flags so will know to truncate */ 132 old_sp -> stack_frame_flags.old_signaller = "1"b; 133 end; 134 else do; /* were called; frame not inconsistent */ 135 frame_add = temp; /* start where old left off */ 136 /* no mc, so don't worry about mod 16 */ 137 end; 138 139 /* add new frame to outer ring stack */ 140 141 sp, /* get ptr to new stack frame */ 142 old_sp -> stack_frame.next_sp = ptr (sb, frame_add); 143 144 /* thread in new frame */ 145 146 sp -> stack_frame.next_sp, 147 sb -> stack_header.stack_end_ptr = addrel (sp, size (trap_return_frame)); 148 sp -> stack_frame.prev_sp = old_sp; 149 150 sp -> stack_frame_flags.link_trap = "1"b; /* previous frame was faulted out of */ 151 sp -> stack_frame.translator_id = bit (bin (10, 18), 18); /* trap_caller_caller_ frame */ 152 153 /* fill in arguments */ 154 155 if mcptr = null then sp -> trap_return_frame.arg (2) = null; /* no mc */ 156 else do; /* arg must point to copied mc */ 157 old_sp -> stack_frame_flags.old_signaller = "1"b; /* must be after next_sp is updated */ 158 pds$signal_data = mcptr -> m_c; 159 sp -> trap_return_frame.arg (2) = addr (sp -> trap_return_frame.mach_cond); 160 end; 161 sp -> trap_return_frame.arg (1) = null; 162 sp -> trap_return_frame.arg (3) = header_ptr; 163 sp -> trap_return_frame.arg (4) = def_ptr; 164 sp -> trap_return_frame.arg (5) = type_ptr; 165 sp -> trap_return_frame.arg (6) = link_ptr; 166 sp -> trap_return_frame.arg (7) = ecode_ptr; /* points to ec in linker caller's frame */ 167 168 /* fill in argument list */ 169 170 sp -> trap_return_frame.arglist.arg_count = bit (bin (12, 18), 18); 171 sp -> trap_return_frame.arglist.code = bit (bin (4, 18), 18); 172 sp -> trap_return_frame.arglist.desc_count, 173 sp -> trap_return_frame.arglist.pad = "0"b; 174 175 176 do i = 1 to 7; 177 sp -> trap_return_frame.arglist.arg_ptrs (i) = 178 addr (sp -> trap_return_frame.arg (i)); 179 end; 180 181 /* put arglist ptr where next proc can find it */ 182 183 sp -> stack_frame.operator_and_lp_ptr = addr (trap_return_frame.arglist); 184 185 call signaller$for_linker (sp, entry_ptr); 186 187 return; /* this will never be executed */ 188 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 06/29/00 1714.9 trap_caller_caller_.pl1 >udd>sm>ds>w>ml>trap_caller_caller_.pl1 78 1 11/07/86 1650.3 stack_header.incl.pl1 >ldd>incl>stack_header.incl.pl1 79 2 11/26/79 1420.6 its.incl.pl1 >ldd>incl>its.incl.pl1 80 3 11/07/86 1650.3 stack_frame.incl.pl1 >ldd>incl>stack_frame.incl.pl1 81 4 12/15/83 1200.4 mc.incl.pl1 >ldd>incl>mc.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 55 ref 95 113 159 177 183 addrel builtin function dcl 55 ref 146 arg 140 based pointer array level 2 dcl 57 set ref 155* 159* 161* 162* 163* 164* 165* 166* 177 arg_count 156 based bit(18) level 3 packed packed unaligned dcl 57 set ref 170* arg_ptrs 160 based pointer array level 3 dcl 57 set ref 177* arglist 156 based structure level 2 dcl 57 set ref 183 baseno builtin function dcl 55 ref 105 105 bin builtin function dcl 55 ref 113 128 151 170 171 bit builtin function dcl 55 ref 151 170 171 code 156(18) based bit(18) level 3 in structure "trap_return_frame" packed packed unaligned dcl 57 in procedure "trap_caller_caller_" set ref 171* code parameter fixed bin(35,0) dcl 43 in procedure "trap_caller_caller_" set ref 13 86* 87 88* 109* 119* def_ptr parameter pointer dcl 35 ref 13 163 desc_count 157 based bit(18) level 3 packed packed unaligned dcl 57 set ref 172* ecode_ptr parameter pointer dcl 35 ref 13 166 entry_ptr 000100 automatic pointer dcl 35 set ref 86* 185* error_table_$no_trap_proc 000020 external static fixed bin(35,0) dcl 49 ref 88 109 119 frame_add 000106 automatic fixed bin(19,0) dcl 45 set ref 130* 135* 141 header_ptr parameter pointer dcl 35 ref 13 162 i 000104 automatic fixed bin(17,0) dcl 37 set ref 102* 107* 107 108 176* 177 177* its based structure level 1 dcl 2-5 label_temp based structure level 1 dcl 52 label_var 000110 automatic label variable dcl 51 set ref 94* 95 level 000105 automatic fixed bin(18,0) dcl 44 set ref 101* 103 113 level$get 000014 constant entry external dcl 41 ref 101 link_ptr parameter pointer dcl 35 ref 13 165 link_snap$make_ptr 000010 constant entry external dcl 39 ref 86 link_trap 20(27) based bit(1) level 2 packed packed unaligned dcl 3-64 set ref 150* m_c based fixed bin(17,0) array dcl 47 ref 158 mach_cond 60 based fixed bin(17,0) array level 2 dcl 57 set ref 159 mc based structure level 1 dcl 4-12 mcptr parameter pointer dcl 35 ref 13 92 92 129 155 158 next_sp 22 based pointer level 2 dcl 3-36 set ref 141* 146* null builtin function dcl 55 ref 86 86 92 129 155 155 161 old_signaller 23(26) based bit(1) level 2 packed packed unaligned dcl 3-64 set ref 132* 157* old_sp 000102 automatic pointer dcl 35 set ref 92* 103* 122* 127 131 132 141 148 157 operator_and_lp_ptr 30 based pointer level 2 dcl 3-36 set ref 183* pad 157(18) based bit(18) level 3 packed packed unaligned dcl 57 set ref 172* pds$signal_data 000016 external static fixed bin(17,0) array dcl 46 set ref 158* prev_sp 20 based pointer level 2 dcl 3-36 set ref 105 106 113 122 148* prs based pointer array level 2 dcl 4-12 ref 92 ptr builtin function dcl 55 ref 127 141 rel builtin function dcl 55 ref 128 ringno 0(18) based bit(3) level 2 packed packed unaligned dcl 2-5 ref 113 sb 000114 automatic pointer dcl 1-24 set ref 127* 128 141 146 signaller 20(26) based bit(1) level 2 packed packed unaligned dcl 3-64 set ref 131* signaller$for_linker 000012 constant entry external dcl 40 ref 185 sp 000116 automatic pointer dcl 3-31 set ref 95* 103 105 105 106* 106 113 122 141* 146 146 146 148 150 151 155 159 159 161 162 163 164 165 166 170 171 172 172 177 177 183 183 185* stack_end_ptr 24 based pointer level 2 dcl 1-26 set ref 128 146* stack_frame based structure level 1 dcl 3-36 stack_frame_flags based structure level 1 dcl 3-64 stack_frame_min_length constant fixed bin(17,0) initial dcl 3-33 ref 130 stack_header based structure level 1 dcl 1-26 stackp 2 based pointer level 2 dcl 52 ref 95 temp 000107 automatic fixed bin(19,0) dcl 45 set ref 128* 130 135 translator_id 37 based bit(18) level 2 packed packed unaligned dcl 3-36 set ref 151* trap_return_frame based structure level 1 dcl 57 set ref 146 type_ptr parameter pointer dcl 35 ref 13 164 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ITP_MODIFIER internal static bit(6) initial packed unaligned dcl 2-56 ITS_MODIFIER internal static bit(6) initial packed unaligned dcl 2-55 RETURN_PTR_MASK internal static bit(72) initial packed unaligned dcl 3-19 TRANSLATOR_ID_ALM internal static bit(18) initial packed unaligned dcl 3-25 TRANSLATOR_ID_PL1V1 internal static bit(18) initial packed unaligned dcl 3-26 TRANSLATOR_ID_PL1V2 internal static bit(18) initial packed unaligned dcl 3-24 TRANSLATOR_ID_SIGNALLER internal static bit(18) initial packed unaligned dcl 3-28 TRANSLATOR_ID_SIGNAL_CALLER internal static bit(18) initial packed unaligned dcl 3-27 abx internal static fixed bin(17,0) initial dcl 4-42 apx internal static fixed bin(17,0) initial dcl 4-42 based_fixed based fixed bin(17,0) dcl 48 baseptr builtin function dcl 55 bbx internal static fixed bin(17,0) initial dcl 4-42 bpx internal static fixed bin(17,0) initial dcl 4-42 call_offset internal static fixed bin(17,0) initial dcl 1-78 divide builtin function dcl 55 entry_offset internal static fixed bin(17,0) initial dcl 1-78 itp based structure level 1 dcl 2-18 itp_unsigned based structure level 1 dcl 2-43 its_unsigned based structure level 1 dcl 2-30 lbx internal static fixed bin(17,0) initial dcl 4-42 lpx internal static fixed bin(17,0) initial dcl 4-42 mcp automatic pointer dcl 4-10 push_offset internal static fixed bin(17,0) initial dcl 1-78 return_no_pop_offset internal static fixed bin(17,0) initial dcl 1-78 return_offset internal static fixed bin(17,0) initial dcl 1-78 sbx internal static fixed bin(17,0) initial dcl 4-42 scu based structure level 1 dcl 4-56 scup automatic pointer dcl 4-54 scux based structure level 1 dcl 4-207 spx internal static fixed bin(17,0) initial dcl 4-42 stack_header_overlay based fixed bin(17,0) array dcl 1-94 tv_offset internal static fixed bin(17,0) initial dcl 1-72 NAMES DECLARED BY EXPLICIT CONTEXT. begin 000026 constant label dcl 86 ref 94 trap_caller_caller_ 000021 constant entry external dcl 13 NAME DECLARED BY CONTEXT OR IMPLICATION. size builtin function ref 146 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 470 512 370 500 Length 744 370 22 216 100 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME trap_caller_caller_ 116 external procedure is an external procedure. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME trap_caller_caller_ 000100 entry_ptr trap_caller_caller_ 000102 old_sp trap_caller_caller_ 000104 i trap_caller_caller_ 000105 level trap_caller_caller_ 000106 frame_add trap_caller_caller_ 000107 temp trap_caller_caller_ 000110 label_var trap_caller_caller_ 000114 sb trap_caller_caller_ 000116 sp trap_caller_caller_ 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. level$get link_snap$make_ptr signaller$for_linker THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$no_trap_proc pds$signal_data CONSTANTS 000000 aa 524000000021 000001 aa 404000000043 000002 aa 404000000021 000003 aa 464000000000 000004 aa 077777000043 000005 aa 000001000000 000006 aa 154 151 156 153 link 000007 aa 137 164 162 141 _tra 000010 aa 160 137 143 141 p_ca 000011 aa 154 154 145 162 ller 000012 aa 137 000 000 000 _ BEGIN PROCEDURE trap_caller_caller_ ENTRY TO trap_caller_caller_ STATEMENT 1 ON LINE 13 trap_caller_caller_: proc (mcptr, header_ptr, def_ptr, type_ptr, link_ptr, ecode_ptr, code); 000013 at 000007000003 000014 tt 000003000003 000015 tt 000003000003 000016 tt 000003000001 000017 ta 000013000000 000020 da 000074300000 000021 aa 000200 6270 00 eax7 128 000022 aa 7 00034 3521 20 epp2 pr7|28,* 000023 aa 2 01045 2721 00 tsp2 pr2|549 ext_entry 000024 aa 000016000000 000025 aa 000000000000 STATEMENT 1 ON LINE 86 begin: call link_snap$make_ptr (null, "link_trap_caller_", "link_trap_caller_", entry_ptr, code); 000026 aa 777756 3734 24 epp7 -18,ic* 000027 aa 6 00120 6535 00 spri7 pr6|80 000030 aa 777756 2370 04 ldaq -18,ic 000006 = 154151156153 137164162141 000031 aa 6 00122 7571 00 staq pr6|82 000032 aa 777756 2370 04 ldaq -18,ic 000010 = 160137143141 154154145162 000033 aa 6 00124 7571 00 staq pr6|84 000034 aa 137000 2350 03 lda 48640,du 000035 aa 6 00126 7551 00 sta pr6|86 000036 aa 777750 2370 04 ldaq -24,ic 000006 = 154151156153 137164162141 000037 aa 6 00130 7571 00 staq pr6|88 000040 aa 777750 2370 04 ldaq -24,ic 000010 = 160137143141 154154145162 000041 aa 6 00132 7571 00 staq pr6|90 000042 aa 137000 2350 03 lda 48640,du 000043 aa 6 00134 7551 00 sta pr6|92 000044 aa 6 00120 3521 00 epp2 pr6|80 000045 aa 6 00140 2521 00 spri2 pr6|96 000046 aa 6 00122 3521 00 epp2 pr6|82 000047 aa 6 00142 2521 00 spri2 pr6|98 000050 aa 6 00130 3521 00 epp2 pr6|88 000051 aa 6 00144 2521 00 spri2 pr6|100 000052 aa 6 00100 3521 00 epp2 pr6|64 entry_ptr 000053 aa 6 00146 2521 00 spri2 pr6|102 000054 aa 6 00032 3715 20 epp5 pr6|26,* 000055 aa 5 00016 3521 20 epp2 pr5|14,* code 000056 aa 6 00150 2521 00 spri2 pr6|104 000057 aa 777724 3520 04 epp2 -44,ic 000003 = 464000000000 000060 aa 6 00152 2521 00 spri2 pr6|106 000061 aa 6 00160 2521 00 spri2 pr6|112 000062 aa 777716 3520 04 epp2 -50,ic 000000 = 524000000021 000063 aa 6 00154 2521 00 spri2 pr6|108 000064 aa 6 00156 2521 00 spri2 pr6|110 000065 aa 777714 3520 04 epp2 -52,ic 000001 = 404000000043 000066 aa 6 00162 2521 00 spri2 pr6|114 000067 aa 6 00136 6211 00 eax1 pr6|94 000070 aa 024000 4310 07 fld 10240,dl 000071 aa 6 00044 3701 20 epp4 pr6|36,* 000072 la 4 00010 3521 20 epp2 pr4|8,* link_snap$make_ptr 000073 aa 0 00622 7001 00 tsx0 pr0|402 call_ext_out_desc STATEMENT 1 ON LINE 87 if code ^= 0 then do; 000074 aa 6 00032 3735 20 epp7 pr6|26,* 000075 aa 7 00016 2361 20 ldq pr7|14,* code 000076 aa 000005 6000 04 tze 5,ic 000103 STATEMENT 1 ON LINE 88 code = error_table_$no_trap_proc; 000077 aa 6 00044 3701 20 epp4 pr6|36,* 000100 la 4 00020 2361 20 ldq pr4|16,* error_table_$no_trap_proc 000101 aa 7 00016 7561 20 stq pr7|14,* code STATEMENT 1 ON LINE 89 return; 000102 aa 0 00631 7101 00 tra pr0|409 return_mac STATEMENT 1 ON LINE 90 end; STATEMENT 1 ON LINE 92 if mcptr ^= null then old_sp = mcptr -> mc.prs (6); 000103 aa 7 00002 2371 20 ldaq pr7|2,* mcptr 000104 aa 777700 6770 04 eraq -64,ic 000004 = 077777000043 000001000000 000105 aa 0 00460 3771 00 anaq pr0|304 = 077777000077 777777077077 000106 aa 000006 6000 04 tze 6,ic 000114 000107 aa 7 00002 3715 20 epp5 pr7|2,* mcptr 000110 aa 5 00000 3715 20 epp5 pr5|0,* mcptr 000111 aa 5 00014 3535 20 epp3 pr5|12,* mc.prs 000112 aa 6 00102 2535 00 spri3 pr6|66 old_sp 000113 aa 000065 7100 04 tra 53,ic 000200 STATEMENT 1 ON LINE 93 else do; STATEMENT 1 ON LINE 94 label_var = begin; 000114 aa 777712 3520 04 epp2 -54,ic 000026 = 777756373424 000115 aa 6 00110 2521 00 spri2 pr6|72 label_var 000116 aa 6 00112 6521 00 spri6 pr6|74 label_var STATEMENT 1 ON LINE 95 sp = addr (label_var) -> label_temp.stackp; 000117 aa 6 00112 3715 20 epp5 pr6|74,* label_temp.stackp 000120 aa 6 00116 6515 00 spri5 pr6|78 sp STATEMENT 1 ON LINE 101 level = level$get (); 000121 aa 6 00135 3521 00 epp2 pr6|93 000122 aa 6 00124 2521 00 spri2 pr6|84 000123 aa 6 00122 6211 00 eax1 pr6|82 000124 aa 004000 4310 07 fld 2048,dl 000125 aa 6 00044 3701 20 epp4 pr6|36,* 000126 la 4 00014 3521 20 epp2 pr4|12,* level$get 000127 aa 0 00623 7001 00 tsx0 pr0|403 call_ext_out 000130 aa 6 00135 2361 00 ldq pr6|93 000131 aa 6 00105 7561 00 stq pr6|69 level STATEMENT 1 ON LINE 102 i = 0; 000132 aa 6 00104 4501 00 stz pr6|68 i STATEMENT 1 ON LINE 103 if level = 0 then old_sp = sp; 000133 aa 000004 6010 04 tnz 4,ic 000137 000134 aa 6 00116 3735 20 epp7 pr6|78,* sp 000135 aa 6 00102 6535 00 spri7 pr6|66 old_sp 000136 aa 000042 7100 04 tra 34,ic 000200 STATEMENT 1 ON LINE 104 else do; STATEMENT 1 ON LINE 105 do while (baseno (sp -> stack_frame.prev_sp) = baseno (sp)); 000137 aa 000000 0110 03 nop 0,du 000140 aa 6 00116 2131 20 epaq pr6|78,* sp 000141 aa 077777 3750 03 ana 32767,du 000142 aa 6 00135 7551 00 sta pr6|93 000143 aa 6 00116 3735 20 epp7 pr6|78,* sp 000144 aa 7 00020 2131 20 epaq pr7|16,* stack_frame.prev_sp 000145 aa 077777 3750 03 ana 32767,du 000146 aa 6 00135 1151 00 cmpa pr6|93 000147 aa 000015 6010 04 tnz 13,ic 000164 STATEMENT 1 ON LINE 106 sp = sp -> stack_frame.prev_sp; 000150 aa 7 00020 3715 20 epp5 pr7|16,* stack_frame.prev_sp 000151 aa 6 00116 6515 00 spri5 pr6|78 sp STATEMENT 1 ON LINE 107 i = i + 1; 000152 aa 6 00104 0541 00 aos pr6|68 i STATEMENT 1 ON LINE 108 if i = 2000 then do; 000153 aa 6 00104 2361 00 ldq pr6|68 i 000154 aa 003720 1160 07 cmpq 2000,dl 000155 aa 777763 6010 04 tnz -13,ic 000140 STATEMENT 1 ON LINE 109 code = error_table_$no_trap_proc; 000156 aa 6 00044 3701 20 epp4 pr6|36,* 000157 la 4 00020 2361 20 ldq pr4|16,* error_table_$no_trap_proc 000160 aa 6 00032 3735 20 epp7 pr6|26,* 000161 aa 7 00016 7561 20 stq pr7|14,* code STATEMENT 1 ON LINE 110 return; 000162 aa 0 00631 7101 00 tra pr0|409 return_mac STATEMENT 1 ON LINE 111 end; STATEMENT 1 ON LINE 112 end; 000163 aa 777755 7100 04 tra -19,ic 000140 STATEMENT 1 ON LINE 113 if bin (addr (sp -> stack_frame.prev_sp) -> its.ringno, 3) ^= level then do; 000164 aa 7 00020 2351 00 lda pr7|16 its.ringno 000165 aa 000022 7350 00 als 18 000166 aa 000105 7730 00 lrl 69 000167 aa 6 00105 1161 00 cmpq pr6|69 level 000170 aa 000006 6000 04 tze 6,ic 000176 STATEMENT 1 ON LINE 119 code = error_table_$no_trap_proc; 000171 aa 6 00044 3701 20 epp4 pr6|36,* 000172 la 4 00020 2361 20 ldq pr4|16,* error_table_$no_trap_proc 000173 aa 6 00032 3715 20 epp5 pr6|26,* 000174 aa 5 00016 7561 20 stq pr5|14,* code STATEMENT 1 ON LINE 120 return; 000175 aa 0 00631 7101 00 tra pr0|409 return_mac STATEMENT 1 ON LINE 121 end; STATEMENT 1 ON LINE 122 old_sp = sp -> stack_frame.prev_sp; 000176 aa 7 00020 3715 20 epp5 pr7|16,* stack_frame.prev_sp 000177 aa 6 00102 6515 00 spri5 pr6|66 old_sp STATEMENT 1 ON LINE 123 end; STATEMENT 1 ON LINE 124 end; STATEMENT 1 ON LINE 127 sb = ptr (old_sp, 0); 000200 aa 6 00102 3525 20 epbp2 pr6|66,* old_sp 000201 aa 6 00114 2521 00 spri2 pr6|76 sb STATEMENT 1 ON LINE 128 temp = bin (rel (sb -> stack_header.stack_end_ptr), 18); 000202 aa 2 00024 6351 20 eaa pr2|20,* stack_header.stack_end_ptr 000203 aa 000066 7730 00 lrl 54 000204 aa 6 00107 7561 00 stq pr6|71 temp STATEMENT 1 ON LINE 129 if mcptr ^= null then do; 000205 aa 6 00032 3735 20 epp7 pr6|26,* 000206 aa 7 00002 2371 20 ldaq pr7|2,* mcptr 000207 aa 777575 6770 04 eraq -131,ic 000004 = 077777000043 000001000000 000210 aa 0 00460 3771 00 anaq pr0|304 = 077777000077 777777077077 000211 aa 000012 6000 04 tze 10,ic 000223 STATEMENT 1 ON LINE 130 frame_add = temp + stack_frame_min_length; 000212 aa 6 00107 2361 00 ldq pr6|71 temp 000213 aa 000060 0760 07 adq 48,dl 000214 aa 6 00106 7561 00 stq pr6|70 frame_add STATEMENT 1 ON LINE 131 old_sp -> stack_frame_flags.signaller = "1"b; 000215 aa 001000 2350 07 lda 512,dl 000216 aa 6 00102 3715 20 epp5 pr6|66,* old_sp 000217 aa 5 00020 2551 00 orsa pr5|16 stack_frame_flags.signaller STATEMENT 1 ON LINE 132 old_sp -> stack_frame_flags.old_signaller = "1"b; 000220 aa 001000 2350 07 lda 512,dl 000221 aa 5 00023 2551 00 orsa pr5|19 stack_frame_flags.old_signaller STATEMENT 1 ON LINE 133 end; 000222 aa 000003 7100 04 tra 3,ic 000225 STATEMENT 1 ON LINE 134 else do; STATEMENT 1 ON LINE 135 frame_add = temp; 000223 aa 6 00107 2361 00 ldq pr6|71 temp 000224 aa 6 00106 7561 00 stq pr6|70 frame_add STATEMENT 1 ON LINE 137 end; STATEMENT 1 ON LINE 141 sp, /* get ptr to new stack frame */ old_sp -> stack_frame.next_sp = ptr (sb, frame_add); 000225 aa 2 00000 3515 00 epp1 pr2|0 000226 aa 000000 3114 06 eawp1 0,ql 000227 aa 6 00120 2515 00 spri1 pr6|80 000230 aa 6 00116 2515 00 spri1 pr6|78 sp 000231 aa 6 00102 3715 20 epp5 pr6|66,* old_sp 000232 aa 5 00022 2515 00 spri1 pr5|18 stack_frame.next_sp STATEMENT 1 ON LINE 146 sp -> stack_frame.next_sp, sb -> stack_header.stack_end_ptr = addrel (sp, size (trap_return_frame)); 000233 aa 6 00116 3515 20 epp1 pr6|78,* sp 000234 aa 000220 0510 03 adwp1 144,du 000235 aa 6 00120 2515 00 spri1 pr6|80 000236 aa 6 00116 3535 20 epp3 pr6|78,* sp 000237 aa 3 00022 2515 00 spri1 pr3|18 stack_frame.next_sp 000240 aa 2 00024 2515 00 spri1 pr2|20 stack_header.stack_end_ptr STATEMENT 1 ON LINE 148 sp -> stack_frame.prev_sp = old_sp; 000241 aa 3 00020 6515 00 spri5 pr3|16 stack_frame.prev_sp STATEMENT 1 ON LINE 150 sp -> stack_frame_flags.link_trap = "1"b; 000242 aa 000400 2350 07 lda 256,dl 000243 aa 3 00020 2551 00 orsa pr3|16 stack_frame_flags.link_trap STATEMENT 1 ON LINE 151 sp -> stack_frame.translator_id = bit (bin (10, 18), 18); 000244 aa 000012 2350 07 lda 10,dl 000245 aa 000002 6050 04 tpl 2,ic 000247 000246 aa 000000 5310 00 neg 0 000247 aa 000022 7350 00 als 18 000250 aa 3 00037 5511 60 stba pr3|31,60 stack_frame.translator_id STATEMENT 1 ON LINE 155 if mcptr = null then sp -> trap_return_frame.arg (2) = null; 000251 aa 7 00002 2371 20 ldaq pr7|2,* mcptr 000252 aa 777532 6770 04 eraq -166,ic 000004 = 077777000043 000001000000 000253 aa 0 00460 3771 00 anaq pr0|304 = 077777000077 777777077077 000254 aa 000004 6010 04 tnz 4,ic 000260 000255 aa 777527 2370 04 ldaq -169,ic 000004 = 077777000043 000001000000 000256 aa 3 00142 7571 00 staq pr3|98 trap_return_frame.arg 000257 aa 000016 7100 04 tra 14,ic 000275 STATEMENT 1 ON LINE 156 else do; STATEMENT 1 ON LINE 157 old_sp -> stack_frame_flags.old_signaller = "1"b; 000260 aa 001000 2350 07 lda 512,dl 000261 aa 5 00023 2551 00 orsa pr5|19 stack_frame_flags.old_signaller STATEMENT 1 ON LINE 158 pds$signal_data = mcptr -> m_c; 000262 aa 6 00044 3701 20 epp4 pr6|36,* 000263 la 4 00016 3515 20 epp1 pr4|14,* pds$signal_data 000264 aa 7 00002 3535 20 epp3 pr7|2,* mcptr 000265 aa 3 00000 3535 20 epp3 pr3|0,* mcptr 000266 aa 000 100 100 500 mlr (pr),(pr),fill(000) 000267 aa 3 00000 00 0300 desc9a pr3|0,192 m_c 000270 aa 1 00000 00 0300 desc9a pr1|0,192 pds$signal_data STATEMENT 1 ON LINE 159 sp -> trap_return_frame.arg (2) = addr (sp -> trap_return_frame.mach_cond); 000271 aa 6 00116 3535 20 epp3 pr6|78,* sp 000272 aa 3 00060 3535 00 epp3 pr3|48 trap_return_frame.mach_cond 000273 aa 6 00116 3715 20 epp5 pr6|78,* sp 000274 aa 5 00142 2535 00 spri3 pr5|98 trap_return_frame.arg STATEMENT 1 ON LINE 160 end; STATEMENT 1 ON LINE 161 sp -> trap_return_frame.arg (1) = null; 000275 aa 777507 2370 04 ldaq -185,ic 000004 = 077777000043 000001000000 000276 aa 6 00116 3715 20 epp5 pr6|78,* sp 000277 aa 5 00140 7571 00 staq pr5|96 trap_return_frame.arg STATEMENT 1 ON LINE 162 sp -> trap_return_frame.arg (3) = header_ptr; 000300 aa 7 00004 3535 20 epp3 pr7|4,* header_ptr 000301 aa 3 00000 3535 20 epp3 pr3|0,* header_ptr 000302 aa 5 00144 2535 00 spri3 pr5|100 trap_return_frame.arg STATEMENT 1 ON LINE 163 sp -> trap_return_frame.arg (4) = def_ptr; 000303 aa 7 00006 3515 20 epp1 pr7|6,* def_ptr 000304 aa 1 00000 3515 20 epp1 pr1|0,* def_ptr 000305 aa 5 00146 2515 00 spri1 pr5|102 trap_return_frame.arg STATEMENT 1 ON LINE 164 sp -> trap_return_frame.arg (5) = type_ptr; 000306 aa 7 00010 3535 20 epp3 pr7|8,* type_ptr 000307 aa 3 00000 3535 20 epp3 pr3|0,* type_ptr 000310 aa 5 00150 2535 00 spri3 pr5|104 trap_return_frame.arg STATEMENT 1 ON LINE 165 sp -> trap_return_frame.arg (6) = link_ptr; 000311 aa 7 00012 3515 20 epp1 pr7|10,* link_ptr 000312 aa 1 00000 3515 20 epp1 pr1|0,* link_ptr 000313 aa 5 00152 2515 00 spri1 pr5|106 trap_return_frame.arg STATEMENT 1 ON LINE 166 sp -> trap_return_frame.arg (7) = ecode_ptr; 000314 aa 7 00014 3535 20 epp3 pr7|12,* ecode_ptr 000315 aa 3 00000 3535 20 epp3 pr3|0,* ecode_ptr 000316 aa 5 00154 2535 00 spri3 pr5|108 trap_return_frame.arg STATEMENT 1 ON LINE 170 sp -> trap_return_frame.arglist.arg_count = bit (bin (12, 18), 18); 000317 aa 000014 2350 07 lda 12,dl 000320 aa 000002 6050 04 tpl 2,ic 000322 000321 aa 000000 5310 00 neg 0 000322 aa 000022 7350 00 als 18 000323 aa 5 00156 5511 60 stba pr5|110,60 trap_return_frame.arg_count STATEMENT 1 ON LINE 171 sp -> trap_return_frame.arglist.code = bit (bin (4, 18), 18); 000324 aa 000004 2350 07 lda 4,dl 000325 aa 000002 6050 04 tpl 2,ic 000327 000326 aa 000000 5310 00 neg 0 000327 aa 0 00264 3771 00 anaq pr0|180 = 000000777777 777777777777 000330 aa 5 00156 5511 14 stba pr5|110,14 trap_return_frame.code STATEMENT 1 ON LINE 172 sp -> trap_return_frame.arglist.desc_count, sp -> trap_return_frame.arglist.pad = "0"b; 000331 aa 777777 2350 07 lda 262143,dl 000332 aa 5 00157 3551 00 ansa pr5|111 trap_return_frame.desc_count 000333 aa 777777 2350 03 lda 262143,du 000334 aa 5 00157 3551 00 ansa pr5|111 trap_return_frame.pad STATEMENT 1 ON LINE 176 do i = 1 to 7; 000335 aa 000001 2360 07 ldq 1,dl 000336 aa 6 00104 7561 00 stq pr6|68 i 000337 aa 000000 0110 03 nop 0,du 000340 aa 6 00104 2361 00 ldq pr6|68 i 000341 aa 000007 1160 07 cmpq 7,dl 000342 aa 000010 6054 04 tpnz 8,ic 000352 STATEMENT 1 ON LINE 177 sp -> trap_return_frame.arglist.arg_ptrs (i) = addr (sp -> trap_return_frame.arg (i)); 000343 aa 000001 7360 00 qls 1 000344 aa 6 00116 3735 20 epp7 pr6|78,* sp 000345 aa 7 00136 3735 06 epp7 pr7|94,ql trap_return_frame.arg 000346 aa 6 00116 3715 20 epp5 pr6|78,* sp 000347 aa 5 00156 6535 06 spri7 pr5|110,ql trap_return_frame.arg_ptrs STATEMENT 1 ON LINE 179 end; 000350 aa 6 00104 0541 00 aos pr6|68 i 000351 aa 777767 7100 04 tra -9,ic 000340 STATEMENT 1 ON LINE 183 sp -> stack_frame.operator_and_lp_ptr = addr (trap_return_frame.arglist); 000352 aa 6 00116 3735 20 epp7 pr6|78,* sp 000353 aa 7 00156 3735 00 epp7 pr7|110 trap_return_frame.arglist 000354 aa 6 00116 3715 20 epp5 pr6|78,* sp 000355 aa 5 00030 6535 00 spri7 pr5|24 stack_frame.operator_and_lp_ptr STATEMENT 1 ON LINE 185 call signaller$for_linker (sp, entry_ptr); 000356 aa 6 00116 3521 00 epp2 pr6|78 sp 000357 aa 6 00140 2521 00 spri2 pr6|96 000360 aa 6 00100 3521 00 epp2 pr6|64 entry_ptr 000361 aa 6 00142 2521 00 spri2 pr6|98 000362 aa 6 00136 6211 00 eax1 pr6|94 000363 aa 010000 4310 07 fld 4096,dl 000364 aa 6 00044 3701 20 epp4 pr6|36,* 000365 la 4 00012 3521 20 epp2 pr4|10,* signaller$for_linker 000366 aa 0 00623 7001 00 tsx0 pr0|403 call_ext_out STATEMENT 1 ON LINE 187 return; 000367 aa 0 00631 7101 00 tra pr0|409 return_mac STATEMENT 1 ON LINE 188 end; END PROCEDURE trap_caller_caller_ ----------------------------------------------------------- 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