COMPILATION LISTING OF SEGMENT get_block Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Multics Op. - System M Compiled on: 11/12/86 1653.0 mst Wed Options: optimize map 1 /****^ ****************************************************** 2* * * 3* * Copyright (c) 1986 by Massachusetts Institute of * 4* * Technology and Honeywell Information Systems, Inc. * 5* * * 6* * Copyright (c) 1972 by Massachusetts Institute of * 7* * Technology and Honeywell Information Systems, Inc. * 8* * * 9* ****************************************************** */ 10 11 12 /****^ HISTORY COMMENTS: 13* 1) change(86-09-05,JMAthane), approve(86-09-05,MCR7525), 14* audit(86-09-11,Martinson), install(86-11-12,MR12.0-1212): 15* Added PASCAL entry points parsing. 16* END HISTORY COMMENTS */ 17 18 /* Procedure to get a pointer to the runtime symbol block for a PL/I 19* program given a pointer to its stack frame and optionally an execution loc 20* 21* modified: 06 Oct 78 by James R. Davis for separate static begin blocks, greater cleanliness 22* and not assume ic is in frame owners block 23* Modified: 25 Aug 79 by JRD to find symbol section header by object info, not link 24* Modified: JMAthane, September 82 to add PASCAL entry points 25**/ 26 get_block: proc (stack_pt, header_pt, block_pt); 27 28 dcl (stack_pt ptr, /* points at stack frame (input) */ 29 header_pt ptr, /* set to point at symbol header */ 30 block_pt ptr) parameter; /* set to point at symbol block */ 31 32 dcl p ptr, /* into object seg */ 33 sp ptr, /* copy of stack_pt */ 34 ic fixed bin, /* offset of execution, or -1 if not supplied */ 35 i fixed bin, 36 based_ptr based ptr, 37 based_word bit (36) based, /* for search for instructions */ 38 rel_to_next bit (18), /* self relative offset for symbol table search */ 39 bitcount fixed bin (24), 40 code fixed bin (35), 41 trans fixed bin; /* translator that produced object seg */ 42 43 dcl 1 oi aligned like object_info; 44 45 dcl hcs_$status_mins entry (ptr, fixed bin (2), fixed bin (24), fixed bin (35)); 46 dcl object_info_$brief entry (ptr, fixed bin (24), ptr, fixed bin (35)); 47 dcl (addr, addrel, fixed, null, pointer) builtin; 48 49 dcl 1 structure aligned based, /* two words placed by PL/I in entry sequence */ 50 2 ignore bit (36), /* various flags we dont care about */ 51 2 head_offset bit (18) unal, /* offset in linkage sec of ptr to header */ 52 2 block_offset bit (18) unal; /* offset from header to frame owner block node */ 53 54 55 56 /* no location available with this entry */ 57 58 ic = -1; 59 60 join: sp = stack_pt; 61 header_pt, block_pt = null; /* assume the worst */ 62 if sp = null then return; /* cant find translator or entry ptr, give up */ 63 64 trans = fixed (sp -> frame.translator_id, 18); /* who made this seg? */ 65 if trans = 0 then do; /* PL/I version 2 */ 66 p = addrel (sp -> frame.entry, 1); 67 if p -> based_word ^= "000614272100"b3 /* tsp2 pr0|614 enter_begin */ 68 & p -> based_word ^= "001376272100"b3 /* tsp2 pr0|1376 ss_enter_begin */ 69 then p = addrel (p, 2); /* not a begin block, so skip two instructions */ 70 end; 71 else if trans = 2 then do; /* PL/I version 1 */ 72 p = addrel (p, 3); 73 74 /* in version 1 the header and block offsets are marked by a preceeding 75* tra 2,ic instruction, which is anywhere from 3 to 8 words past the address 76* pointed to by the entry pointer */ 77 78 do i = 3 to 8; 79 if p -> based_word = "000002710004"b3 then goto found_tra; 80 p = addrel (p, 1); 81 end; 82 return; /* fell through, its not there ! */ 83 found_tra: end; /* of version one */ 84 else if trans = 8 then do; /* Grenoble University PASCAL */ 85 p = addrel (sp -> frame.entry, 2); /* 3rd word */ 86 if (p -> based_word ^= "000001273100"b3) /* tsp3 0|1 : old internal */ 87 & (p -> based_word ^= "000064273100"b3) /* tsp3 0|52 : internal */ 88 & (p -> based_word ^= "000131273100"b3) /* tsp3 0|89 : v7 int_entry */ 89 then do; 90 p = addrel (p, 2); /* 5th word */ 91 if (p -> based_word ^= "500002273100"b3) /* tsp3 5|2 : old exportable */ 92 & (p -> based_word ^= "500055273100"b3) /* tsp3 5|45 : old exportable fast */ 93 & (p -> based_word ^= "500065273100"b3) /* tsp3 5|53 : exportable */ 94 & (p -> based_word ^= "500067273100"b3) /* tsp3 5|55 : exportable fast */ 95 then do; 96 p = addrel (p, 1); /* 6th word */ 97 if (p -> based_word ^= "200117273100"b3) /* tsp3 2|79 : v7 MAIN_entry */ 98 & (p -> based_word ^= "200130273100"b3) /* tsp3 2|88 : v7 ext_entry */ 99 then do; 100 p = addrel (p, 2); /* 8th word */ 101 if (p -> based_word ^= "500000273100"b3) /* tsp3 5|0 : old MAIN */ 102 & (p -> based_word ^= "500054273100"b3) /* tsp3 5|44 : old MAIN_fast */ 103 & (p -> based_word ^= "500063273100"b3) /* tsp3 5|51 : MAIN */ 104 & (p -> based_word ^= "500066273100"b3) /* tsp3 5|54 MAIN fast */ 105 then return; 106 end; 107 end; 108 end; 109 p = addrel (p, 1); 110 end; 111 else return; /* no other language is supported */ 112 113 /* now p points to the two word structure where symbol table ptrs are */ 114 115 if p -> structure.head_offset = (18)"0"b then return; /* no symbol table */ 116 117 /* in former days, we got a pointer to the symbol section header by snapping the link *symbol, 118* which is found at offselt {p -> structure.head_offset} in the linkage section 119* 120* This is not a good idea though, because a run unit may have been entered since the time 121* that the program called out, which means that snapping links will not work. Run units 122* work by setting up a whole new name space. 123**/ 124 125 call hcs_$status_mins (pointer (p, 0), (0), bitcount, code); 126 if code ^= 0 then return; 127 oi.version_number = object_info_version_2; 128 call object_info_$brief (pointer (p, 0), bitcount, addr (oi), code); 129 if code ^= 0 then return; 130 header_pt = oi.symbp; 131 132 /* if the seg is bound, then header_pt is to header of the whole seg. Thats OK, because the 133* have the offset relative to the header of the block node we are interested in. From that block node 134* we can get the ptr to the header we want. 135**/ 136 137 138 block_pt = addrel (header_pt, p -> structure.block_offset); 139 140 if ^block_pt -> runtime_block.flag then return; /* not modern symbol table, can do no more */ 141 142 if ic < 0 then return; /* cant be a quick block */ 143 144 /* get pointer to the root symbol_block for this seg. The seg may be bound, we cant trust 145* header_pt, as it may be the header for the bound seg as a whole. Find the header for the component */ 146 147 p = addrel (block_pt, block_pt -> runtime_block.header); /* point to header */ 148 block_pt = addrel (p, p -> std_symbol_header.area_pointer); /* point to pl1 symbol block */ 149 block_pt = addrel (p, block_pt -> pl1_symbol_block.root); /* point at first block */ 150 block_pt = addrel (block_pt, block_pt -> runtime_block.son); /* skip the root, its useless */ 151 152 /* now search from the first block (root) for the smallest block that contains ic */ 153 154 rel_to_next = "1"b; /* make sure we enter loop */ 155 do p = block_pt repeat addrel (p, rel_to_next) while (rel_to_next ^= (18)"0"b); 156 if ic >= fixed (addrel (p, p -> runtime_block.first) -> statement_map.location, 18) 157 & ic <= fixed (addrel (p, p -> runtime_block.last) -> statement_map.location, 18) 158 then do; 159 block_pt = p; /* we are in this block */ 160 rel_to_next = p -> runtime_block.son; /* search son if there is one */ 161 end; 162 else rel_to_next = p -> runtime_block.brother; /* else brother */ 163 end; 164 return; 165 166 get_runtime_block: entry (stack_pt, header_pt, block_pt, loc); 167 168 dcl loc fixed bin parameter; 169 170 /* this entry is called when a location in the object seg is available 171* One should not expect stu_ to do without the stack_pt, 172* even though stu could find the symbol information without it. It is up to 173* the caller to get it */ 174 175 ic = loc; 176 goto join; 177 1 1 dcl 1 frame aligned based, 1 2 2 pointers(0:7) ptr, 1 3 2 back ptr, 1 4 2 next ptr, 1 5 2 return ptr, 1 6 2 entry ptr, 1 7 2 operator ptr, 1 8 2 argptr ptr, 1 9 2 skip1(2) fixed bin, 1 10 2 on_unit_info(2) bit(18) unaligned, 1 11 2 translator_id bit(18) unaligned, 1 12 2 operator_return bit(18) unaligned, 1 13 2 display ptr, 1 14 2 skip2(2) fixed bin, 1 15 2 linkage ptr; 178 2 1 /* BEGIN INCLUDE FILE ... runtime_symbol.incl.pl1 ... Modified 07/79 */ 2 2 2 3 dcl 1 runtime_symbol aligned based, 2 4 2 flag unal bit(1), /* always "1"b for Version II */ 2 5 2 use_digit unal bit(1), /* if "1"b and units are half words units are really digits */ 2 6 2 array_units unal bit(2), 2 7 2 units unal bit(2), /* addressing units */ 2 8 2 type unal bit(6), /* data type */ 2 9 2 level unal bit(6), /* structure level */ 2 10 2 ndims unal bit(6), /* number of dimensions */ 2 11 2 bits unal, 2 12 3 aligned bit(1), 2 13 3 packed bit(1), 2 14 3 simple bit(1), 2 15 2 skip unal bit(1), 2 16 2 scale unal bit(8), /* arithmetic scale factor */ 2 17 2 name unal bit(18), /* rel ptr to acc name */ 2 18 2 brother unal bit(18), /* rel ptr to brother entry */ 2 19 2 father unal bit(18), /* rel ptr to father entry */ 2 20 2 son unal bit(18), /* rel ptr to son entry */ 2 21 2 address unal, 2 22 3 location bit(18), /* location in storage class */ 2 23 3 class bit(4), /* storage class */ 2 24 3 next bit(14), /* rel ptr to next of same class */ 2 25 2 size fixed bin(35), /* encoded string|arith size */ 2 26 2 offset fixed bin(35), /* encoded offset from address */ 2 27 2 virtual_org fixed bin(35), 2 28 2 bounds(1), 2 29 3 lower fixed bin(35), /* encoded lower bound */ 2 30 3 upper fixed bin(35), /* encoded upper bound */ 2 31 3 multiplier fixed bin(35); /* encoded multiplier */ 2 32 2 33 dcl 1 runtime_bound based, 2 34 2 lower fixed bin(35), 2 35 2 upper fixed bin(35), 2 36 2 multiplier fixed bin(35); 2 37 2 38 dcl 1 runtime_block aligned based, 2 39 2 flag unal bit(1), /* always "1"b for Version II */ 2 40 2 quick unal bit(1), /* "1"b if quick block */ 2 41 2 fortran unal bit(1), /* "1"b if fortran program */ 2 42 2 standard unal bit(1), /* "1"b if program has std obj segment */ 2 43 2 owner_flag unal bit(1), /* "1"b if block has valid owner field */ 2 44 2 skip unal bit(1), 2 45 2 type unal bit(6), /* = 0 for a block node */ 2 46 2 number unal bit(6), /* begin block number */ 2 47 2 start unal bit(18), /* rel ptr to start of symbols */ 2 48 2 name unal bit(18), /* rel ptr to name of proc */ 2 49 2 brother unal bit(18), /* rel ptr to brother block */ 2 50 2 father unal bit(18), /* rel ptr to father block */ 2 51 2 son unal bit(18), /* rel ptr to son block */ 2 52 2 map unal, 2 53 3 first bit(18), /* rel ptr to first word of map */ 2 54 3 last bit(18), /* rel ptr to last word of map */ 2 55 2 entry_info unal bit(18), /* info about entry of quick block */ 2 56 2 header unal bit(18), /* rel ptr to symbol header */ 2 57 2 chain(4) unal bit(18), /* chain(i) is rel ptr to first symbol 2 58* on start list with length >= 2**i */ 2 59 2 token(0:5) unal bit(18), /* token(i) is rel ptr to first token 2 60* on list with length >= 2 ** i */ 2 61 2 owner unal bit(18); /* rel ptr to owner block */ 2 62 2 63 dcl 1 runtime_token aligned based, 2 64 2 next unal bit(18), /* rel ptr to next token */ 2 65 2 dcl unal bit(18), /* rel ptr to first dcl of this token */ 2 66 2 name, /* ACC */ 2 67 3 size unal unsigned fixed bin (9), /* number of chars in token */ 2 68 3 string unal char(n refer(runtime_token.size)); 2 69 2 70 dcl 1 encoded_value aligned based, 2 71 2 flag bit (2) unal, 2 72 2 code bit (4) unal, 2 73 2 n1 bit (6) unal, 2 74 2 n2 bit (6) unal, 2 75 2 n3 bit (18) unal; 2 76 2 77 /* END INCLUDE FILE ... runtime_symbol.incl.pl1 */ 179 3 1 dcl 1 std_symbol_header based aligned, 3 2 2 dcl_version fixed bin, 3 3 2 identifier char(8), 3 4 2 gen_number fixed bin, 3 5 2 gen_created fixed bin(71), 3 6 2 object_created fixed bin(71), 3 7 2 generator char(8), 3 8 2 gen_version unaligned, 3 9 3 offset bit(18), 3 10 3 size bit(18), 3 11 2 userid unaligned, 3 12 3 offset bit(18), 3 13 3 size bit(18), 3 14 2 comment unaligned, 3 15 3 offset bit(18), 3 16 3 size bit(18), 3 17 2 text_boundary bit(18) unaligned, 3 18 2 stat_boundary bit(18) unaligned, 3 19 2 source_map bit(18) unaligned, 3 20 2 area_pointer bit(18) unaligned, 3 21 2 backpointer bit(18) unaligned, 3 22 2 block_size bit(18) unaligned, 3 23 2 next_block bit(18) unaligned, 3 24 2 rel_text bit(18) unaligned, 3 25 2 rel_def bit(18) unaligned, 3 26 2 rel_link bit(18) unaligned, 3 27 2 rel_symbol bit(18) unaligned, 3 28 2 mini_truncate bit(18) unaligned, 3 29 2 maxi_truncate bit(18) unaligned; 180 4 1 dcl 1 pl1_symbol_block aligned based, 4 2 2 version fixed bin, 4 3 2 identifier char(8), /* must be "pl1info" */ 4 4 2 flags, 4 5 3 profile bit(1) unal, 4 6 3 table bit(1) unal, 4 7 3 map bit(1) unal, 4 8 3 flow bit(1) unal, 4 9 3 io bit(1) unal, 4 10 3 table_removed bit(1) unal, 4 11 3 long_profile bit(1) unal, 4 12 3 pad bit(29) unal, 4 13 2 greatest_severity fixed bin, 4 14 2 root unal bit(18), 4 15 2 profile unal bit(18), 4 16 2 map unal, 4 17 3 first bit(18), 4 18 3 last bit(18), 4 19 2 segname unaligned, 4 20 3 offset bit(18), 4 21 3 size bit(18); 181 5 1 dcl 1 statement_map aligned based, 5 2 2 location bit(18) unaligned, 5 3 2 source_id unaligned, 5 4 3 file bit(8), 5 5 3 line bit(14), 5 6 3 statement bit(5), 5 7 2 source_info unaligned, 5 8 3 start bit(18), 5 9 3 length bit(9); 182 6 1 /* BEGIN INCLUDE FILE ... object_info.incl.pl1 6 2*coded February 8, 1972 by Michael J. Spier */ 6 3 /* modified May 26, 1972 by M. Weaver */ 6 4 /* modified 15 April, 1975 by M. Weaver */ 6 5 6 6 declare 1 object_info aligned based, /* structure containing object info based, returned by object_info_ */ 6 7 2 version_number fixed bin, /* version number of current structure format (=2) */ 6 8 2 textp pointer, /* pointer to beginning of text section */ 6 9 2 defp pointer, /* pointer to beginning of definition section */ 6 10 2 linkp pointer, /* pointer to beginning of linkage section */ 6 11 2 statp pointer, /* pointer to beginning of static section */ 6 12 2 symbp pointer, /* pointer to beginning of symbol section */ 6 13 2 bmapp pointer, /* pointer to beginning of break map (may be null) */ 6 14 2 tlng fixed bin, /* length in words of text section */ 6 15 2 dlng fixed bin, /* length in words of definition section */ 6 16 2 llng fixed bin, /* length in words of linkage section */ 6 17 2 ilng fixed bin, /* length in words of static section */ 6 18 2 slng fixed bin, /* length in words of symbol section */ 6 19 2 blng fixed bin, /* length in words of break map */ 6 20 2 format, /* word containing bit flags about object type */ 6 21 3 old_format bit(1) unaligned, /* on if segment isn't in new format, i.e. has old style object map */ 6 22 3 bound bit(1) unaligned, /* on if segment is bound */ 6 23 3 relocatable bit(1) unaligned, /* on if seg has relocation info in its first symbol block */ 6 24 3 procedure bit(1) unaligned, /* on if segment is an executable object program */ 6 25 3 standard bit(1) unaligned, /* on if seg is in standard format (more than just standard map) */ 6 26 3 gate bit(1) unaligned, /* on if segment is a gate */ 6 27 3 separate_static bit(1) unaligned, /* on if static not in linkage */ 6 28 3 links_in_text bit(1) unaligned, /* on if there are threaded links in text */ 6 29 3 perprocess_static bit (1) unaligned, /* on if static is not to be per run unit */ 6 30 3 pad bit(27) unaligned, 6 31 2 entry_bound fixed bin, /* entry bound if segment is a gate */ 6 32 2 textlinkp pointer, /* ptr to first link in text */ 6 33 6 34 /* LIMIT OF BRIEF STRUCTURE */ 6 35 6 36 2 compiler char(8) aligned, /* name of processor which generated segment */ 6 37 2 compile_time fixed bin(71), /* clock reading of date/time object was generated */ 6 38 2 userid char(32) aligned, /* standard Multics id of creator of object segment */ 6 39 2 cvers aligned, /* generator version name in printable char string form */ 6 40 3 offset bit(18) unaligned, /* offset of name in words relative to base of symbol section */ 6 41 3 length bit(18) unaligned, /* length of name in characters */ 6 42 2 comment aligned, /* printable comment concerning generator or generation of segment */ 6 43 3 offset bit(18) unaligned, /* offset of comment in words relative to base of symbol section */ 6 44 3 length bit(18) unaligned, /* length of comment in characters */ 6 45 2 source_map fixed bin, /* offset, relative to base of symbol section, of source map structure */ 6 46 6 47 /* LIMIT OF DISPLAY STRUCTURE */ 6 48 6 49 2 rel_text pointer, /* pointer to text section relocation info */ 6 50 2 rel_def pointer, /* pointer to definition section relocation info */ 6 51 2 rel_link pointer, /* pointer to linkage section relocation info */ 6 52 2 rel_static pointer, /* pointer to static section relocation info */ 6 53 2 rel_symbol pointer, /* pointer to symbol section relocation info */ 6 54 2 text_boundary fixed bin, /* specifies mod of text section base boundary */ 6 55 2 static_boundary fixed bin, /* specifies mod of internal static base boundary */ 6 56 /* currently not used by system */ 6 57 2 default_truncate fixed bin, /* offset rel to symbp for binder to automatically trunc. symb sect. */ 6 58 2 optional_truncate fixed bin; /* offset rel to symbp for binder to optionally trunc. symb sect. */ 6 59 6 60 declare object_info_version_2 fixed bin int static init(2); 6 61 6 62 /* END INCLUDE FILE ... object_info.incl.pl1 */ 183 184 185 end get_block; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/12/86 1607.5 get_block.pl1 >spec>install>1212>get_block.pl1 178 1 05/06/74 1752.6 stu_frame.incl.pl1 >ldd>include>stu_frame.incl.pl1 179 2 11/26/79 1320.6 runtime_symbol.incl.pl1 >ldd>include>runtime_symbol.incl.pl1 180 3 05/06/74 1751.6 std_symbol_header.incl.pl1 >ldd>include>std_symbol_header.incl.pl1 181 4 03/10/77 1345.4 pl1_symbol_block.incl.pl1 >ldd>include>pl1_symbol_block.incl.pl1 182 5 05/06/74 1751.6 statement_map.incl.pl1 >ldd>include>statement_map.incl.pl1 183 6 08/05/77 1022.5 object_info.incl.pl1 >ldd>include>object_info.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 47 ref 128 128 addrel builtin function dcl 47 ref 66 67 72 80 85 90 96 100 109 138 147 148 149 150 156 156 163 area_pointer 16(18) based bit(18) level 2 packed unaligned dcl 3-1 ref 148 based_word based bit(36) unaligned dcl 32 ref 67 67 79 86 86 86 91 91 91 91 97 97 101 101 101 101 bitcount 000107 automatic fixed bin(24,0) dcl 32 set ref 125* 128* block_offset 1(18) based bit(18) level 2 packed unaligned dcl 49 ref 138 block_pt parameter pointer dcl 28 set ref 26 61* 138* 140 147 147 148* 149* 149 150* 150 150 155 159* 166 brother 1(18) based bit(18) level 2 packed unaligned dcl 2-38 ref 162 code 000110 automatic fixed bin(35,0) dcl 32 set ref 125* 126 128* 129 entry 26 based pointer level 2 dcl 1-1 ref 66 85 first 3 based bit(18) level 3 packed unaligned dcl 2-38 ref 156 fixed builtin function dcl 47 ref 64 156 156 flag based bit(1) level 2 packed unaligned dcl 2-38 ref 140 frame based structure level 1 dcl 1-1 hcs_$status_mins 000010 constant entry external dcl 45 ref 125 head_offset 1 based bit(18) level 2 packed unaligned dcl 49 ref 115 header 4(18) based bit(18) level 2 packed unaligned dcl 2-38 ref 147 header_pt parameter pointer dcl 28 set ref 26 61* 130* 138 166 i 000105 automatic fixed bin(17,0) dcl 32 set ref 78* ic 000104 automatic fixed bin(17,0) dcl 32 set ref 58* 142 156 156 175* last 3(18) based bit(18) level 3 packed unaligned dcl 2-38 ref 156 loc parameter fixed bin(17,0) dcl 168 ref 166 175 location based bit(18) level 2 packed unaligned dcl 5-1 ref 156 156 map 3 based structure level 2 packed unaligned dcl 2-38 null builtin function dcl 47 ref 61 62 object_info based structure level 1 dcl 6-6 object_info_$brief 000012 constant entry external dcl 46 ref 128 object_info_version_2 constant fixed bin(17,0) initial dcl 6-60 ref 127 oi 000112 automatic structure level 1 dcl 43 set ref 128 128 p 000100 automatic pointer dcl 32 set ref 66* 67 67 67* 67 72* 72 79 80* 80 85* 86 86 86 90* 90 91 91 91 91 96* 96 97 97 100* 100 101 101 101 101 109* 109 115 125 125 128 128 138 147* 148 148 149 155* 156 156 156 156 159 160 162* 163* pl1_symbol_block based structure level 1 dcl 4-1 pointer builtin function dcl 47 ref 125 125 128 128 rel_to_next 000106 automatic bit(18) unaligned dcl 32 set ref 154* 155 160* 162* 163 root 5 based bit(18) level 2 packed unaligned dcl 4-1 ref 149 runtime_block based structure level 1 dcl 2-38 son 2(18) based bit(18) level 2 packed unaligned dcl 2-38 ref 150 160 sp 000102 automatic pointer dcl 32 set ref 60* 62 64 66 85 stack_pt parameter pointer dcl 28 ref 26 60 166 statement_map based structure level 1 dcl 5-1 std_symbol_header based structure level 1 dcl 3-1 structure based structure level 1 dcl 49 symbp 12 000112 automatic pointer level 2 dcl 43 set ref 130 trans 000111 automatic fixed bin(17,0) dcl 32 set ref 64* 65 71 84 translator_id 37 based bit(18) level 2 packed unaligned dcl 1-1 ref 64 version_number 000112 automatic fixed bin(17,0) level 2 dcl 43 set ref 127* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. based_ptr based pointer dcl 32 encoded_value based structure level 1 dcl 2-70 runtime_bound based structure level 1 unaligned dcl 2-33 runtime_symbol based structure level 1 dcl 2-3 runtime_token based structure level 1 dcl 2-63 NAMES DECLARED BY EXPLICIT CONTEXT. found_tra 000121 constant label dcl 83 ref 79 get_block 000030 constant entry external dcl 26 get_runtime_block 000377 constant entry external dcl 166 join 000037 constant label dcl 60 ref 176 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 466 502 410 476 Length 766 410 14 247 55 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME get_block 144 external procedure is an external procedure. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME get_block 000100 p get_block 000102 sp get_block 000104 ic get_block 000105 i get_block 000106 rel_to_next get_block 000107 bitcount get_block 000110 code get_block 000111 trans get_block 000112 oi get_block THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out return_mac ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. hcs_$status_mins object_info_$brief NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 26 000024 58 000035 60 000037 61 000043 62 000046 64 000052 65 000055 66 000057 67 000062 70 000074 71 000075 72 000077 78 000102 79 000107 80 000114 81 000116 82 000120 84 000121 85 000123 86 000126 90 000140 91 000142 96 000156 97 000160 100 000170 101 000172 109 000206 110 000210 111 000211 115 000212 125 000216 126 000236 127 000240 128 000242 129 000263 130 000265 138 000270 140 000277 142 000302 147 000305 148 000311 149 000316 150 000323 154 000327 155 000331 156 000334 159 000355 160 000357 161 000362 162 000363 163 000366 164 000371 166 000372 175 000404 176 000407 ----------------------------------------------------------- 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