COMPILATION LISTING OF SEGMENT checker_crossref_ Compiled by: Multics PL/I Compiler, Release 28d, of October 4, 1983 Compiled at: Honeywell Multics Op. - System M Compiled on: 06/01/84 1534.0 mst Fri Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* *********************************************************** */ 6 /* checker_crossref_ -- Program to look at all the links in an MST */ 7 /* and see if they can be resolved */ 8 /* format: style2 */ 9 /* Modified December 1983 by Keith Loepere for non-loaded collections; also 10* so that temp segs in one minor collection can reference segs in another 11* minor collection within the same major collection. */ 12 checker_crossref_: 13 procedure; 14 15 1 1 /* Begin include file checker_dcls_.incl.pl1 BIM 7/82 */ 1 2 /* Modified for loaded by Keith Loepere, December 1983 */ 1 3 /* format: style3,idind30 */ 1 4 1 5 dcl checker_data_$temp_ptrs (4) ptr external static; 1 6 dcl checker_data_$slt_ptr ptr external static; 1 7 dcl checker_data_$area_ptr ptr external static; 1 8 dcl checker_area area (sys_info$max_seg_size) based (checker_data_$area_ptr); 1 9 1 10 dcl checker_data_$name_table_ptr ptr external static; 1 11 dcl checker_data_$buffer_ptr ptr external static; 1 12 dcl checker_data_$meter_ptr ptr external static; 1 13 1 14 dcl checker_data_$input_iocbp ptr ext static; 1 15 dcl checker_data_$output_iocbp ptr ext static; 1 16 1 17 1 18 dcl checker_data_$last_wired_collection 1 19 fixed bin external static; 1 20 dcl checker_data_$last_text_wired_collection 1 21 fixed bin external static; 1 22 dcl checker_data_$last_supervisor_collection 1 23 fixed bin external static; 1 24 1 25 dcl 1 checker_data_$collection_names (0:10) external static, 1 26 2 major fixed bin, 1 27 2 minor fixed bin; 1 28 1 29 dcl checker_data_$loaded (0:10) external static bit (1) aligned; 1 30 1 31 dcl checker_data_$n_temp_ptrs fixed bin external static; 1 32 1 33 dcl checker_data_$severity fixed bin external static; 1 34 1 35 dcl 1 meters aligned based (checker_data_$meter_ptr), 1 36 2 sizes aligned, 1 37 3 wired_ai_linkage_size fixed bin, 1 38 3 paged_ai_linkage_size fixed bin, 1 39 3 wired_wi_linkage_size fixed bin, 1 40 3 paged_wi_linkage_size fixed bin, 1 41 3 wired_as_linkage_size fixed bin, 1 42 3 paged_as_linkage_size fixed bin, 1 43 3 wired_ws_linkage_size fixed bin, 1 44 3 paged_ws_linkage_size fixed bin, 1 45 3 wired_definitions_size fixed bin, 1 46 3 paged_definitions_size fixed bin, 1 47 2 wired_nt_size fixed bin, 1 48 2 paged_nt_size fixed bin, 1 49 2 overflown aligned, 1 50 3 (wired_ai_linkage, paged_ai_linkage, wired_wi_linkage, 1 51 paged_wi_linkage, wired_as_linkage, paged_as_linkage, 1 52 wired_ws_linkage, paged_ws_linkage, 1 53 wired_definitions, paged_definitions, 1 54 wired_nt, paged_nt, 1 55 wired_storage) bit (1) unaligned, 1 56 2 counts aligned, 1 57 3 wired_sdw_count fixed bin, 1 58 3 paged_sdw_count fixed bin, 1 59 3 wired_slte_count fixed bin, 1 60 3 paged_slte_count fixed bin, 1 61 2 wired_nt_used fixed bin, 1 62 2 paged_nt_used fixed bin, 1 63 2 used aligned, 1 64 3 wired_ai_linkage_used fixed bin, 1 65 3 paged_ai_linkage_used fixed bin, 1 66 3 wired_wi_linkage_used fixed bin, 1 67 3 paged_wi_linkage_used fixed bin, 1 68 3 wired_as_linkage_used fixed bin, 1 69 3 paged_as_linkage_used fixed bin, 1 70 3 wired_ws_linkage_used fixed bin, 1 71 3 paged_ws_linkage_used fixed bin, 1 72 3 wired_definitions_used fixed bin, 1 73 3 paged_definitions_used fixed bin, 1 74 2 per_collection (0:10) aligned, 1 75 3 read bit (1) aligned, 1 76 3 mark aligned, 1 77 4 major fixed bin, 1 78 4 minor fixed bin, 1 79 3 first_segment fixed bin (18), 1 80 3 last_segment fixed bin (18), 1 81 3 segment_count fixed bin (17), 1 82 3 words_used fixed bin (35), /* for wired */ 1 83 3 pages_used fixed bin (35), /* for paged */ 1 84 3 wired_pages_used fixed bin (35), /* for both! */ 1 85 3 perm_segment_count fixed bin, /* stay forever */ 1 86 3 temp_segment_count fixed bin, /* one collection */ 1 87 3 init_segment_count fixed bin, /* all of initialization */ 1 88 3 user_ring_segment_count fixed bin, 1 89 3 user_ring_segment_pages fixed bin, 1 90 3 ai_linkage_used fixed bin, 1 91 3 wi_linkage_used fixed bin, 1 92 3 as_linkage_used fixed bin, 1 93 3 ws_linkage_used fixed bin, 1 94 3 definitions_used fixed bin, 1 95 3 name_table_used fixed bin, 1 96 2 per_segment (0:1024) aligned, 1 97 3 collection fixed bin, 1 98 3 next fixed bin (18), 1 99 3 link_ptr pointer unaligned, 1 100 3 defs_ptr pointer unaligned; 1 101 1 102 declare segment_links_ptr pointer; 1 103 declare 1 segment_links aligned based (segment_links_ptr), 1 104 2 n_links fixed bin, 1 105 2 per_link (a_n_links refer (segment_links.n_links)) aligned, 1 106 3 expression_relps fixed bin (18) uns unal, 1 107 3 modifiers bit (6) unal; 1 108 1 109 /* rel pointers into def section stored in area */ 1 110 1 111 declare a_n_links fixed bin; 1 112 1 113 declare segment_defs_ptr pointer; 1 114 declare 1 segment_defs based (segment_defs_ptr) aligned, 1 115 2 length fixed bin, 1 116 2 definitions (a_defs_length refer (segment_defs.length)) bit (36) aligned; 1 117 1 118 declare a_defs_length fixed bin; 1 119 1 120 declare (CHECKER_WARNING init (1), /* */ 1 121 CHECKER_ERROR init (2), /* */ 1 122 CHECKER_SEVERE init (3), /* */ 1 123 CHECKER_FATAL init (4)) fixed bin int static options (constant); 1 124 1 125 declare ERROR_NAMES (1:4) char (16) init ("WARNING", "ERROR", "SEVERE ERROR", "FATAL ERROR") int static options (constant); 1 126 1 127 /* End include file checker_dcls_.incl.pl1 */ 16 17 2 1 /* BEGIN INCLUDE FILE slte.incl.pl1 */ 2 2 /* Declaration for Segment Loading Table Entry structure. 2 3* Used by Initialization, MST Generation, and MST Checker subroutines */ 2 4 /* modified 5/4/76 by Noel I. Morris */ 2 5 /* last modified 12/12/83 by Keith Loepere for breakpointable */ 2 6 /* format: style3 */ 2 7 2 8 dcl sltep ptr; 2 9 2 10 dcl 1 slte_uns based (sltep) aligned, 2 11 ( 2 names_ptr bit (18), /* rel pointer to thread of names */ 2 12 2 path_ptr bit (18), /* rel pointer to pathname (if present) */ 2 13 /**** End of word 1 */ 2 14 2 access bit (4), /* SDW access bit (REWP) */ 2 15 2 cache bit (1), /* Segment to be allowed in cache */ 2 16 2 abs_seg bit (1), /* segment is an abs seg if ON */ 2 17 2 firmware_seg bit (1), /* load in low 256 */ 2 18 2 layout_seg bit (1), /* mailbox & such */ 2 19 2 breakpointable bit (1), /* includes breakpoint_page */ 2 20 2 pad1 bit (3), /* unused */ 2 21 2 wired bit (1), /* segment is wired if ON */ 2 22 2 paged bit (1), /* segment is paged if ON */ 2 23 2 per_process bit (1), /* segment is per-process if ON */ 2 24 2 pad3 bit (2), 2 25 2 acl_provided bit (1), /* ON if acl structure follows path_name on MST */ 2 26 /**** End of 1st half of word 2 */ 2 27 2 pad4 bit (3), 2 28 2 branch_required bit (1), /* path name supplied if ON */ 2 29 2 init_seg bit (1), /* segment is init_seg if ON */ 2 30 2 temp_seg bit (1), /* segment is temp_seg if ON */ 2 31 2 link_provided bit (1), /* linkage segment provided if ON */ 2 32 2 link_sect bit (1), /* segment is linkage segment if ON */ 2 33 2 link_sect_wired bit (1), /* linkage segment is wired if ON */ 2 34 2 combine_link bit (1), /* linkage is combined if ON */ 2 35 2 pre_linked bit (1), /* lot entry has been made if ON */ 2 36 2 defs bit (1), /* segment is definitions segment if ON */ 2 37 /***** End of word 2 */ 2 38 2 pad5 bit (6), 2 39 2 cur_length fixed bin (9) uns, /* current length of segment (in 1024 word blocks) */ 2 40 2 ringbrack (3) fixed bin (3) uns, /* ringbrackets */ 2 41 2 segno fixed bin (18) uns, /* text/link segment number */ 2 42 /***** End of word 3 */ 2 43 2 pad7 bit (3), 2 44 2 max_length fixed bin (9) uns, /* maximum length for segment */ 2 45 2 bit_count fixed bin (24) uns 2 46 ) unaligned; /* bitcount of segment */ 2 47 2 48 dcl 1 slte based (sltep) aligned, 2 49 ( 2 names_ptr bit (18), /* rel pointer to thread of names */ 2 50 2 path_ptr bit (18), /* rel pointer to pathname (if present) */ 2 51 2 access bit (4), /* SDW access bit (REWP) */ 2 52 2 cache bit (1), /* Segment to be allowed in cache */ 2 53 2 abs_seg bit (1), /* segment is an abs seg if ON */ 2 54 2 firmware_seg bit (1), 2 55 2 layout_seg bit (1), 2 56 2 breakpointable bit (1), 2 57 2 pad2 bit (3), 2 58 2 wired bit (1), /* segment is wired if ON */ 2 59 2 paged bit (1), /* segment is paged if ON */ 2 60 2 per_process bit (1), /* segment is per-process if ON */ 2 61 2 pad3 bit (2), 2 62 2 acl_provided bit (1), /* ON if acl structure follows path_name on MST */ 2 63 2 pad4 bit (3), 2 64 2 branch_required bit (1), /* path name supplied if ON */ 2 65 2 init_seg bit (1), /* segment is init_seg if ON */ 2 66 2 temp_seg bit (1), /* segment is temp_seg if ON */ 2 67 2 link_provided bit (1), /* linkage segment provided if ON */ 2 68 2 link_sect bit (1), /* segment is linkage segment if ON */ 2 69 2 link_sect_wired bit (1), /* linkage segment is wired if ON */ 2 70 2 combine_link bit (1), /* linkage is combined if ON */ 2 71 2 pre_linked bit (1), /* lot entry has been made if ON */ 2 72 2 defs bit (1), /* segment is definitions segment if ON */ 2 73 2 pad5 bit (6), 2 74 2 cur_length bit (9), /* current length of segment (in 1024 word blocks) */ 2 75 2 ringbrack (3) bit (3), /* ringbrackets */ 2 76 2 segno bit (18), /* text/link segment number */ 2 77 2 pad6 bit (3), 2 78 2 max_length bit (9), /* maximum length for segment */ 2 79 2 bit_count bit (24) 2 80 ) unaligned; /* bitcount of segment */ 2 81 2 82 /* END INCLUDE FILE slte.incl.pl1 */ 18 3 1 /* BEGIN INCLUDE FILE slt.incl.pl1 --- Last modified 2/76 SHW */ 3 2 3 3 /* Declarations for Segment Loading Table header and array. 3 4* 3 5* Used by Initialization and MST Checker subroutines */ 3 6 3 7 dcl sltp ptr, /* pointer to base of SLT segment */ 3 8 names_ptr ptr, /* pointer to base of SLT names segment */ 3 9 namep ptr, /* pointer to segment name list block */ 3 10 pathp ptr, /* pointer to segment's directory path name */ 3 11 aclp ptr; /* pointer to acl structure */ 3 12 3 13 declare 1 slt based (sltp) aligned, /* declaration of Segment Loading Table (SLT) */ 3 14 2 name_seg_ptr ptr, /* words 0-1, pointer (ITS pair) to name segment */ 3 15 2 free_core_start fixed bin (24), /* word 2, start of free core after perm-wired */ 3 16 2 first_sup_seg fixed bin (18), /* word 3, first supervisor segment number */ 3 17 2 last_sup_seg fixed bin (18), /* word 4, last supervisor segment number */ 3 18 2 first_init_seg fixed bin (18), /* word 5, first initializer segment number */ 3 19 2 last_init_seg fixed bin (18), /* word 6, last initializer segment number */ 3 20 2 free_core_size fixed bin (24), /* size (in words) of free core after perm-wired */ 3 21 2 seg (0:8191) aligned, /* segment entries (4 words each) */ 3 22 3 slte (4) fixed bin (35); /* Space for SLT entries */ 3 23 3 24 /* auxiliary segment of SLT for storing of segment names and directory path names */ 3 25 3 26 declare 1 name_seg based (names_ptr) aligned, /* name segment header */ 3 27 2 pad bit (18) unal, 3 28 2 next_loc bit (18) unal, /* Next available free location in name seg */ 3 29 2 ht (0:127) bit (18) aligned; /* Names hash table */ 3 30 3 31 declare 1 segnam based (namep) aligned, /* declaration for segment name block */ 3 32 2 count fixed bin (17), /* number of segment names in this block */ 3 33 2 names (50 refer (segnam.count)), /* segment name array */ 3 34 3 hp bit (18) unal, /* hash thread pointer */ 3 35 3 ref bit (1) unal, /* "1"b if name referenced */ 3 36 3 pad bit (5) unal, 3 37 3 segno bit (12) unal, /* segment number associated with this name */ 3 38 3 name char (32) unal; /* space for name (max 32 characters) */ 3 39 3 40 declare 1 path based (pathp) aligned, /* declaration for directory path name */ 3 41 2 size fixed bin (17), /* length of pathname */ 3 42 2 name char (168 refer (path.size)) unal, /* directory path name */ 3 43 2 acls fixed bin; /* ACL list starts here */ 3 44 3 45 declare 1 acls based (aclp) aligned, /* declaration for acl list */ 3 46 2 count fixed bin, /* number of entries in acl list */ 3 47 2 acl (50 refer (acls.count)), /* array of acl entries */ 3 48 3 userid char (32), /* user specification */ 3 49 3 mode bit (36) aligned, /* mode for the specified user */ 3 50 3 pad bit (36) aligned, 3 51 3 code fixed bin; 3 52 3 53 3 54 /* END INCLUDE FILE slt.incl.pl1 */ 19 20 21 22 declare 1 list_head aligned based, 23 2 first ptr unaligned, 24 2 count fixed bin; 25 26 declare 1 segment_not_found_head 27 aligned like list_head; 28 declare 1 found_online_head aligned like list_head; 29 declare 1 entrypoint_not_found_head 30 aligned like list_head; 31 declare 1 special_link_head aligned like list_head; 32 33 declare ONLINE fixed bin init (-2) int static options (constant); 34 declare SEGMENT_NOT_FOUND fixed bin init (-1) int static options (constant); 35 declare ENTRYPOINT_NOT_FOUND fixed bin init (-4) int static options (constant); 36 declare SPECIAL_LINK fixed bin init (-3) int static options (constant); 37 declare SELF_LINK fixed bin init (-5) int static options (constant); 38 39 declare 1 IL_arg aligned, 40 2 segname char (32) aligned, 41 2 entryname char (33) aligned, 42 2 expression char (8) aligned, 43 2 modifier char (4) aligned, 44 2 trap char (32) aligned; 45 46 declare cep pointer; 47 declare cx fixed bin; 48 declare 1 chain_entry based (cep), 49 2 next ptr unal, 50 2 linker char (32) unal, 51 2 link char (256) unal; 52 53 54 declare checker_print_$error entry () options (variable); 55 declare checker_print_$error_term 56 entry () options (variable); 57 declare checker_print_ entry () options (variable); 58 declare checker_print_$page entry; 59 declare checker_print_$skip entry; 60 declare hcs_$make_ptr entry (ptr, char (*), char (*), ptr, fixed bin (35)); 61 declare ioa_ entry () options (variable); 62 declare interpret_link_$given_exp 63 entry (ptr, fixed bin (18), bit (6), ptr, fixed bin (35)); 64 declare hash_$opt_size entry (fixed bin) returns (fixed bin); 65 declare hash_$in entry (ptr, char (*), bit (36) aligned, fixed bin (35)); 66 declare hash_$make entry (ptr, fixed bin, fixed bin (35)); 67 declare hash_$search entry (ptr, char (*), bit (36) aligned, fixed bin (35)); 68 declare get_definition_ entry (ptr, char (*), char (*), ptr, fixed bin (35)); 69 declare get_temp_segment_ entry (char (*), ptr, fixed bin (35)); 70 declare release_temp_segment_ entry (char (*), ptr, fixed bin (35)); 71 72 declare error_table_$no_ext_sym 73 fixed bin (35) ext static; 74 declare error_table_$seg_not_found 75 fixed bin (35) ext static; 76 77 declare cleanup condition; 78 declare htp pointer; 79 declare (hbound, null, length, rtrim, char, substr, ptr, addr, unspec) 80 builtin; 81 declare ME init ("checker_crossref_") int static options (constant) char (32); 82 83 84 htp = null; 85 on cleanup 86 begin; 87 if htp ^= null () 88 then call release_temp_segment_ (ME, htp, (0)); 89 end; 90 91 call get_temp_segment_ (ME, htp, (0)); 92 call hash_$make (htp, hash_$opt_size (5000), (0));/* hash table to remember where we found (that we found) a given segname */ 93 94 segment_not_found_head.first, found_online_head.first, entrypoint_not_found_head.first, 95 special_link_head.first = null; 96 97 segment_not_found_head.count, found_online_head.count, entrypoint_not_found_head.count, 98 special_link_head.count = 0; 99 100 call checker_print_$page; 101 call checker_print_ ("Begin Crossreference:"); 102 call checker_print_$skip; 103 call ioa_ ("Begin Crossreference."); 104 105 sltp = checker_data_$slt_ptr; 106 names_ptr = checker_data_$name_table_ptr; 107 108 call FILL_HASH_TABLE; 109 110 do cx = 0 to hbound (meters.per_collection, 1) 111 while (meters.per_collection (cx).read & cx <= checker_data_$last_supervisor_collection); 112 if checker_data_$loaded (cx) then call COLLECTION (cx); 113 end; 114 115 call REPORT; 116 call ioa_ ("Done Crossreference."); 117 call release_temp_segment_ (ME, htp, (0)); 118 return; 119 120 121 COLLECTION: 122 procedure (collection); 123 declare collection fixed bin; 124 declare 1 PC aligned like meters.per_collection defined (meters.per_collection (collection)); 125 declare segment_number fixed bin (18); 126 127 call ioa_ ("Checking collection ^d.^d.", checker_data_$collection_names (collection).major, 128 checker_data_$collection_names (collection).minor); 129 130 do segment_number = PC.first_segment repeat meters.per_segment (segment_number).next 131 while (segment_number ^< 0); 132 if addr (slt.seg (segment_number)) -> slte_uns.ringbrack (1) = 0 133 & meters.per_segment (segment_number).link_ptr ^= null 134 then call LOOK_AT_LINKS (segment_number, (meters.per_segment (segment_number).link_ptr), 135 (meters.per_segment (segment_number).defs_ptr)); 136 end; 137 return; 138 end COLLECTION; 139 140 LOOK_AT_LINKS: 141 procedure (segment_number, links_ptr, defs_ptr); 142 declare segment_number fixed bin (18); 143 declare defs_ptr ptr; 144 declare links_ptr pointer; 145 declare exp_relp fixed bin (18); 146 declare modifier bit (6); 147 declare segment_name char (32); 148 declare lx fixed bin; 149 declare def_section_ptr ptr; 150 151 def_section_ptr = addr (defs_ptr -> segment_defs.definitions); 152 segment_name = NAME (segment_number); 153 segment_links_ptr = links_ptr; 154 155 do lx = 1 to segment_links.n_links; 156 exp_relp = segment_links.expression_relps (lx); 157 modifier = segment_links.modifiers (lx); 158 159 call PROCESS_LINK (segment_number, segment_name, def_section_ptr, exp_relp, modifier); 160 end; 161 end LOOK_AT_LINKS; 162 163 PROCESS_LINK: 164 procedure (segment_number, segment_name, defs_ptr, exp_relp, modifier); 165 declare segment_number fixed bin (18); 166 declare segment_name char (32); 167 declare defs_ptr pointer; 168 declare exp_relp fixed bin (18); 169 declare modifier bit (6); 170 declare link_entrypoint char (32); 171 declare found_in_segno fixed bin; 172 declare 1 (linking_slte, linked_slte) 173 aligned like slte_uns; 174 declare link_printed_rep char (256); 175 176 177 /* Get the name that this references */ 178 179 call interpret_link_$given_exp (addr (IL_arg), exp_relp, modifier, defs_ptr, (0)); 180 181 sltep = addr (slt.seg (segment_number)); 182 linking_slte = slte_uns; 183 184 /* Look for the definitions */ 185 186 if substr (IL_arg.entryname, 1, 1) = "|" 187 then link_entrypoint = ""; 188 else link_entrypoint = substr (IL_arg.entryname, 2); 189 found_in_segno = SEARCH (IL_arg.segname, link_entrypoint, linking_slte.ringbrack (2) > 0); 190 link_printed_rep = LINK_REP (); /* IL_arg is global */ 191 if found_in_segno ^< 0 192 then do; /* hardcore segment */ 193 194 sltep = addr (slt.seg (found_in_segno)); 195 linked_slte = slte_uns; 196 197 if linking_slte.temp_seg 198 & checker_data_$collection_names (meters.per_segment (found_in_segno).collection).major 199 > checker_data_$collection_names (meters.per_segment (segment_number).collection).major 200 then call checker_print_$error (CHECKER_ERROR, (0), "crossref", 201 "Temp seg ^a link ^a: target is in a later collection.", segment_name, link_printed_rep); 202 203 else if linking_slte.temp_seg & linked_slte.temp_seg 204 & checker_data_$collection_names (meters.per_segment (found_in_segno).collection).major 205 ^= checker_data_$collection_names (meters.per_segment (segment_number).collection).major 206 then call checker_print_$error (CHECKER_ERROR, (0), "crossref", 207 "Temp seg ^a link ^a: target is temp segment in a different collection.", segment_name, 208 link_printed_rep); 209 210 else if linked_slte.temp_seg 211 & checker_data_$collection_names (meters.per_segment (found_in_segno).collection).major 212 < checker_data_$collection_names (meters.per_segment (segment_number).collection).major 213 then call checker_print_$error (CHECKER_ERROR, (0), "crossref", 214 "Seg ^a link ^a links to earlier temp seg.", segment_name, link_printed_rep); 215 216 /* Check for ring order here */ 217 end; 218 219 else if found_in_segno = ONLINE 220 then call ADD_TO_CHAIN (segment_name, link_printed_rep, found_online_head); 221 else if found_in_segno = SEGMENT_NOT_FOUND 222 then call ADD_TO_CHAIN (segment_name, link_printed_rep, segment_not_found_head); 223 else if found_in_segno = ENTRYPOINT_NOT_FOUND 224 then call ADD_TO_CHAIN (segment_name, link_printed_rep, entrypoint_not_found_head); 225 else if found_in_segno = SPECIAL_LINK 226 then call ADD_TO_CHAIN (segment_name, link_printed_rep, special_link_head); 227 /* other case is SELF, which is okay */ 228 229 end PROCESS_LINK; 230 231 232 SEARCH: 233 procedure (segname, entrypoint, runs_in_user_ring) returns (fixed bin); 234 declare segname char (*) aligned; 235 declare entrypoint char (*); /* "" for numeric based links */ 236 declare segno_in_word bit (36) aligned; 237 declare segno fixed bin (35); 238 declare runs_in_user_ring bit (1) aligned; 239 declare code fixed bin (35); 240 declare (cx, sx) fixed bin (18); 241 declare s_ptr pointer; 242 declare segname_u char (32); 243 declare def_section_ptr pointer; 244 declare searched_hardcore bit (1) aligned; 245 246 searched_hardcore = "0"b; 247 segname_u = segname; 248 if segname_u = "*symbol" | segname_u = "*system" | segname_u = "*defs" 249 then return (SPECIAL_LINK); 250 else if char (segname_u, 1) = "*" 251 then return (SELF_LINK); 252 call hash_$search (htp, segname_u, segno_in_word, code); 253 if code = 0 254 then do; 255 unspec (segno) = segno_in_word; 256 go to HAVE_SEGNO; 257 end; 258 259 /* Try online */ 260 261 SEARCH_ONLINE: 262 call hcs_$make_ptr (null (), segname_u, entrypoint, s_ptr, code); 263 if s_ptr ^= null 264 then return (ONLINE); 265 else do; 266 if code = error_table_$no_ext_sym | searched_hardcore 267 /* return original error */ 268 then return (ENTRYPOINT_NOT_FOUND); 269 else return (SEGMENT_NOT_FOUND); 270 end; 271 272 HAVE_SEGNO: 273 if entrypoint = "" 274 then return (segno); /* easy enough */ 275 276 sx = segno; 277 if meters.per_segment (sx).defs_ptr = null 278 then go to NO_ENTRYPOINT; 279 280 def_section_ptr = addr (meters.per_segment (sx).defs_ptr -> segment_defs.definitions); 281 282 call get_definition_ (def_section_ptr, segname_u, entrypoint, (null), code); 283 if code ^= 0 284 then 285 NO_ENTRYPOINT: 286 do; 287 if ^runs_in_user_ring | searched_hardcore 288 then return (ENTRYPOINT_NOT_FOUND); 289 else do; 290 searched_hardcore = "1"b; 291 go to SEARCH_ONLINE; 292 end; 293 end; 294 return (segno); 295 end SEARCH; 296 297 298 NAME: 299 procedure (s) returns (char (32)) reducible; 300 declare s fixed bin (18); 301 return (ptr (checker_data_$name_table_ptr, addr (slt.seg (s)) -> slte_uns.names_ptr) -> segnam.names (1).name); 302 end NAME; 303 304 LINK_REP: 305 procedure returns (char (256)); 306 307 declare arep char (256); 308 309 arep = rtrim (IL_arg.segname) || rtrim (IL_arg.entryname) || rtrim (IL_arg.expression) 310 || rtrim (IL_arg.modifier) || " " || IL_arg.trap; 311 return (arep); 312 end LINK_REP; 313 314 ADD_TO_CHAIN: 315 procedure (sn, lrep, head); 316 declare sn char (*); /* segment name making the link */ 317 declare lrep char (256); /* the link offending */ 318 declare 1 head aligned like list_head; 319 /* the chain */ 320 declare new_cep ptr; 321 declare prev_cep ptr; 322 323 allocate chain_entry in (checker_area) set (new_cep); 324 new_cep -> chain_entry.linker = sn; 325 new_cep -> chain_entry.link = lrep; 326 new_cep -> chain_entry.next = null; 327 328 head.count = head.count + 1; 329 if head.first = null 330 then do; 331 head.first = new_cep; 332 return; 333 end; 334 335 prev_cep = null; 336 do cep = head.first repeat chain_entry.next while (cep ^= null); 337 if sn < chain_entry.linker 338 then 339 INSERT: 340 do; /* insert here */ 341 new_cep -> chain_entry.next = cep; 342 if prev_cep = null /* to beginning */ 343 then head.first = new_cep; 344 else prev_cep -> chain_entry.next = new_cep; 345 return; 346 end; 347 else if sn = chain_entry.linker 348 then do; /* look for multiples on this segname */ 349 do cep = cep repeat chain_entry.next while (cep ^= null); 350 if lrep < chain_entry.link 351 then go to INSERT; 352 if sn ^= chain_entry.linker 353 then go to INSERT; /* last on this segname */ 354 prev_cep = cep; 355 end; 356 go to OFF_END; 357 end; 358 prev_cep = cep; 359 end; 360 361 362 OFF_END: /* prev_cep -> last one */ 363 prev_cep -> chain_entry.next = new_cep; 364 end ADD_TO_CHAIN; 365 366 367 REPORT: 368 procedure; 369 370 if entrypoint_not_found_head.count > 0 371 then do; 372 call THROW; 373 call checker_print_$error (CHECKER_SEVERE, (0), "crossref", 374 "Links exist to entrypoints not defined."); 375 call checker_print_$skip; 376 377 call PRINT_CHAIN (entrypoint_not_found_head.first, CHECKER_ERROR, error_table_$no_ext_sym); 378 end; 379 380 if segment_not_found_head.count > 0 381 then do; 382 call THROW; 383 call checker_print_$error (CHECKER_SEVERE, (0), "crossref", "Links exist to segments not found."); 384 call checker_print_$skip; 385 386 call PRINT_CHAIN (segment_not_found_head.first, CHECKER_ERROR, error_table_$seg_not_found); 387 end; 388 389 if found_online_head.count > 0 390 then do; 391 call THROW; 392 call checker_print_$error (CHECKER_WARNING, (0), "crossref", 393 "Links exist to segments found only online."); 394 call checker_print_$skip; 395 396 call PRINT_CHAIN (found_online_head.first, 0, 0); 397 end; 398 399 if special_link_head.count > 0 400 then do; 401 call THROW; 402 call checker_print_$error (CHECKER_WARNING, (0), "crossref", 403 "Links exist to special ""*"" segnames."); 404 call checker_print_$skip; 405 406 call PRINT_CHAIN (special_link_head.first, 0, 0); 407 end; 408 return; 409 410 THROW: 411 procedure; 412 call checker_print_$page; 413 call checker_print_$skip; 414 end THROW; 415 416 PRINT_CHAIN: 417 procedure (first_cep, severity, code); 418 declare first_cep ptr unal; 419 declare last_s char (32); 420 declare severity fixed bin; 421 declare code fixed bin (35); 422 declare line char (136); 423 declare column fixed bin; 424 425 line = ""; 426 column = 1; 427 last_s = ""; 428 do cep = first_cep repeat chain_entry.next while (cep ^= null); 429 if chain_entry.linker ^= last_s 430 then do; 431 if column > 1 432 then call checker_print_ ("^a", line); 433 /* leftovers */ 434 call checker_print_$skip; 435 call checker_print_ ("^a", chain_entry.linker); 436 line = ""; 437 column = 1; 438 end; 439 440 last_s = chain_entry.linker; 441 if length (rtrim (chain_entry.link)) <= length (line) - column + 1 442 then begin; 443 declare next char (length (rtrim (chain_entry.link)) + 1) 444 defined (line) position (column); 445 next = chain_entry.link; 446 column = column + length (next); 447 end; 448 else do; 449 call checker_print_ ("^a", line); 450 column = length (rtrim (chain_entry.link)) + 2; 451 line = chain_entry.link; 452 end; 453 if severity > 0 454 then call checker_print_$error_term (severity, code, "", "^a links to ^a.", chain_entry.linker, 455 chain_entry.link); 456 457 458 end; 459 if column > 1 460 then call checker_print_ ("^a", line); /* leftovers */ 461 end PRINT_CHAIN; 462 end REPORT; 463 464 FILL_HASH_TABLE: 465 procedure; 466 declare sx fixed bin (18); 467 declare nx fixed bin; 468 do sx = slt.first_sup_seg to slt.last_sup_seg, slt.first_init_seg to slt.last_init_seg; 469 namep = ptr (checker_data_$name_table_ptr, addr (slt.seg (sx)) -> slte_uns.names_ptr); 470 do nx = 1 to segnam.count; 471 call hash_$in (htp, segnam.names (nx).name, unspec (sx), (0)); 472 end; 473 end; 474 end FILL_HASH_TABLE; 475 476 end checker_crossref_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 06/01/84 1426.8 checker_crossref_.pl1 >special_ldd>temp>bce>06/01/84>checker_crossref_.pl1 16 1 06/01/84 1103.1 checker_dcls_.incl.pl1 >special_ldd>temp>bce>06/01/84>checker_dcls_.incl.pl1 18 2 06/01/84 1103.2 slte.incl.pl1 >special_ldd>temp>bce>06/01/84>slte.incl.pl1 19 3 05/24/82 1005.0 slt.incl.pl1 >ldd>include>slt.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. CHECKER_ERROR 000047 constant fixed bin(17,0) initial dcl 1-120 set ref 197* 203* 210* 377* 386* CHECKER_SEVERE 000045 constant fixed bin(17,0) initial dcl 1-120 set ref 373* 383* CHECKER_WARNING 000046 constant fixed bin(17,0) initial dcl 1-120 set ref 392* 402* ENTRYPOINT_NOT_FOUND 003235 constant fixed bin(17,0) initial dcl 35 ref 223 266 287 IL_arg 000122 automatic structure level 1 dcl 39 set ref 179 179 ME 000000 constant char(32) initial unaligned dcl 81 set ref 87* 91* 117* ONLINE 003237 constant fixed bin(17,0) initial dcl 33 ref 219 263 PC defined structure level 1 dcl 124 SEGMENT_NOT_FOUND 003236 constant fixed bin(17,0) initial dcl 34 ref 221 269 SELF_LINK constant fixed bin(17,0) initial dcl 37 ref 250 SPECIAL_LINK 003234 constant fixed bin(17,0) initial dcl 36 ref 225 248 addr builtin function dcl 79 ref 132 151 179 179 181 194 280 301 469 arep 000424 automatic char(256) unaligned dcl 307 set ref 309* 311 cep 000156 automatic pointer dcl 46 set ref 336* 336* 337 341 347 349* 349 349* 350 352 354* 355 358* 359 428* 428* 429 435 440 441 443 445 450 451 453 453* 458 chain_entry based structure level 1 packed unaligned dcl 48 set ref 323 char builtin function dcl 79 ref 250 checker_area based area dcl 1-8 ref 323 checker_data_$area_ptr 000012 external static pointer dcl 1-7 ref 323 checker_data_$collection_names 000022 external static structure array level 1 unaligned dcl 1-25 checker_data_$last_supervisor_collection 000020 external static fixed bin(17,0) dcl 1-22 ref 110 checker_data_$loaded 000024 external static bit(1) array dcl 1-29 ref 112 checker_data_$meter_ptr 000016 external static pointer dcl 1-12 ref 110 110 130 132 132 132 136 197 197 203 203 210 210 277 280 checker_data_$name_table_ptr 000014 external static pointer dcl 1-10 ref 106 301 469 checker_data_$slt_ptr 000010 external static pointer dcl 1-6 ref 105 checker_print_ 000032 constant entry external dcl 57 ref 101 431 435 449 459 checker_print_$error 000026 constant entry external dcl 54 ref 197 203 210 373 383 392 402 checker_print_$error_term 000030 constant entry external dcl 55 ref 453 checker_print_$page 000034 constant entry external dcl 58 ref 100 412 checker_print_$skip 000036 constant entry external dcl 59 ref 102 375 384 394 404 413 434 cleanup 000162 stack reference condition dcl 77 ref 85 code parameter fixed bin(35,0) dcl 421 in procedure "PRINT_CHAIN" set ref 416 453* code 000370 automatic fixed bin(35,0) dcl 239 in procedure "SEARCH" set ref 252* 253 261* 266 282* 283 collection 371 based fixed bin(17,0) array level 3 in structure "meters" dcl 1-35 in procedure "checker_crossref_" ref 197 197 203 203 210 210 collection parameter fixed bin(17,0) dcl 123 in procedure "COLLECTION" ref 121 127 127 130 column 000632 automatic fixed bin(17,0) dcl 423 set ref 426* 431 437* 441 445 446* 446 446 450* 459 count 1 000114 automatic fixed bin(17,0) level 2 in structure "found_online_head" dcl 28 in procedure "checker_crossref_" set ref 97* 389 count 1 parameter fixed bin(17,0) level 2 in structure "head" dcl 318 in procedure "ADD_TO_CHAIN" set ref 328* 328 count 1 000116 automatic fixed bin(17,0) level 2 in structure "entrypoint_not_found_head" dcl 29 in procedure "checker_crossref_" set ref 97* 370 count 1 000112 automatic fixed bin(17,0) level 2 in structure "segment_not_found_head" dcl 26 in procedure "checker_crossref_" set ref 97* 380 count 1 000120 automatic fixed bin(17,0) level 2 in structure "special_link_head" dcl 31 in procedure "checker_crossref_" set ref 97* 399 count based fixed bin(17,0) level 2 in structure "segnam" dcl 3-31 in procedure "checker_crossref_" ref 470 cx 000160 automatic fixed bin(17,0) dcl 47 set ref 110* 110 110* 112 112* def_section_ptr 000224 automatic pointer dcl 149 in procedure "LOOK_AT_LINKS" set ref 151* 159* def_section_ptr 000404 automatic pointer dcl 243 in procedure "SEARCH" set ref 280* 282* definitions 1 based bit(36) array level 2 dcl 1-114 set ref 151 280 defs_ptr 374 based pointer array level 3 in structure "meters" packed unaligned dcl 1-35 in procedure "checker_crossref_" ref 132 277 280 defs_ptr parameter pointer dcl 167 in procedure "PROCESS_LINK" set ref 163 179* defs_ptr parameter pointer dcl 143 in procedure "LOOK_AT_LINKS" ref 140 151 entryname 10 000122 automatic char(33) level 2 dcl 39 set ref 186 188 309 entrypoint parameter char unaligned dcl 235 set ref 232 261* 272 282* entrypoint_not_found_head 000116 automatic structure level 1 dcl 29 set ref 223* error_table_$no_ext_sym 000064 external static fixed bin(35,0) dcl 72 set ref 266 377* error_table_$seg_not_found 000066 external static fixed bin(35,0) dcl 74 set ref 386* exp_relp parameter fixed bin(18,0) dcl 168 in procedure "PROCESS_LINK" set ref 163 179* exp_relp 000210 automatic fixed bin(18,0) dcl 145 in procedure "LOOK_AT_LINKS" set ref 156* 159* expression 21 000122 automatic char(8) level 2 dcl 39 set ref 309 expression_relps 1 based fixed bin(18,0) array level 3 packed unsigned unaligned dcl 1-103 ref 156 first parameter pointer level 2 in structure "head" packed unaligned dcl 318 in procedure "ADD_TO_CHAIN" set ref 329 331* 336 342* first 000116 automatic pointer level 2 in structure "entrypoint_not_found_head" packed unaligned dcl 29 in procedure "checker_crossref_" set ref 94* 377* first 000120 automatic pointer level 2 in structure "special_link_head" packed unaligned dcl 31 in procedure "checker_crossref_" set ref 94* 406* first 000112 automatic pointer level 2 in structure "segment_not_found_head" packed unaligned dcl 26 in procedure "checker_crossref_" set ref 94* 386* first 000114 automatic pointer level 2 in structure "found_online_head" packed unaligned dcl 28 in procedure "checker_crossref_" set ref 94* 396* first_cep parameter pointer unaligned dcl 418 ref 416 428 first_init_seg 5 based fixed bin(18,0) level 2 dcl 3-13 ref 468 first_segment 3 defined fixed bin(18,0) level 2 dcl 124 ref 130 first_sup_seg 3 based fixed bin(18,0) level 2 dcl 3-13 ref 468 found_in_segno 000246 automatic fixed bin(17,0) dcl 171 set ref 189* 191 194 197 203 210 219 221 223 225 found_online_head 000114 automatic structure level 1 dcl 28 set ref 219* get_definition_ 000056 constant entry external dcl 68 ref 282 get_temp_segment_ 000060 constant entry external dcl 69 ref 91 hash_$in 000050 constant entry external dcl 65 ref 471 hash_$make 000052 constant entry external dcl 66 ref 92 hash_$opt_size 000046 constant entry external dcl 64 ref 92 92 hash_$search 000054 constant entry external dcl 67 ref 252 hbound builtin function dcl 79 ref 110 hcs_$make_ptr 000040 constant entry external dcl 60 ref 261 head parameter structure level 1 dcl 318 set ref 314 htp 000170 automatic pointer dcl 78 set ref 84* 87 87* 91* 92* 117* 252* 471* interpret_link_$given_exp 000044 constant entry external dcl 62 ref 179 ioa_ 000042 constant entry external dcl 61 ref 103 116 127 last_init_seg 6 based fixed bin(18,0) level 2 dcl 3-13 ref 468 last_s 000560 automatic char(32) unaligned dcl 419 set ref 427* 429 440* last_sup_seg 4 based fixed bin(18,0) level 2 dcl 3-13 ref 468 length builtin function dcl 79 ref 441 441 443 446 450 line 000570 automatic char(136) unaligned dcl 422 set ref 425* 431* 436* 441 445* 445 446 446 449* 451* 459* link 11 based char(256) level 2 packed unaligned dcl 48 set ref 325* 350 441 443 445 450 451 453* link_entrypoint 000236 automatic char(32) unaligned dcl 170 set ref 186* 188* 189* link_printed_rep 000257 automatic char(256) unaligned dcl 174 set ref 190* 197* 203* 210* 219* 221* 223* 225* link_ptr 373 based pointer array level 3 packed unaligned dcl 1-35 ref 132 132 linked_slte 000253 automatic structure level 1 dcl 172 set ref 195* linker 1 based char(32) level 2 packed unaligned dcl 48 set ref 324* 337 347 352 429 435* 440 453* linking_slte 000247 automatic structure level 1 dcl 172 set ref 182* links_ptr parameter pointer dcl 144 ref 140 153 list_head based structure level 1 dcl 22 lrep parameter char(256) unaligned dcl 317 ref 314 325 350 lx 000222 automatic fixed bin(17,0) dcl 148 set ref 155* 156 157* major 000022 external static fixed bin(17,0) array level 2 dcl 1-25 set ref 127* 197 197 203 203 210 210 meters based structure level 1 dcl 1-35 minor 1 000022 external static fixed bin(17,0) array level 2 dcl 1-25 set ref 127* modifier 23 000122 automatic char(4) level 2 in structure "IL_arg" dcl 39 in procedure "checker_crossref_" set ref 309 modifier parameter bit(6) unaligned dcl 169 in procedure "PROCESS_LINK" set ref 163 179* modifier 000211 automatic bit(6) unaligned dcl 146 in procedure "LOOK_AT_LINKS" set ref 157* 159* modifiers 1(18) based bit(6) array level 3 packed unaligned dcl 1-103 ref 157 n_links based fixed bin(17,0) level 2 dcl 1-103 ref 155 name 2 based char(32) array level 3 packed unaligned dcl 3-31 set ref 301 471* namep 000110 automatic pointer dcl 3-7 set ref 469* 470 471 names 1 based structure array level 2 dcl 3-31 names_ptr 000106 automatic pointer dcl 3-7 in procedure "checker_crossref_" set ref 106* names_ptr based bit(18) level 2 in structure "slte_uns" packed unaligned dcl 2-10 in procedure "checker_crossref_" ref 301 469 new_cep 000532 automatic pointer dcl 320 set ref 323* 324 325 326 331 341 342 344 362 next based pointer level 2 in structure "chain_entry" packed unaligned dcl 48 in procedure "checker_crossref_" set ref 326* 341* 344* 355 359 362* 458 next 372 based fixed bin(18,0) array level 3 in structure "meters" dcl 1-35 in procedure "checker_crossref_" ref 136 next defined char unaligned dcl 443 in begin block on line 441 set ref 445* 446 null builtin function dcl 79 ref 84 87 94 132 261 261 263 277 282 326 329 335 336 342 349 428 nx 000643 automatic fixed bin(17,0) dcl 467 set ref 470* 471* per_collection 35 based structure array level 2 dcl 1-35 ref 110 130 130 per_link 1 based structure array level 2 dcl 1-103 per_segment 371 based structure array level 2 dcl 1-35 prev_cep 000534 automatic pointer dcl 321 set ref 335* 342 344 354* 358* 362 ptr builtin function dcl 79 ref 301 469 read 35 based bit(1) array level 3 dcl 1-35 ref 110 release_temp_segment_ 000062 constant entry external dcl 70 ref 87 117 ringbrack 2(09) 000247 automatic fixed bin(3,0) array level 2 in structure "linking_slte" packed unsigned unaligned dcl 172 in procedure "PROCESS_LINK" set ref 189 ringbrack 2(09) based fixed bin(3,0) array level 2 in structure "slte_uns" packed unsigned unaligned dcl 2-10 in procedure "checker_crossref_" ref 132 rtrim builtin function dcl 79 ref 309 309 309 309 441 443 450 runs_in_user_ring parameter bit(1) dcl 238 ref 232 287 s parameter fixed bin(18,0) dcl 300 ref 298 301 s_ptr 000372 automatic pointer dcl 241 set ref 261* 263 searched_hardcore 000406 automatic bit(1) dcl 244 set ref 246* 266 287 290* seg 10 based structure array level 2 dcl 3-13 set ref 132 181 194 301 469 segment_defs based structure level 1 dcl 1-114 segment_links based structure level 1 dcl 1-103 segment_links_ptr 000100 automatic pointer dcl 1-102 set ref 153* 155 156 157 segment_name 000212 automatic char(32) unaligned dcl 147 in procedure "LOOK_AT_LINKS" set ref 152* 159* segment_name parameter char(32) unaligned dcl 166 in procedure "PROCESS_LINK" set ref 163 197* 203* 210* 219* 221* 223* 225* segment_not_found_head 000112 automatic structure level 1 dcl 26 set ref 221* segment_number parameter fixed bin(18,0) dcl 165 in procedure "PROCESS_LINK" ref 163 181 197 203 210 segment_number parameter fixed bin(18,0) dcl 142 in procedure "LOOK_AT_LINKS" set ref 140 152* 159* segment_number 000200 automatic fixed bin(18,0) dcl 125 in procedure "COLLECTION" set ref 130* 130* 132 132 132* 132 132* 136 segnam based structure level 1 dcl 3-31 segname parameter char dcl 234 in procedure "SEARCH" ref 232 247 segname 000122 automatic char(32) level 2 in structure "IL_arg" dcl 39 in procedure "checker_crossref_" set ref 189* 309 segname_u 000374 automatic char(32) unaligned dcl 242 set ref 247* 248 248 248 250 252* 261* 282* segno 000367 automatic fixed bin(35,0) dcl 237 set ref 255* 272 276 294 segno_in_word 000366 automatic bit(36) dcl 236 set ref 252* 255 severity parameter fixed bin(17,0) dcl 420 set ref 416 453 453* slt based structure level 1 dcl 3-13 slte_uns based structure level 1 dcl 2-10 ref 182 195 sltep 000102 automatic pointer dcl 2-8 set ref 181* 182 194* 195 sltp 000104 automatic pointer dcl 3-7 set ref 105* 132 181 194 301 468 468 468 468 469 sn parameter char unaligned dcl 316 ref 314 324 337 347 352 special_link_head 000120 automatic structure level 1 dcl 31 set ref 225* substr builtin function dcl 79 ref 186 188 sx 000371 automatic fixed bin(18,0) dcl 240 in procedure "SEARCH" set ref 276* 277 280 sx 000642 automatic fixed bin(18,0) dcl 466 in procedure "FILL_HASH_TABLE" set ref 468* 469 471 471* temp_seg 1(23) 000253 automatic bit(1) level 2 in structure "linked_slte" packed unaligned dcl 172 in procedure "PROCESS_LINK" set ref 203 210 temp_seg 1(23) 000247 automatic bit(1) level 2 in structure "linking_slte" packed unaligned dcl 172 in procedure "PROCESS_LINK" set ref 197 203 trap 24 000122 automatic char(32) level 2 dcl 39 set ref 309 unspec builtin function dcl 79 set ref 255* 471 471 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. CHECKER_FATAL internal static fixed bin(17,0) initial dcl 1-120 ERROR_NAMES internal static char(16) initial array unaligned dcl 1-125 a_defs_length automatic fixed bin(17,0) dcl 1-118 a_n_links automatic fixed bin(17,0) dcl 1-111 aclp automatic pointer dcl 3-7 acls based structure level 1 dcl 3-45 checker_data_$buffer_ptr external static pointer dcl 1-11 checker_data_$input_iocbp external static pointer dcl 1-14 checker_data_$last_text_wired_collection external static fixed bin(17,0) dcl 1-20 checker_data_$last_wired_collection external static fixed bin(17,0) dcl 1-18 checker_data_$n_temp_ptrs external static fixed bin(17,0) dcl 1-31 checker_data_$output_iocbp external static pointer dcl 1-15 checker_data_$severity external static fixed bin(17,0) dcl 1-33 checker_data_$temp_ptrs external static pointer array dcl 1-5 cx automatic fixed bin(18,0) dcl 240 name_seg based structure level 1 dcl 3-26 path based structure level 1 dcl 3-40 pathp automatic pointer dcl 3-7 segment_defs_ptr automatic pointer dcl 1-113 slte based structure level 1 dcl 2-48 NAMES DECLARED BY EXPLICIT CONTEXT. ADD_TO_CHAIN 002047 constant entry internal dcl 314 ref 219 221 223 225 COLLECTION 000546 constant entry internal dcl 121 ref 112 FILL_HASH_TABLE 003032 constant entry internal dcl 464 ref 108 HAVE_SEGNO 001560 constant label dcl 272 ref 256 INSERT 002134 constant label dcl 337 ref 350 352 LINK_REP 001705 constant entry internal dcl 304 ref 190 LOOK_AT_LINKS 000646 constant entry internal dcl 140 ref 132 NAME 001664 constant entry internal dcl 298 ref 152 NO_ENTRYPOINT 001644 constant label dcl 283 ref 277 OFF_END 002222 constant label dcl 362 ref 356 PRINT_CHAIN 002521 constant entry internal dcl 416 ref 377 386 396 406 PROCESS_LINK 000731 constant entry internal dcl 163 ref 159 REPORT 002231 constant entry internal dcl 367 ref 115 SEARCH 001371 constant entry internal dcl 232 ref 189 SEARCH_ONLINE 001476 constant label dcl 261 ref 291 THROW 002505 constant entry internal dcl 410 ref 372 382 391 401 checker_crossref_ 000246 constant entry external dcl 12 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3542 3632 3241 3552 Length 4144 3241 70 275 301 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME checker_crossref_ 746 external procedure is an external procedure. on unit on line 85 80 on unit COLLECTION internal procedure shares stack frame of external procedure checker_crossref_. LOOK_AT_LINKS internal procedure shares stack frame of external procedure checker_crossref_. PROCESS_LINK internal procedure shares stack frame of external procedure checker_crossref_. SEARCH internal procedure shares stack frame of external procedure checker_crossref_. NAME internal procedure shares stack frame of external procedure checker_crossref_. LINK_REP internal procedure shares stack frame of external procedure checker_crossref_. ADD_TO_CHAIN internal procedure shares stack frame of external procedure checker_crossref_. REPORT internal procedure shares stack frame of external procedure checker_crossref_. THROW internal procedure shares stack frame of external procedure checker_crossref_. PRINT_CHAIN internal procedure shares stack frame of external procedure checker_crossref_. begin block on line 441 begin block shares stack frame of external procedure checker_crossref_. FILL_HASH_TABLE internal procedure shares stack frame of external procedure checker_crossref_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME checker_crossref_ 000100 segment_links_ptr checker_crossref_ 000102 sltep checker_crossref_ 000104 sltp checker_crossref_ 000106 names_ptr checker_crossref_ 000110 namep checker_crossref_ 000112 segment_not_found_head checker_crossref_ 000114 found_online_head checker_crossref_ 000116 entrypoint_not_found_head checker_crossref_ 000120 special_link_head checker_crossref_ 000122 IL_arg checker_crossref_ 000156 cep checker_crossref_ 000160 cx checker_crossref_ 000170 htp checker_crossref_ 000200 segment_number COLLECTION 000210 exp_relp LOOK_AT_LINKS 000211 modifier LOOK_AT_LINKS 000212 segment_name LOOK_AT_LINKS 000222 lx LOOK_AT_LINKS 000224 def_section_ptr LOOK_AT_LINKS 000236 link_entrypoint PROCESS_LINK 000246 found_in_segno PROCESS_LINK 000247 linking_slte PROCESS_LINK 000253 linked_slte PROCESS_LINK 000257 link_printed_rep PROCESS_LINK 000366 segno_in_word SEARCH 000367 segno SEARCH 000370 code SEARCH 000371 sx SEARCH 000372 s_ptr SEARCH 000374 segname_u SEARCH 000404 def_section_ptr SEARCH 000406 searched_hardcore SEARCH 000424 arep LINK_REP 000532 new_cep ADD_TO_CHAIN 000534 prev_cep ADD_TO_CHAIN 000560 last_s PRINT_CHAIN 000570 line PRINT_CHAIN 000632 column PRINT_CHAIN 000642 sx FILL_HASH_TABLE 000643 nx FILL_HASH_TABLE THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_g_a alloc_cs cat_realloc_cs call_ext_out_desc call_ext_out return enable shorten_stack ext_entry int_entry alloc_based THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. checker_print_ checker_print_$error checker_print_$error_term checker_print_$page checker_print_$skip get_definition_ get_temp_segment_ hash_$in hash_$make hash_$opt_size hash_$search hcs_$make_ptr interpret_link_$given_exp ioa_ release_temp_segment_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. checker_data_$area_ptr checker_data_$collection_names checker_data_$last_supervisor_collection checker_data_$loaded checker_data_$meter_ptr checker_data_$name_table_ptr checker_data_$slt_ptr error_table_$no_ext_sym error_table_$seg_not_found LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 12 000245 84 000253 85 000255 87 000271 89 000317 91 000320 92 000342 94 000371 97 000376 100 000402 101 000407 102 000426 103 000433 105 000452 106 000456 108 000461 110 000462 112 000500 113 000504 115 000506 116 000507 117 000523 118 000545 121 000546 127 000550 130 000576 132 000610 136 000635 137 000645 140 000646 151 000650 152 000654 153 000664 155 000670 156 000677 157 000702 159 000707 160 000726 161 000730 163 000731 179 000733 181 000756 182 000764 186 000767 188 000777 189 001002 190 001012 191 001014 194 001016 195 001022 197 001026 203 001120 210 001177 217 001250 219 001251 221 001275 223 001321 225 001345 229 001370 232 001371 246 001407 247 001410 248 001416 250 001435 252 001444 253 001471 255 001473 256 001475 261 001476 263 001532 266 001542 269 001554 272 001560 276 001572 277 001574 280 001604 282 001610 283 001642 287 001644 290 001655 291 001657 294 001660 298 001664 301 001666 304 001705 309 001707 311 002040 314 002047 323 002060 324 002067 325 002075 326 002101 328 002106 329 002110 331 002112 332 002113 335 002114 336 002116 337 002124 341 002134 342 002142 344 002151 345 002156 347 002157 349 002160 350 002166 352 002175 354 002203 355 002204 356 002212 358 002213 359 002214 362 002222 364 002230 367 002231 370 002232 372 002234 373 002235 375 002270 377 002275 380 002310 382 002312 383 002313 384 002346 386 002353 389 002366 391 002370 392 002371 394 002424 396 002431 399 002435 401 002437 402 002440 404 002473 406 002500 408 002504 410 002505 412 002506 413 002513 414 002520 416 002521 425 002523 426 002526 427 002530 428 002533 429 002546 431 002553 434 002575 435 002602 436 002622 437 002625 440 002627 441 002633 443 002652 445 002666 446 002672 441 002673 449 002674 450 002713 451 002727 453 002732 458 003000 459 003007 461 003031 464 003032 468 003033 469 003045 470 003060 471 003067 472 003124 473 003126 474 003146 ----------------------------------------------------------- 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