COMPILATION LISTING OF SEGMENT attempt_thunk Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Multics Op. - System M Compiled on: 11/05/86 1039.5 mst Wed Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* *********************************************************** */ 6 attempt_thunk: 7 procedure (P_encoded_value, P_blockp, P_stackp, P_refp, P_code) returns (fixed bin (35)); 8 9 /* ATTEMPT_THUNK -- This procedure is used by stu_ to call a thunk: a small 10* procedure that is used to encode a value that cannot be expressed at 11* compile time, such as the location of a value that is determined by 12* a refer extent, or adjustable automatic. The thunk is a non-quick internal 13* procedure with access to its parent's stack frame, and in theory must be 14* called with an entry variable containing a pointer to that stack frame. 15* In many cases, however (such as refer extents for based variables), the 16* thunk never references its parent's stack frame, but only references the 17* data itself (for which it is supplied a pointer) and makes some of its 18* own calculations to determine the address. 19* 20* Thus, it is often possible to call a thunk even without a stack frame 21* pointer, and that's what this program does: it examines the object code 22* of the thunk to see whether it looks like it will work without a valid 23* stack frame pointer for display chasing (linkage section references are 24* also prohibited), and if it looks safe, calls it. Of course, if there 25* is a valid stack frame pointer supplied by our caller, it uses that, 26* instead, and doesn't go through all these heuristics. 27* 28* Well, yes: I KNOW this is a kludge, but it does seem to work. Sure would 29* be nifty if this information were in the symbol table, though, and there 30* is even room elsewhere in a thunk-encoded value to put it (n1 and n2). 31* 32* 23 Jun 83, W. Olin Sibert: Initial coding, for azm and display_data_. 33* */ 34 35 declare P_encoded_value fixed bin (35) parameter; 36 declare P_blockp pointer parameter; 37 declare P_stackp pointer parameter; 38 declare P_refp pointer parameter; 39 declare P_code fixed bin (35) parameter; 40 41 declare refp pointer; 42 declare blockp pointer; 43 declare value fixed bin (35); 44 45 declare 1 ev aligned like encoded_value; 46 47 declare thunk_entry variable entry (pointer, fixed bin (35)); 48 declare 1 entry_template aligned, 49 2 location pointer, 50 2 stack_frame pointer; 51 52 declare thunk_ptr pointer; 53 declare thunk_lth fixed bin; 54 declare thunk (thunk_lth) bit (36) aligned based (thunk_ptr); 55 56 declare (addr, binary, hbound, null, pointer) builtin; 57 58 /* */ 59 60 refp = P_refp; 61 sp = P_stackp; 62 blockp = P_blockp; 63 unspec (ev) = unspec (P_encoded_value); 64 65 /* First, see if the encoded value actually represents a thunk. If not, give 66* up immediately, since our caller should have handled the other types. */ 67 68 if (binary (ev.code, 4) ^= 8) then call punt (1); /* 8 is thunk-type */ 69 70 /* Next, see if we got a valid stack pointer. If so, then we will just call 71* the thunk entry variable and be done with it. */ 72 73 if (sp ^= null ()) then do; 74 thunk_ptr = pointer (sp -> stack_frame.entry_ptr, ev.n3); 75 entry_template.location = thunk_ptr; 76 entry_template.stack_frame = sp; 77 unspec (thunk_entry) = unspec (entry_template); 78 79 call thunk_entry (refp, value); 80 81 P_code = 0; /* Successful */ 82 return (value); 83 end; 84 85 /* If we have no stack frame pointer, first we find the thunk, assuming that 86* is is in the segment that the block pointer indicates, and then we check 87* the code to ensure that it does nothing untoward. */ 88 89 if (blockp = null ()) then call punt (2); 90 91 thunk_ptr = pointer (blockp, ev.n3); 92 entry_template.location = thunk_ptr; 93 entry_template.stack_frame = baseptr (""b); /* Guaranteed unusable */ 94 unspec (thunk_entry) = unspec (entry_template); /* thunk_ptr may be changed after this. */ 95 96 call find_thunk_bounds (); 97 98 call check_thunk_code (); 99 100 call thunk_entry (refp, value); 101 102 P_code = 0; 103 return (value); 104 105 /* */ 106 107 find_thunk_bounds: 108 procedure (); 109 110 declare idx fixed bin; 111 112 113 /*^ This procedure verifies that the thunk entry sequence starts as follows: 114* lxl7 stack_frame_size,dl 115* epp2 pr7|34,* 116* tsp2 pr2|1047 int_entry 117* zero 2,0 118* zero 0,0 119* After doing so, it adjusts thunk_ptr to point to the beginning of the 120* executable code for the thunk. 121* */ 122 123 thunk_lth = 5; /* To look at the beginning */ 124 if (substr (thunk (1), 19, 18) ^= "727007"b3) then call punt (3); 125 if (thunk (2) ^= "700034352120"b3) then call punt (3); 126 if (thunk (3) ^= "201047272100"b3) then call punt (3); 127 if (thunk (4) ^= "000002000000"b3) then call punt (3); 128 if (thunk (5) ^= "000000000000"b3) then call punt (3); 129 130 thunk_ptr = addrel (thunk_ptr, 5); 131 thunk_lth = 200; /* More than 200 instructions seems unlikely */ 132 133 /* Now, go looking for the end of the thunk, searching for the transfer to 134* the return operator: 135* tra pr0|631 return 136* */ 137 138 do idx = 1 to hbound (thunk, 1); 139 if (thunk (idx) = "000631710100"b3) then do; 140 thunk_lth = idx - 1; 141 return; 142 end; 143 end; 144 145 call punt (4); /* No return operator found */ 146 147 end find_thunk_bounds; 148 149 /* */ 150 151 check_thunk_code: 152 procedure (); 153 154 declare idx fixed bin; 155 declare jdx fixed bin; 156 declare opcode bit (12) aligned; 157 declare TRANSFERS (24) bit (12) aligned internal static options (constant) init 158 ("7100"b3 /* tra */, 159 "6050"b3 /* tpl */, 160 "6040"b3 /* tmi */, 161 "6054"b3 /* tpnz */, 162 "6000"b3 /* tze */, 163 "6010"b3 /* tnz */, 164 "6070"b3 /* ttf */, 165 "6064"b3 /* ttn */, 166 "7000"b3 /* tsx0 */, 167 "7010"b3 /* tsx1 */, 168 "7020"b3 /* tsx2 */, 169 "7030"b3 /* tsx3 */, 170 "7040"b3 /* tsx4 */, 171 "7050"b3 /* tsx5 */, 172 "7060"b3 /* tsx6 */, 173 "7070"b3 /* tsx7 */, 174 "2700"b3 /* tsp0 */, 175 "2710"b3 /* tsp1 */, 176 "2720"b3 /* tsp2 */, 177 "2730"b3 /* tsp3 */, 178 "6700"b3 /* tsp4 */, 179 "6710"b3 /* tsp5 */, 180 "6720"b3 /* tsp6 */, 181 "6730"b3 /* tsp7 */); 182 183 declare 1 inst aligned, 184 2 offset fixed bin (18) unsigned unaligned, 185 2 opcode bit (10) unaligned, 186 2 pad bit (2) unaligned, 187 2 pr_flag bit (1) unaligned, 188 2 tag bit (6) unaligned; 189 declare 1 pr_inst aligned, 190 2 pr_no fixed bin (3) unsigned unaligned, 191 2 offset fixed bin (14) unaligned, 192 2 opcode bit (10) unaligned, 193 2 pad bit (2) unaligned, 194 2 pr_flag bit (1) unaligned, 195 2 tag bit (6) unaligned; 196 197 /* */ 198 199 /* By rights, this should do more checking: it's easily confused by EIS, and 200* I'm not sure what else could go wrong. I believe I've gotten most of the 201* important cases, though. The other ones will just fault, I suppose. */ 202 203 do idx = 1 to thunk_lth; 204 unspec (inst) = thunk (idx); 205 unspec (pr_inst) = thunk (idx); 206 207 /* The most important check is for stack frame references: we allow only 208* references to the argument pointer and to variables within the variable 209* portion of the stack frame. Note that this will also disallow linkage 210* section references, since it prohibits loading the LP from the frame. */ 211 212 if inst.pr_flag then 213 if (pr_inst.pr_no = 6) then 214 if (pr_inst.offset < 64) then /* random variable */ 215 if (pr_inst.offset ^= 26) then /* arg pointer */ 216 call punt (5); 217 218 /* Next, check to be sure it's not a transfer instruction. */ 219 220 opcode = inst.opcode || "00"b; 221 do jdx = 1 to hbound (TRANSFERS, 1); 222 if (opcode = TRANSFERS (jdx)) then call punt (6); 223 end; 224 end; 225 226 return; 227 end check_thunk_code; 228 229 /* */ 230 231 PUNT: 232 return (0); 233 234 235 236 punt: 237 procedure (why); 238 239 declare why fixed bin (35) parameter; 240 241 P_code = why; 242 goto PUNT; 243 244 end punt; 245 246 /* BEGIN INCLUDE FILE ... runtime_symbol.incl.pl1 ... Modified 07/79 */ 1 2 1 3 dcl 1 runtime_symbol aligned based, 1 4 2 flag unal bit(1), /* always "1"b for Version II */ 1 5 2 use_digit unal bit(1), /* if "1"b and units are half words units are really digits */ 1 6 2 array_units unal bit(2), 1 7 2 units unal bit(2), /* addressing units */ 1 8 2 type unal bit(6), /* data type */ 1 9 2 level unal bit(6), /* structure level */ 1 10 2 ndims unal bit(6), /* number of dimensions */ 1 11 2 bits unal, 1 12 3 aligned bit(1), 1 13 3 packed bit(1), 1 14 3 simple bit(1), 1 15 2 skip unal bit(1), 1 16 2 scale unal bit(8), /* arithmetic scale factor */ 1 17 2 name unal bit(18), /* rel ptr to acc name */ 1 18 2 brother unal bit(18), /* rel ptr to brother entry */ 1 19 2 father unal bit(18), /* rel ptr to father entry */ 1 20 2 son unal bit(18), /* rel ptr to son entry */ 1 21 2 address unal, 1 22 3 location bit(18), /* location in storage class */ 1 23 3 class bit(4), /* storage class */ 1 24 3 next bit(14), /* rel ptr to next of same class */ 1 25 2 size fixed bin(35), /* encoded string|arith size */ 1 26 2 offset fixed bin(35), /* encoded offset from address */ 1 27 2 virtual_org fixed bin(35), 1 28 2 bounds(1), 1 29 3 lower fixed bin(35), /* encoded lower bound */ 1 30 3 upper fixed bin(35), /* encoded upper bound */ 1 31 3 multiplier fixed bin(35); /* encoded multiplier */ 1 32 1 33 dcl 1 runtime_bound based, 1 34 2 lower fixed bin(35), 1 35 2 upper fixed bin(35), 1 36 2 multiplier fixed bin(35); 1 37 1 38 dcl 1 runtime_block aligned based, 1 39 2 flag unal bit(1), /* always "1"b for Version II */ 1 40 2 quick unal bit(1), /* "1"b if quick block */ 1 41 2 fortran unal bit(1), /* "1"b if fortran program */ 1 42 2 standard unal bit(1), /* "1"b if program has std obj segment */ 1 43 2 owner_flag unal bit(1), /* "1"b if block has valid owner field */ 1 44 2 skip unal bit(1), 1 45 2 type unal bit(6), /* = 0 for a block node */ 1 46 2 number unal bit(6), /* begin block number */ 1 47 2 start unal bit(18), /* rel ptr to start of symbols */ 1 48 2 name unal bit(18), /* rel ptr to name of proc */ 1 49 2 brother unal bit(18), /* rel ptr to brother block */ 1 50 2 father unal bit(18), /* rel ptr to father block */ 1 51 2 son unal bit(18), /* rel ptr to son block */ 1 52 2 map unal, 1 53 3 first bit(18), /* rel ptr to first word of map */ 1 54 3 last bit(18), /* rel ptr to last word of map */ 1 55 2 entry_info unal bit(18), /* info about entry of quick block */ 1 56 2 header unal bit(18), /* rel ptr to symbol header */ 1 57 2 chain(4) unal bit(18), /* chain(i) is rel ptr to first symbol 1 58* on start list with length >= 2**i */ 1 59 2 token(0:5) unal bit(18), /* token(i) is rel ptr to first token 1 60* on list with length >= 2 ** i */ 1 61 2 owner unal bit(18); /* rel ptr to owner block */ 1 62 1 63 dcl 1 runtime_token aligned based, 1 64 2 next unal bit(18), /* rel ptr to next token */ 1 65 2 dcl unal bit(18), /* rel ptr to first dcl of this token */ 1 66 2 name, /* ACC */ 1 67 3 size unal unsigned fixed bin (9), /* number of chars in token */ 1 68 3 string unal char(n refer(runtime_token.size)); 1 69 1 70 dcl 1 encoded_value aligned based, 1 71 2 flag bit (2) unal, 1 72 2 code bit (4) unal, 1 73 2 n1 bit (6) unal, 1 74 2 n2 bit (6) unal, 1 75 2 n3 bit (18) unal; 1 76 1 77 /* END INCLUDE FILE ... runtime_symbol.incl.pl1 */ 246 247 /* BEGIN INCLUDE FILE ... stack_frame.incl.pl1 ... */ 2 2 2 3 /* format: off */ 2 4 2 5 /* Modified: 16 Dec 1977, D. Levin - to add fio_ps_ptr and pl1_ps_ptr */ 2 6 /* Modified: 3 Feb 1978, P. Krupp - to add run_unit_manager bit & main_proc bit */ 2 7 /* Modified: 21 March 1978, D. Levin - change fio_ps_ptr to support_ptr */ 2 8 /* Modified: 03/01/84, S. Herbst - Added RETURN_PTR_MASK */ 2 9 2 10 2 11 /****^ HISTORY COMMENTS: 2 12* 1) change(86-09-15,Kissel), approve(86-09-15,MCR7473), 2 13* audit(86-10-01,Fawcett), install(86-11-03,MR12.0-1206): 2 14* Modified to add constants for the translator_id field in the stack_frame 2 15* structure. 2 16* END HISTORY COMMENTS */ 2 17 2 18 2 19 dcl RETURN_PTR_MASK bit (72) int static options (constant) /* mask to be AND'd with stack_frame.return_ptr */ 2 20 init ("777777777777777777000000"b3); /* when copying, to ignore bits that a call fills */ 2 21 /* with indicators (nonzero for Fortran hexfp caller) */ 2 22 /* say: unspec(ptr) = unspec(stack_frame.return_ptr) & RETURN_PTR_MASK; */ 2 23 2 24 dcl TRANSLATOR_ID_PL1V2 bit (18) internal static options (constant) init ("000000"b3); 2 25 dcl TRANSLATOR_ID_ALM bit (18) internal static options (constant) init ("000001"b3); 2 26 dcl TRANSLATOR_ID_PL1V1 bit (18) internal static options (constant) init ("000002"b3); 2 27 dcl TRANSLATOR_ID_SIGNAL_CALLER bit (18) internal static options (constant) init ("000003"b3); 2 28 dcl TRANSLATOR_ID_SIGNALLER bit (18) internal static options (constant) init ("000004"b3); 2 29 2 30 2 31 dcl sp pointer; /* pointer to beginning of stack frame */ 2 32 2 33 dcl stack_frame_min_length fixed bin static init(48); 2 34 2 35 2 36 dcl 1 stack_frame based(sp) aligned, 2 37 2 pointer_registers(0 : 7) ptr, 2 38 2 prev_sp pointer, 2 39 2 next_sp pointer, 2 40 2 return_ptr pointer, 2 41 2 entry_ptr pointer, 2 42 2 operator_and_lp_ptr ptr, /* serves as both */ 2 43 2 arg_ptr pointer, 2 44 2 static_ptr ptr unaligned, 2 45 2 support_ptr ptr unal, /* only used by fortran I/O */ 2 46 2 on_unit_relp1 bit(18) unaligned, 2 47 2 on_unit_relp2 bit(18) unaligned, 2 48 2 translator_id bit(18) unaligned, /* Translator ID (see constants above) 2 49* 0 => PL/I version II 2 50* 1 => ALM 2 51* 2 => PL/I version I 2 52* 3 => signal caller frame 2 53* 4 => signaller frame */ 2 54 2 operator_return_offset bit(18) unaligned, 2 55 2 x(0: 7) bit(18) unaligned, /* index registers */ 2 56 2 a bit(36), /* accumulator */ 2 57 2 q bit(36), /* q-register */ 2 58 2 e bit(36), /* exponent */ 2 59 2 timer bit(27) unaligned, /* timer */ 2 60 2 pad bit(6) unaligned, 2 61 2 ring_alarm_reg bit(3) unaligned; 2 62 2 63 2 64 dcl 1 stack_frame_flags based(sp) aligned, 2 65 2 pad(0 : 7) bit(72), /* skip over prs */ 2 66 2 xx0 bit(22) unal, 2 67 2 main_proc bit(1) unal, /* on if frame belongs to a main procedure */ 2 68 2 run_unit_manager bit(1) unal, /* on if frame belongs to run unit manager */ 2 69 2 signal bit(1) unal, /* on if frame belongs to logical signal_ */ 2 70 2 crawl_out bit(1) unal, /* on if this is a signal caller frame */ 2 71 2 signaller bit(1) unal, /* on if next frame is signaller's */ 2 72 2 link_trap bit(1) unal, /* on if this frame was made by the linker */ 2 73 2 support bit(1) unal, /* on if frame belongs to a support proc */ 2 74 2 condition bit(1) unal, /* on if condition established in this frame */ 2 75 2 xx0a bit(6) unal, 2 76 2 xx1 fixed bin, 2 77 2 xx2 fixed bin, 2 78 2 xx3 bit(25) unal, 2 79 2 old_crawl_out bit (1) unal, /* on if this is a signal caller frame */ 2 80 2 old_signaller bit(1) unal, /* on if next frame is signaller's */ 2 81 2 xx3a bit(9) unaligned, 2 82 2 xx4(9) bit(72) aligned, 2 83 2 v2_pl1_op_ret_base ptr, /* When a V2 PL/I program calls an operator the 2 84* * operator puts a pointer to the base of 2 85* * the calling procedure here. (text base ptr) */ 2 86 2 xx5 bit(72) aligned, 2 87 2 pl1_ps_ptr ptr; /* ptr to ps for this frame; also used by fio. */ 2 88 2 89 /* format: on */ 2 90 2 91 /* END INCLUDE FILE ... stack_frame.incl.pl1 */ 247 248 249 end attempt_thunk; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/04/86 1042.3 attempt_thunk.pl1 >special_ldd>install>MR12.0-1206>attempt_thunk.pl1 246 1 11/26/79 1320.6 runtime_symbol.incl.pl1 >ldd>include>runtime_symbol.incl.pl1 247 2 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. P_blockp parameter pointer dcl 36 ref 6 62 P_code parameter fixed bin(35,0) dcl 39 set ref 6 81* 102* 241* P_encoded_value parameter fixed bin(35,0) dcl 35 ref 6 63 P_refp parameter pointer dcl 38 ref 6 60 P_stackp parameter pointer dcl 37 ref 6 61 TRANSFERS 000000 constant bit(12) initial array dcl 157 ref 221 222 binary builtin function dcl 56 ref 68 blockp 000102 automatic pointer dcl 42 set ref 62* 89 91 code 0(02) 000105 automatic bit(4) level 2 packed unaligned dcl 45 set ref 68 encoded_value based structure level 1 dcl 1-70 entry_ptr 26 based pointer level 2 dcl 2-36 ref 74 entry_template 000112 automatic structure level 1 dcl 48 set ref 77 94 ev 000105 automatic structure level 1 dcl 45 set ref 63* hbound builtin function dcl 56 ref 138 221 idx 000132 automatic fixed bin(17,0) dcl 110 in procedure "find_thunk_bounds" set ref 138* 139 140* idx 000142 automatic fixed bin(17,0) dcl 154 in procedure "check_thunk_code" set ref 203* 204 205* inst 000146 automatic structure level 1 dcl 183 set ref 204* jdx 000143 automatic fixed bin(17,0) dcl 155 set ref 221* 222* location 000112 automatic pointer level 2 dcl 48 set ref 75* 92* n3 0(18) 000105 automatic bit(18) level 2 packed unaligned dcl 45 set ref 74 91 null builtin function dcl 56 ref 73 89 offset 0(03) 000150 automatic fixed bin(14,0) level 2 packed unaligned dcl 189 set ref 212 212 opcode 000144 automatic bit(12) dcl 156 in procedure "check_thunk_code" set ref 220* 222 opcode 0(18) 000146 automatic bit(10) level 2 in structure "inst" packed unaligned dcl 183 in procedure "check_thunk_code" set ref 220 pointer builtin function dcl 56 ref 74 91 pr_flag 0(30) 000146 automatic bit(1) level 2 packed unaligned dcl 183 set ref 212 pr_inst 000150 automatic structure level 1 dcl 189 set ref 205* pr_no 000150 automatic fixed bin(3,0) level 2 packed unsigned unaligned dcl 189 set ref 212 refp 000100 automatic pointer dcl 41 set ref 60* 79* 100* sp 000122 automatic pointer dcl 2-31 set ref 61* 73 74 76 stack_frame 2 000112 automatic pointer level 2 in structure "entry_template" dcl 48 in procedure "attempt_thunk" set ref 76* 93* stack_frame based structure level 1 dcl 2-36 in procedure "attempt_thunk" thunk based bit(36) array dcl 54 ref 124 125 126 127 128 138 139 204 205 thunk_entry 000106 automatic entry variable dcl 47 set ref 77* 79 94* 100 thunk_lth 000120 automatic fixed bin(17,0) dcl 53 set ref 123* 131* 138 140* 203 thunk_ptr 000116 automatic pointer dcl 52 set ref 74* 75 91* 92 124 125 126 127 128 130* 130 138 139 204 205 value 000104 automatic fixed bin(35,0) dcl 43 set ref 79* 82 100* 103 why parameter fixed bin(35,0) dcl 239 ref 236 241 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. RETURN_PTR_MASK internal static bit(72) initial unaligned dcl 2-19 TRANSLATOR_ID_ALM internal static bit(18) initial unaligned dcl 2-25 TRANSLATOR_ID_PL1V1 internal static bit(18) initial unaligned dcl 2-26 TRANSLATOR_ID_PL1V2 internal static bit(18) initial unaligned dcl 2-24 TRANSLATOR_ID_SIGNALLER internal static bit(18) initial unaligned dcl 2-28 TRANSLATOR_ID_SIGNAL_CALLER internal static bit(18) initial unaligned dcl 2-27 addr builtin function dcl 56 runtime_block based structure level 1 dcl 1-38 runtime_bound based structure level 1 unaligned dcl 1-33 runtime_symbol based structure level 1 dcl 1-3 runtime_token based structure level 1 dcl 1-63 stack_frame_flags based structure level 1 dcl 2-64 stack_frame_min_length internal static fixed bin(17,0) initial dcl 2-33 NAMES DECLARED BY EXPLICIT CONTEXT. PUNT 000202 constant label dcl 231 ref 242 attempt_thunk 000046 constant entry external dcl 6 check_thunk_code 000311 constant entry internal dcl 151 ref 98 find_thunk_bounds 000205 constant entry internal dcl 107 ref 96 punt 000403 constant entry internal dcl 236 ref 68 89 124 125 126 127 128 145 212 222 NAMES DECLARED BY CONTEXT OR IMPLICATION. addrel builtin function ref 130 baseptr builtin function ref 93 substr builtin function ref 124 unspec builtin function set ref 63 63 77* 77 94* 94 204* 205* STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 460 470 432 470 Length 674 432 10 170 25 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME attempt_thunk 126 external procedure is an external procedure. find_thunk_bounds internal procedure shares stack frame of external procedure attempt_thunk. check_thunk_code internal procedure shares stack frame of external procedure attempt_thunk. punt internal procedure shares stack frame of external procedure attempt_thunk. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME attempt_thunk 000100 refp attempt_thunk 000102 blockp attempt_thunk 000104 value attempt_thunk 000105 ev attempt_thunk 000106 thunk_entry attempt_thunk 000112 entry_template attempt_thunk 000116 thunk_ptr attempt_thunk 000120 thunk_lth attempt_thunk 000122 sp attempt_thunk 000132 idx find_thunk_bounds 000142 idx check_thunk_code 000143 jdx check_thunk_code 000144 opcode check_thunk_code 000146 inst check_thunk_code 000150 pr_inst check_thunk_code THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ent_var return_mac ext_entry NO EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 6 000040 60 000053 61 000057 62 000062 63 000065 68 000067 73 000100 74 000104 75 000112 76 000113 77 000114 79 000120 81 000130 82 000132 89 000135 91 000145 92 000152 93 000153 94 000157 96 000163 98 000164 100 000165 102 000175 103 000177 231 000202 107 000205 123 000206 124 000210 125 000220 126 000230 127 000240 128 000250 130 000257 131 000262 138 000264 139 000273 140 000277 141 000301 143 000302 145 000304 147 000310 151 000311 203 000312 204 000321 205 000325 212 000331 220 000353 221 000362 222 000367 223 000376 224 000400 226 000402 236 000403 241 000405 242 000410 ----------------------------------------------------------- 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