COMPILATION LISTING OF SEGMENT bind_fnp_load_ Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/15/82 1626.6 mst Mon Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 /* format: style4,delnl,insnl,^ifthendo */ 12 bind_fnp_load_: 13 proc (bind_fnp_ptr, fatal_error); 14 15 /* 16* Written by S. E. Barr 5/76. 17* Modified 1/9/78 by J. Stern to produce symbol cross reference. 18* Modified 3/15/78 by J. Stern to process trace macros identified by secondary defs. 19* Modified 1979 May 27 by Art Beattie to add support for DN6670 paging mechanism and 20* separate trace buffer from module chain. 21* Modified 1981 Jan 22 by Robert Coren to process metering macros identified by secondary defs. 22* Modified 1982 April 21 by Robert Coren to set up buffer page table entry pointer and to eliminate all references to 355 simulator. 23* Modified 1982 July 29 by Robert Coren to check size of core image against maximum loadable. 24**/ 25 26 /* parameter */ 27 28 dcl bind_fnp_ptr ptr; /* ptr to binder information */ 29 dcl fatal_error bit (1) unal; /* ON if binding unsuccessful */ 30 31 /* automatic */ 32 33 dcl address fixed bin (17); /* core_image offset */ 34 dcl card_id bit (12); 35 dcl card_len fixed bin; 36 dcl card_ptr ptr; /* ptr to card image from GCOS read */ 37 dcl chain_links fixed bin; /* number of links in the module chain for a single segment */ 38 dcl code fixed bin (35); 39 dcl core_len fixed bin; /* index of last word loaded in core image */ 40 dcl def_used bit (hbound (b.def, 1)) unal; /* one flag for each SYMDEF. ON if def was referenced */ 41 dcl entry_offset fixed bin; /* offset of entry at which to begin execution */ 42 dcl eof bit (1); /* ON if end of segment was reached */ 43 dcl extra_len fixed bin; /* length of unused table space */ 44 dcl input_attached bit (1) unal; /* ON is segment is attached for GCOS read */ 45 dcl iseg fixed bin; /* index of segment being loaded */ 46 dcl last_chain fixed bin; /* module name chain offset */ 47 dcl load_offset fixed bin; /* offset in core image to segment being loaded */ 48 dcl message char (300); /* error message printed by print */ 49 dcl message_len fixed bin; /* error message length */ 50 dcl module_nums_used (18) fixed bin; /* holds indices into b.segs, relates module numbers to segments */ 51 dcl num_defs fixed bin; /* number of defs */ 52 dcl num_refs fixed bin; /* number of refs for current segment */ 53 dcl num_trace_defs fixed bin; /* number of secondary defs identifying trace macros */ 54 dcl num_meter_defs fixed bin; /* number of secondary defs identifying metering macros */ 55 dcl obj_date char (32); /* date core image segment was created */ 56 dcl print_count fixed bin; /* number of items that have been printed */ 57 dcl sym_field_len fixed bin; /* number of bits used for symbol reference field */ 58 dcl text_size fixed bin; /* number of 18 bit words in segment to be loaded */ 59 dcl reflist char (130) varying; 60 dcl word fixed bin (35); 61 dcl (i, j, k, cnt) fixed bin; 62 63 dcl cleanup condition; 64 dcl (addr, bit, divide, fixed, hbound, length, mod, rel, substr, unspec, bin) builtin; 65 66 /* based */ 67 68 dcl 1 b based (bind_fnp_ptr) aligned like bind_fnp_info; 69 dcl 1 core aligned based (b.obj_ptr), 70 2 count fixed bin (35), 71 2 loc (0:32765) bit (18) unal; 72 dcl 1 core_image unal based (b.obj_ptr), 73 2 count fixed bin (35), /* number of 36 bit words in rest of segment */ 74 2 header unal, 75 3 not_set (0:415) bit (18) unal, 76 3 date_time_loaded fixed bin (71), /* date of loading */ 77 3 date_time_boot bit (72) unal, /* not set */ 78 3 buffer bit (18) unal, /* not set */ 79 3 last_loc_memory fixed bin (17) unal, /* offset of last location in core image */ 80 3 num_buffers bit (18) unal, 81 3 iom_table fixed bin (17) unal, /* offset of iom table */ 82 3 num_hsla fixed bin (17) unal, /* number of hsla's configured */ 83 3 num_lsla fixed bin (17) unal, /* number of lsla's configured */ 84 3 console_enable bit (18) unal, /* console enabled flag */ 85 3 module_chain fixed bin (17) unal, /* starting address of module chain */ 86 3 next_buffer bit (18) unal, 87 3 trace_mask bit (18) unal, /* trace entry enable mask */ 88 3 trace_table fixed bin (17) unal, /* base address of trace table */ 89 3 next_trace fixed bin (17) unal, /* next avialable location in trace table */ 90 3 fault_data fixed bin (17) unal, /* pointer to fault data storage */ 91 3 tib_table_base fixed bin (17) unal, /* base of tib table */ 92 3 tib_table_end fixed bin (17) unal, /* end of tib table */ 93 3 first_delay_table bit (18) unal, /* not set */ 94 3 version char (4) unal, /* version number */ 95 3 breakpoint_addr bit (18) unal, /* not set */ 96 3 trace_sw bit (18) unal, /* not set */ 97 3 next_smal_space bit (18) unal, /* not set */ 98 3 num_small_buffers bit (18) unal, /* not set */ 99 3 cct_desc bit (18) unal, /* address of first cct descriptor */ 100 3 sked_data_blk bit (18) unal, /* address of scheduler data block */ 101 3 echo_tables fixed bin (17) unal, /* address of list of echo-negotiation bit tables */ 102 3 cpu_page_table fixed bin (17) unal, /* address of cpu page table */ 103 3 cpu_page_table_entry fixed bin (17) unal, /* address of variable cpu page table entry */ 104 3 trace_size fixed bin (17) unal, /* size of trace buffer */ 105 3 meter_flag fixed bin (17) unal, /* nonzero if metering enabled */ 106 3 tandd_tib_addr bit (18) unal, /* not set */ 107 3 buffer_time_meter_addr bit (18) unal, /* not set */ 108 3 next_high_memory_buffer bit (18) unal, /* not set */ 109 3 buffer_page_table_entry fixed bin (17) unal, /* address of page table entry for buffer addresses */ 110 3 pad (39) bit (18) unal, 111 3 copyright_notice char (28) unal, /* image copyright notice */ 112 3 crash_loc fixed bin (17) unal, /* offset used for unresolved REF's */ 113 3 crash_op bit (18) unal, /* crash instruction */ 114 3 hsla_com bit (512 * 18 * b.num_hsla) unal, 115 3 page_table bit (128 * 18 * fixed ((b.memory >= 64), 17)) unal, 116 /* must start on mod 128 boundary */ 117 3 iom_channel (0:15) unal, 118 4 multiple_channel bit (1) unal, /* ON if multiple channel device */ 119 4 pad bit (2) unal, 120 4 device_number bit (3) unal, /* device number (for multiple channel devices) */ 121 4 pad_2 bit (3) unal, 122 4 device_type fixed bin (4) unal, /* code for type of device */ 123 4 device_speed bit (4) unal, 124 4 offset fixed bin (17) unal, /* offset ofchannel table */ 125 3 hsla_table bit (32 * 36 * b.num_hsla), 126 3 lsla_table bit (54 * 36 * b.num_lsla), 127 3 start_load fixed bin; 128 129 dcl 1 core_fragment aligned based (b.obj_ptr), 130 2 count fixed bin (35), 131 2 loaded (0:load_offset) bit (18) unal, 132 2 extra (extra_len) bit (18) unal; 133 134 /* external */ 135 136 dcl clock_ entry () returns (fixed bin (71)); 137 dcl date_time_ entry (fixed bin (71), char (*)); 138 dcl error_table_$noentry fixed bin (35) ext; 139 dcl ioa_$ioa_switch entry options (variable); 140 dcl ioa_$ioa_switch_nnl entry options (variable); 141 dcl ioa_$rsnnl entry options (variable); 142 dcl ios_$attach entry (char (*), char (*), char (*), char (*), bit (72)); 143 dcl ios_$detach entry (char (*), char (*), char (*), bit (72)); 144 dcl ios_$setsize entry (char (*), fixed bin, bit (72)); 145 dcl iox_$error_output ptr ext; 146 dcl com_err_ entry options (variable); 147 dcl gcos_cv_gebcd_ascii_ entry (ptr, fixed bin, ptr); 148 dcl gcos_gsr_read_$gsr_read_init entry (char (*), fixed bin (35)); 149 dcl gcos_gsr_read_ entry (char (*), ptr, fixed bin, bit (12), bit (1), fixed bin (35)); 150 dcl gcos_gsr_read_$gsr_read_close entry (char (*), fixed bin (35)); 151 dcl get_group_id_ entry () returns (char (32)); 152 dcl get_wdir_ entry () returns (char (168)); 153 154 /* constants */ 155 156 dcl INPUT char (8) int static options (constant) init ("bind_fnp"); 157 dcl TRACE fixed bin int static options (constant) init (3);/* b.module (3) = trace type */ 158 dcl LOAD_BASE fixed bin int static options (constant) init (512); 159 dcl LOW_CORE_SIZE fixed bin int static options (constant) init (32768); 160 1 1 /* BEGIN INCLUDE FILE for bind_fnp_info */ 1 2 /* Written 5/76 by S.E. Barr */ 1 3 /* Modified 1/9/78 by J. Stern for cross reference data */ 1 4 /* Modified 3/15/78 by J. Stern to add trace macro data */ 1 5 /* Modified 1/22/81 by Robert Coren to add metering macro data */ 1 6 1 7 dcl 1 bind_fnp_info aligned based, 1 8 2 obj_name char (32), /* name of core_image beging built */ 1 9 2 obj_len fixed bin, /* number of 36 bit words in core image segment */ 1 10 2 obj_ptr ptr, /* ptr to core image segment */ 1 11 2 list_ptr ptr, /* ptr to listing if -list was specified */ 1 12 2 flags aligned, 1 13 3 list bit (1) unal, /* ON if output listing was requested */ 1 14 3 printer bit (1) unal, /* ON if printer can be configured */ 1 15 3 console bit (1) unal, /* ON if console can be configured */ 1 16 3 error_header bit (1) unal, /* ON if error message header has been printed */ 1 17 3 simulator bit (1) unal, 1 18 3 cross_ref bit (1) unal, /* ON if symbol cross reference was requested */ 1 19 3 metering_enabled bit (1) unal, /* ON if metering code is to be executed */ 1 20 3 pad bit (29) unal, 1 21 2 version char (4), /* MCS version number */ 1 22 2 num_hsla fixed bin, /* maximum HSLA's that can be configured */ 1 23 2 num_lsla fixed bin, /* maximum LSLA's that can be configured */ 1 24 2 memory fixed bin, /* amt of memory available in units of 1024 */ 1 25 2 entry char (8), /* entry at which execution is to begin */ 1 26 2 module (3) aligned, 1 27 3 name char (25) var, /* segment name of module without .objdk */ 1 28 3 size fixed bin, /* size of tables in 18 bit words */ 1 29 2 mask bit (18), /* trace mask */ 1 30 2 num_segs fixed bin, /* number of segments to be combined */ 1 31 2 num_directories fixed bin, /* number of directories in binder search rules */ 1 32 2 directory (10) char (168) var, /* directories to search for object segments */ 1 33 2 segs (100) aligned, 1 34 3 seg_name char (32) var, /* segment name */ 1 35 3 offset fixed bin unal, /* load offset of module */ 1 36 3 length fixed bin unal, /* text length of module */ 1 37 3 date char (15), /* date module was compiled */ 1 38 3 dir_found char (168), /* search rule used to find module */ 1 39 3 modnum fixed bin, /* module number used as trace mask index */ 1 40 2 ref (256) fixed bin, /* index into def table for SYMREF (allows 8 bit field) */ 1 41 2 def (1000) aligned, /* SYMDEF table */ 1 42 3 name bit (36) unal, /* bcd name of SYMDEF */ 1 43 3 offset fixed bin, /* offset within module in 18 bit words */ 1 44 3 def_module fixed bin, /* index in segs array of module containing this def */ 1 45 3 ref_modules bit (108) unal, /* bit i ON if def referenced by module i */ 1 46 2 trace_offset (100) fixed bin, /* trace macro offsets */ 1 47 2 meter_offset (100) fixed bin, /* metering macro offsets */ 1 48 2 unresolved (num_unresolved), /* unresolved reference table */ 1 49 3 core_loc fixed bin, /* core location offset in 18 bit words */ 1 50 3 index_def fixed bin; /* index in def table of SYMDEF not yet found */ 1 51 dcl num_unresolved fixed bin; 1 52 1 53 /* END INCLUDE FILE for bind_fnp_info */ 161 162 163 core_len = core_offset (addr (core_image.start_load)) - 1; 164 last_chain = core_offset (addr (core_image.module_chain)); 165 def_used, input_attached = "0"b; 166 num_defs, num_unresolved = 0; 167 module_nums_used (*) = 0; 168 on cleanup call detach_segment; 169 170 do iseg = 1 to b.num_segs; 171 call get_segment (b.segs (iseg).seg_name); 172 call preface_cards; 173 call relocate_text; 174 call detach_segment; 175 end; 176 177 core.loc (last_chain) = ""b; /* zero forward ptr in last link of module chain */ 178 call set_load_info; 179 180 /* Print warning messages for SYMDEF's that were not referenced. */ 181 182 if b.list & substr (^def_used, 1, num_defs) 183 then do; 184 call ioa_$ioa_switch (b.list_ptr, 185 "^/^/The following symbols were defined, but were not referenced:^/^/^1x^4(Symbol Module^19x^)"); 186 j = 0; 187 do i = 1 to num_defs; 188 if ^substr (def_used, i, 1) & b.def (i).offset ^= 0 189 then call print_symbol (j, b.def (i).offset, b.def (i).name); 190 end; 191 end; 192 193 /* Fill in unresolved references from table. There is only one error message for each symbol. After the error 194* message has been printed, the offset in def is set to -1, so future references will not cause a message. 195**/ 196 197 cnt = 0; 198 do i = 1 to num_unresolved; 199 j = b.unresolved (i).core_loc; 200 k = b.unresolved (i).index_def; 201 address = b.def (k).offset; 202 if address <= 0 203 then do; 204 if b.list & address = 0 205 then do; 206 if cnt = 0 207 then call ioa_$ioa_switch (b.list_ptr, 208 "^/^/The following symbols were referenced, but were not defined:^/^/^1x^4(Symbol Module^19x^)" 209 ); 210 call print_symbol (cnt, j, b.def (k).name); 211 b.def (k).offset = -1; 212 end; 213 address = core_offset (addr (core_image.crash_loc)); 214 end; 215 word = fixed (core.loc (j), 35) + address; 216 core.loc (j) = substr (unspec (word), 19, 18); 217 end; 218 219 /* Print symbol table */ 220 221 if b.list 222 then do; 223 call shell_sort (b.def, num_defs); 224 call ioa_$ioa_switch (b.list_ptr, "^/^/^/^/The following symbols were defined:^/^/^6(Symbol Offset^3x^)"); 225 print_count = 0; 226 do i = 1 to num_defs; 227 if b.def (i).offset > 0 228 then do; 229 if mod (print_count, 6) = 0 230 then call ioa_$ioa_switch (b.list_ptr, ""); 231 print_count = print_count + 1; 232 call ioa_$ioa_switch_nnl (b.list_ptr, "^6a^8o^3x", ascii (b.def (i).name), b.def (i).offset); 233 end; 234 end; 235 end; 236 237 if b.list 238 then do; 239 call date_time_ ((core_image.date_time_loaded), obj_date); 240 call ioa_$ioa_switch (b.list_ptr, "^|Bindmap for ^a>^a, Version ^a^/Created on ^a, by ^a", get_wdir_ (), 241 b.obj_name, b.version, obj_date, get_group_id_ ()); 242 call ioa_$ioa_switch (b.list_ptr, "^/Component^16x^[^6x^;Modnum^] Start Length Date Compiled Directory^/", 243 unspec (module_nums_used) = ""b); 244 do i = 1 to b.num_segs; 245 call ioa_$ioa_switch (b.list_ptr, "^25a^[^s^6x^;^6d^]^7o^8o ^a ^a", b.segs (i).seg_name, 246 b.segs (i).modnum = 0, b.segs (i).modnum, b.segs (i).offset, b.segs (i).length, b.segs (i).date, 247 b.segs (i).dir_found); 248 end; 249 end; 250 251 /* print symbol cross reference */ 252 253 if b.cross_ref 254 then do; 255 call ioa_$ioa_switch (b.list_ptr, "^|Symbol cross reference by module:^/"); 256 do i = 1 to num_defs; 257 if b.def (i).offset > 0 258 then do; 259 k = b.def (i).def_module; 260 call ioa_$ioa_switch (b.list_ptr, "^/^6a^8o (^a|^o)", ascii (b.def (i).name), b.def (i).offset, 261 b.segs (k).seg_name, b.def (i).offset - b.segs (k).offset); 262 reflist = ""; 263 do j = 1 to b.num_segs; 264 if substr (b.def (i).ref_modules, j, 1) 265 then do; 266 if length (reflist) + length (b.segs (j).seg_name) + 2 > 130 267 then do; 268 call ioa_$ioa_switch (b.list_ptr, "^a", reflist); 269 reflist = ""; 270 end; 271 reflist = reflist || " " || b.segs (j).seg_name; 272 end; 273 end; 274 if reflist ^= "" 275 then call ioa_$ioa_switch (b.list_ptr, "^a", reflist); 276 end; 277 end; 278 end; 279 280 RETURN: 281 return; 282 283 /* This procedure converts a BCD bit string into an ASCII character string */ 284 285 286 ascii: 287 proc (bit_string) returns (char (80) var); 288 289 dcl bit_string bit (*); 290 dcl char_string char (80); 291 dcl num_chars fixed bin; 292 293 num_chars = divide (length (bit_string), 6, 17); 294 call gcos_cv_gebcd_ascii_ (addr (bit_string), num_chars, addr (char_string)); 295 296 return (substr (char_string, 1, num_chars)); 297 298 end ascii; 299 300 /* * This procedure sets up the next segment to be loaded. 301* * 1. It locates the segment using the specified search rules. (the suffix .objdk is assumed) 302* * 2. It makes the io attachment of the input stream to the segment and sets input_attached. 303* * 3. It makes the initializing call to the GCOS read procedure. 304**/ 305 306 307 get_segment: 308 proc (name); 309 310 dcl name char (*) var; /* The segment name without .objdk */ 311 312 /* automatic */ 313 314 dcl i fixed bin; 315 dcl status bit (72); 316 dcl code fixed bin (35) based (addr (status)); 317 318 do i = 1 to b.num_directories; 319 call ios_$attach (INPUT, "file_", b.directory (i) || ">" || name || ".objdk", "r", status); 320 if code = 0 321 then do; 322 b.segs (iseg).dir_found = b.directory (i); 323 input_attached = "1"b; 324 call ios_$setsize (INPUT, 36, status); 325 if code = 0 326 then do; 327 call gcos_gsr_read_$gsr_read_init (INPUT, code); 328 if code = 0 329 then return; 330 end; 331 end; 332 333 else if code ^= error_table_$noentry 334 then call abort (code, b.directory (i) || ">" || name || ".objdk"); 335 end; 336 337 call abort (error_table_$noentry, name || ".objdk"); 338 339 end get_segment; 340 341 /* * This procedure reads the preface cards for the object segment and fills in the ref table and def table 342* * It sets: 343* * load_offset Location to begin loading text. 344* * text_size The length of the text. (It may be longer than the number of words to be loaded 345* * if table space was reserved at the end of the text) 346* * sym_field_len Number of bits in the symbol reference field 347**/ 348 349 350 preface_cards: 351 proc; 352 353 /* automatic */ 354 355 dcl (i, j) fixed bin; 356 dcl cnt fixed bin; 357 dcl time fixed bin; 358 dcl num_symbols fixed bin; 359 360 /* based */ 361 362 dcl 1 binary aligned based (card_ptr), 363 2 word_1 aligned, 364 3 id_1 bit (3) unal, /* must be '4' */ 365 3 sym_ref_field bit (6) unal, /* number of bits for symbol reference */ 366 3 id_2 bit (3) unal, /* must be '5' */ 367 3 preface_len bit (6) unal, /* number 18 bit words from word 3 */ 368 3 text_len bit (18) unal, /* number of words in text */ 369 2 checksum bit (36) aligned, 370 2 word_3 aligned, 371 3 blank_common_len bit (18) unal, /* not used */ 372 3 load_mod_code bit (3) unal, /* 0,1,2,3, = mod 2, 8, 16, 64 */ 373 3 num_symbols_2 bit (15) unal, /* 2 * number of SYMDEF's, SYMREF's and common */ 374 2 symbol (num_symbols) aligned, 375 3 name bit (36), 376 3 offset fixed bin (17) unal, 377 3 pad bit (15) unal, 378 3 symbol_code bit (3) unal; 379 380 dcl 1 h aligned based (card_ptr), /* header card */ 381 2 pad (10) bit (36), 382 2 ten_hr fixed bin (5) unal, 383 2 one_hr fixed bin (5) unal, 384 2 decimal_pt bit (6) unal, 385 2 ten_min fixed bin (5) unal, 386 2 one_min fixed bin (5) unal, 387 2 pad_2 bit (6) unal, /* ignore last digit of time */ 388 2 month bit (12) unal, 389 2 day bit (12) unal, 390 2 year bit (12) unal; 391 392 /* constant */ 393 394 dcl BIN_CARD bit (3) int static options (constant) init ("100"b); 395 dcl CHAIN_ID bit (12) int static options (constant) init ("3323"b3); 396 /* BCD for .c */ 397 dcl TRACE_ID bit (6) int static options (constant) init ("67"b3); 398 /* BCD for x */ 399 dcl METER_ID bit (6) int static options (constant) init ("44"b3); 400 /* BCD for m */ 401 dcl LOAD_MOD (0:4) fixed bin int static options (constant) init (2, 8, 16, 32, 64); 402 403 call gcos_gsr_read_ (INPUT, card_ptr, card_len, card_id, eof, code); 404 405 if b.list 406 then do; 407 time = ten_hr * 1000 + one_hr * 100 + divide (60 * (ten_min * 10 + one_min), 100, 17, 0); 408 call ioa_$rsnnl ("^a/^a/^a ^4d", b.segs (iseg).date, i, ascii (h.month), ascii (h.day), ascii (h.year), time); 409 end; 410 load_offset, num_refs, cnt, chain_links, num_trace_defs, num_meter_defs = 0; 411 do while ("1"b); 412 call gcos_gsr_read_ (INPUT, card_ptr, card_len, card_id, eof, code); 413 if code ^= 0 414 then do; 415 call ioa_$rsnnl ("Attempting to read ^a>^a.objdk", message, message_len, b.segs (iseg).dir_found, 416 b.segs (iseg).seg_name); 417 call abort (code, message); 418 end; 419 if load_offset = 0 420 then do; 421 i = fixed (binary.load_mod_code, 17); 422 load_offset = core_len + LOAD_MOD (i) - mod (core_len, LOAD_MOD (i)); 423 text_size = fixed (binary.text_len, 17); 424 sym_field_len = fixed (binary.sym_ref_field, 17) + 1; 425 call special_module (text_size); 426 if b.list 427 then do; 428 b.segs (iseg).offset = load_offset; 429 b.segs (iseg).length = text_size; 430 end; 431 432 end; 433 if binary.id_1 = BIN_CARD 434 then do; 435 num_symbols = divide (fixed (binary.preface_len, 35) - 2, 4, 35); 436 do i = 1 to num_symbols; 437 438 /* The chain is specified by a secondary DEF for a symbol with a name that begins with ".c" */ 439 440 if symbol (i).symbol_code = "001"b 441 then do; 442 if substr (symbol (i).name, 1, length (CHAIN_ID)) = CHAIN_ID 443 then do; 444 chain_links = chain_links + 1; 445 if chain_links > 1 446 then do; 447 call ioa_$rsnnl ("^d secondary DEFS found for module chain in ^a.objdk", message, 448 message_len, chain_links, b.segs (iseg).seg_name); 449 call print (); 450 end; 451 452 core.loc (last_chain) = bit (load_offset + symbol (i).offset, 18); 453 last_chain = load_offset + symbol (i).offset; 454 end; 455 456 /* A trace macro is identified by a secondary DEF for a symbol with a name that begins with "x" */ 457 458 else if substr (symbol (i).name, 1, length (TRACE_ID)) = TRACE_ID 459 then do; 460 num_trace_defs = num_trace_defs + 1; 461 b.trace_offset (num_trace_defs) = load_offset + symbol (i).offset; 462 end; 463 464 /* A metering macro is identified by a secondary DEF for a symbol with a name that begins with "m" */ 465 466 else if substr (symbol (i).name, 1, length (METER_ID)) = METER_ID 467 then do; 468 num_meter_defs = num_meter_defs + 1; 469 b.meter_offset (num_meter_defs) = load_offset + symbol (i).offset; 470 end; 471 472 473 else do; 474 call ioa_$rsnnl ("Unexpected secondary DEF ^a in ^a.objdk", message, message_len, 475 ascii ((symbol (i).name)), b.segs (iseg).seg_name); 476 call print (); 477 end; 478 end; 479 else do; 480 do j = 1 to num_defs while (symbol (i).name ^= b.def (j).name); 481 end; 482 if j > num_defs 483 then do; 484 num_defs = num_defs + 1; 485 b.def (j).name = symbol (i).name; 486 end; 487 488 /* SYMREF: put index of symbol in DEF table into REF table */ 489 490 if symbol (i).symbol_code = "101"b 491 then do; 492 num_refs = num_refs + 1; 493 b.ref (num_refs) = j; 494 end; 495 496 /* Primary DEF: put actual offset into DEF table */ 497 498 else if symbol (i).symbol_code = "000"b 499 then do; 500 if b.def (j).offset ^= 0 501 then do; /* already have a DEF with same name */ 502 call ioa_$rsnnl ("DEF ^a in ^a.objdk previously defined in ^a.objdk", message, 503 message_len, ascii (b.def (j).name), b.segs (iseg).seg_name, 504 b.segs (b.def (j).def_module).seg_name); 505 call print (); 506 end; 507 508 b.def (j).offset = load_offset + symbol (i).offset; 509 b.def (j).def_module = iseg; 510 if b.entry = ascii ((symbol (i).name)) 511 then do; 512 entry_offset = b.def (j).offset; 513 substr (def_used, j, 1) = "1"b; 514 end; 515 end; 516 else do; 517 call ioa_$rsnnl ("Illegal symbol code while processing ^a>^a.objdk", message, message_len, 518 b.segs (iseg).dir_found, b.segs (iseg).seg_name); 519 call abort (0, message); 520 end; 521 end; 522 end; 523 cnt = cnt + num_symbols; 524 if 2 * cnt = fixed (binary.num_symbols_2) 525 then do; 526 if chain_links = 0 527 then do; 528 call ioa_$rsnnl ("Module chain link missing for ^a.objdk", message, message_len, 529 b.segs (iseg).seg_name); 530 call print (); 531 end; 532 return; 533 end; 534 end; 535 else do; 536 call ioa_$rsnnl ("Binary card expected while processing ^a>^a.objdk", message, message_len, 537 b.segs (iseg).dir_found, b.segs (iseg).seg_name); 538 call abort (0, message); 539 end; 540 end; 541 542 end preface_cards; 543 544 /* * This procedure special cases the lsla, hsla and trace type modules. 545* * 546* * lsla, hsla the length of the text is reduced by the amount of unused table space. 547* * (size * number of LSLA's not used) 548**/ 549 550 551 special_module: 552 proc (text_len); 553 554 dcl text_len fixed bin; /* number of words of text to load */ 555 556 dcl i fixed bin; 557 558 /* constants */ 559 560 dcl MAX_LSLA fixed bin int static options (constant) init (6); 561 dcl MAX_HSLA fixed bin int static options (constant) init (3); 562 563 do i = 1 to 3 while (b.module (i).name ^= b.segs (iseg).seg_name); 564 end; 565 if i = 1 566 then text_len = text_len - (MAX_LSLA - b.num_lsla) * b.module (1).size; 567 else if i = 2 568 then text_len = text_len - (MAX_HSLA - b.num_hsla) * b.module (2).size; 569 570 return; 571 572 end special_module; 573 574 /* * This procedure loads and modifies text using the relocation bits specified on the text cards. 575* * Text cards may contain one or more blocks of 18 bit words to be loaded. If the word following a block that 576* * has just been loaded contains a relocation id, then another block follows. The format of the first block 577* * on the card is described by 'text'. The format of successive blocks is described by 'extra'. There are 578* * a maximum of 39 words per card. 579**/ 580 581 582 relocate_text: 583 proc; 584 585 dcl i fixed bin; 586 dcl num_instr fixed bin; /* number of instructions to load */ 587 dcl p ptr; 588 589 /* constant */ 590 591 dcl REL_CARD bit (12) int static options (constant) init ("010000000101"b); 592 /* '2005' */ 593 594 /* based */ 595 596 dcl 1 text unal based (card_ptr), 597 2 id bit (12) unal, /* must be '2005' */ 598 2 num bit (6) unal, /* number 18 bit words in this block to load */ 599 2 base_rel_offset fixed bin (17) unal, /* load offset */ 600 2 check_sum bit (36) unal, 601 2 reloc (39) bit (2) unal, 602 2 pad bit (12) unal, 603 2 instr (num_instr) bit (18) unal, /* words to be loaded */ 604 2 next_block bit (18) unal; 605 dcl 1 extra unal based (p), 606 2 id bit (12) unal, 607 2 num bit (6) unal, 608 2 base_rel_offset fixed bin (17) unal, 609 2 instr (num_instr) bit (18) unal, 610 2 next_block bit (18) unal; 611 612 613 do while (^eof); 614 call gcos_gsr_read_ (INPUT, card_ptr, card_len, card_id, eof, code); 615 if ^eof 616 then do; 617 if setup_block (0, card_ptr) 618 then do; 619 call load (0, addr (text.instr (1))); 620 p = addr (text.next_block); 621 i = num_instr; 622 do while (setup_block (i, p)); 623 call load (i, addr (extra.instr (1))); 624 p = addr (extra.next_block); 625 i = i + num_instr; 626 end; 627 end; 628 end; 629 end; 630 631 call process_trace_defs (); 632 call process_meter_defs (); 633 load_offset = load_offset + text_size - 1; 634 extra_len = core_len - load_offset; /* get length of unused table space */ 635 if extra_len > 0 636 then unspec (core_fragment.extra) = ""b; 637 core_len = load_offset; 638 639 return; 640 641 /* This procedure checks the next word on a text card. It it has a relocation id, it computes the new load offset 642* and the number of words to be loaded. 643**/ 644 645 646 setup_block: 647 proc (num_instr_loaded, p) returns (bit (1) unal); 648 649 dcl num_instr_loaded fixed bin; /* number of instructions already loaded from this card */ 650 dcl p ptr; 651 652 dcl 1 extra unal based (p), 653 2 id bit (12) unal, 654 2 num bit (6) unal, 655 2 base_rel_offset fixed bin (17) unal, 656 2 instr (num_instr) bit (18) unal, 657 2 next_block bit (18) unal; 658 659 if num_instr_loaded < 39 660 then if extra.id = REL_CARD 661 then do; 662 num_instr = fixed (extra.num, 17); 663 core_len = load_offset + extra.base_rel_offset; 664 return ("1"b); 665 end; 666 667 return ("0"b); 668 669 end setup_block; 670 671 /* * This procedure loads the words using the relocation code specified by text.reloc in the first block of the 672* * text card. 673* * 674* * "00"b no relocation 675* * "01"b address is relative to the load address of the module 676* * "11"b symbol reference 677**/ 678 679 680 load: 681 proc (index_rel, p); 682 683 dcl index_rel fixed bin; /* index of last relocation bits */ 684 dcl p ptr; /* ptr to instructions to be loaded */ 685 686 dcl (i, j) fixed bin; 687 dcl word fixed bin (35); 688 689 /* based */ 690 691 dcl instr (num_instr) bit (18) unal based (p); /* words to be loaded */ 692 dcl 1 sym_ref based (addr (word)), /* word that contains a symbol reference */ 693 2 pad bit (18) unal, 694 2 tag bit (3) unal, 695 2 id bit (sym_field_len) unal, /* symbol reference number */ 696 2 address bit (18 - sym_field_len) unal; 697 698 do i = 1 to num_instr; 699 if text.reloc (index_rel + i) = "00"b 700 then core.loc (core_len) = instr (i); 701 else do; 702 word = fixed (instr (i), 35); 703 if text.reloc (index_rel + i) = "01"b 704 then word = word + load_offset; 705 706 /* SYMREF load relative to symbol reference and set flag to indicate SYMDEF was used. 707* Check for overflow of the address field (all 1's) 708**/ 709 else if text.reloc (index_rel + i) = "11"b 710 then do; 711 j = fixed (sym_ref.id, 17, 0); 712 sym_ref.id = "0"b; 713 if j <= num_refs & j > 0 714 then do; 715 if ^sym_ref.address = "0"b 716 then do; 717 call ioa_$rsnnl ("Indirection through external symbol is not supported in ^a.objdk", 718 message, message_len, b.segs (iseg).seg_name); 719 call print (); 720 end; 721 j = b.ref (j); /* get def index for reference */ 722 723 /* add location to unresolved table if offset is zero */ 724 725 if b.def (j).offset = 0 726 then do; 727 num_unresolved = num_unresolved + 1; 728 b.unresolved (num_unresolved).core_loc = core_len; 729 b.unresolved (num_unresolved).index_def = j; 730 end; 731 else word = word + b.def (j).offset; 732 substr (def_used, j, 1) = "1"b; 733 substr (b.def (j).ref_modules, iseg, 1) = "1"b; 734 end; 735 else do; 736 call ioa_$rsnnl ("Invalid reference to #^d in ^a.objdk", message, message_len, j, 737 b.segs (iseg).seg_name); 738 call print (); 739 end; 740 end; 741 else do; 742 call ioa_$rsnnl ("Invalid relocation code ^b in ^a.objdk", message, message_len, 743 text.reloc (index_rel + i), b.segs (iseg).seg_name); 744 call print (); 745 end; 746 core.loc (core_len) = substr (unspec (word), 19, 18); 747 ; 748 end; 749 core_len = core_len + 1; 750 end; 751 return; 752 753 end load; 754 755 /* This procedure enables trace macros for a module if the 756* trace mask indicates that they should be enabled. Otherwise, 757* no action is taken which leaves the trace macros in their 758* disabled state. 759**/ 760 761 762 process_trace_defs: 763 proc; 764 765 dcl i fixed bin; 766 dcl module_num fixed bin; 767 768 769 if chain_links ^= 1 /* module chain messed up for this module */ 770 then return; 771 772 module_num = bin (core.loc (last_chain), 18); 773 if module_num < 0 | module_num > 18 774 then do; 775 call ioa_$rsnnl ("Invalid module number ^d found for ^a.objdk", message, message_len, module_num, 776 b.segs (iseg).seg_name); 777 call print (); 778 return; 779 end; 780 781 if module_num ^= 0 782 then do; 783 if module_nums_used (module_num) ^= 0 784 then do; 785 call ioa_$rsnnl ("Module number ^d in ^a.objdk previously used for ^a.objdk", message, message_len, 786 module_num, b.segs (iseg).seg_name, b.segs (module_nums_used (module_num)).seg_name); 787 call print (); 788 return; 789 end; 790 791 b.segs (iseg).modnum = module_num; 792 module_nums_used (module_num) = iseg; 793 end; 794 795 if num_trace_defs = 0 796 then return; 797 798 if module_num = 0 799 then do; 800 call ioa_$rsnnl ("Zero module number found for ^a.objdk which contains trace DEFs", message, message_len, 801 b.segs (iseg).seg_name); 802 call print (); 803 end; 804 805 if ^substr (b.mask, module_num, 1) /* want trace macros disabled */ 806 then return; /* so leave them alone */ 807 call patch_defs (num_trace_defs, b.trace_offset, "Trace"); 808 809 end process_trace_defs; 810 811 process_meter_defs: 812 proc; 813 814 /* This procedure enables metering macros for a module if the bindfile indicates 815* that metering is to be enabled. Otherwise, they are left disabled. 816**/ 817 818 if num_meter_defs > 0 819 then if b.flags.metering_enabled 820 then call patch_defs (num_meter_defs, b.meter_offset, "Metering"); 821 return; 822 823 end process_meter_defs; 824 825 patch_defs: 826 proc (p_num_defs, offset_array, type_name); 827 828 /* Procedure used by process_meter_defs and process_trace_defs to patch TRAs marked 829* by secondary symdefs to NOPs 830**/ 831 832 dcl p_num_defs fixed bin; 833 dcl offset_array (*) fixed bin; 834 dcl type_name char (*); 835 836 dcl TRA_OPCODE bit (6) int static options (constant) init ("71"b3); 837 dcl NOP bit (18) int static options (constant) init ("233100"b3); 838 839 840 do i = 1 to p_num_defs; /* enable all the specified macros */ 841 if substr (core.loc (offset_array (i)), 4, 6) ^= TRA_OPCODE 842 then do; 843 call ioa_$rsnnl ("^a macro at ^a.objdk|^o does not begin with TRA instruction", message, message_len, 844 type_name, b.segs (iseg).seg_name, offset_array (i) - load_offset); 845 call print (); 846 end; 847 else core.loc (offset_array (i)) = NOP; 848 end; 849 return; 850 end patch_defs; 851 852 end relocate_text; 853 854 /* This procedure fills in the header and trailer for the core image */ 855 856 857 set_load_info: 858 proc; 859 860 dcl i fixed bin (35); 861 862 dcl 1 trailer unal based (addr (core.loc (core_len))), 863 2 start fixed bin (17) unal, /* start of core image */ 864 2 end fixed bin (17) unal, /* offset of end of core image */ 865 2 length fixed bin (17) unal, /* number of 18 bit words in core image */ 866 2 start_entry fixed bin (17) unal; /* offset to begin execution */ 867 868 dcl MCS_BCD bit (36) int static init ("011011100100010011110010011011010000"b); 869 /* BCD .mcs. octal 334423623320 */ 870 871 dcl ( 872 FIRST_HSLA_CH init (6), 873 FIRST_LSLA_CH init (9) 874 ) fixed bin int static options (constant); 875 876 core_image.date_time_loaded = clock_ (); 877 core_image.last_loc_memory = b.memory * 1024 - 1; /* memory starts at 0 */ 878 if b.memory >= 64 879 then do; 880 core_image.cpu_page_table = core_offset (addr (substr (core_image.page_table, 1))); 881 core_image.cpu_page_table_entry = core_image.cpu_page_table + 127; 882 core_image.buffer_page_table_entry = core_image.cpu_page_table + 126; 883 end; 884 core_image.iom_table = core_offset (addr (core_image.iom_channel (0))); 885 core_image.num_hsla = b.num_hsla; 886 core_image.num_lsla = b.num_lsla; 887 core_image.trace_mask = b.mask; 888 core_image.version = b.version; 889 core_image.crash_loc = 0; 890 core_image.crash_op = "000101001000000010"b; /* octal 051002 */ 891 core_image.trace_size = b.module (TRACE).size; 892 if b.flags.metering_enabled 893 then core_image.meter_flag = 1; 894 else core_image.meter_flag = 0; 895 core_image.copyright_notice = "COPR. (C) H.I.S. INC. 1981"; 896 897 /* Fill in iom channel table. Device type codes: 898* * 0 not implemented 4 lsla 899* * 1 clock 5 console 900* * 2 dia 6 printer 901* * 3 hsla 902**/ 903 if b.console 904 then core_image.iom_channel (0).device_type = 5; /* console */ 905 if b.printer 906 then core_image.iom_channel (2).device_type = 6; /* printer */ 907 core_image.iom_channel (4).device_type = 2; /* dia */ 908 if b.memory >= 64 /* if modern core image */ 909 then do; 910 core_image.iom_channel (3).device_type, /* dia may be on any of 3, 4, 5, or 12 */ 911 core_image.iom_channel (5).device_type, 912 core_image.iom_channel (12).device_type = 2; 913 end; 914 core_image.iom_channel (15).device_type = 1; /* clock */ 915 916 do i = 1 to b.num_hsla; 917 core_image.iom_channel (FIRST_HSLA_CH + i - 1).multiple_channel = "1"b; 918 core_image.iom_channel (FIRST_HSLA_CH + i - 1).device_type = 3; 919 core_image.iom_channel (FIRST_HSLA_CH + i - 1).device_number = substr (unspec (i), 34, 3); 920 core_image.iom_channel (FIRST_HSLA_CH + i - 1).offset = 921 core_offset (addr (substr (core_image.hsla_table, 32 * 36 * (i - 1) + 1))); 922 end; 923 924 do i = 1 to b.num_lsla; 925 core_image.iom_channel (FIRST_LSLA_CH + i - 1).multiple_channel = "1"b; 926 core_image.iom_channel (FIRST_LSLA_CH + i - 1).device_type = 4; 927 core_image.iom_channel (FIRST_LSLA_CH + i - 1).device_number = substr (unspec (i), 34, 3); 928 core_image.iom_channel (FIRST_LSLA_CH + i - 1).device_speed = "0100"b; 929 core_image.iom_channel (FIRST_LSLA_CH + i - 1).offset = 930 core_offset (addr (substr (core_image.lsla_table, 54 * 36 * (i - 1) + 1))); 931 end; 932 933 /* Add 4 word block at end of core image for FNP loader */ 934 935 core_len = core_len + 4 - mod (core_len, 4); 936 trailer.start = 0; 937 trailer.end, trailer.length = core_len + 4; 938 trailer.start_entry = entry_offset; 939 core_len = core_len + 4; 940 941 /* Make sure core image will fit in 32K with gicb */ 942 943 if core_len + LOAD_BASE > LOW_CORE_SIZE /* it won't */ 944 then call abort (0, "Core image is too large to load in 32K."); 945 946 b.obj_len = divide (core_len, 2, 17, 0) + 1; 947 core_image.count = b.obj_len - 1; 948 949 end set_load_info; 950 951 /* The procedure is given an address within the core_image and it returns the index in loc that corresponds to 952* that address. 953**/ 954 955 956 core_offset: 957 proc (item_ptr) returns (fixed bin (17)); 958 959 dcl item_ptr ptr; 960 dcl offset fixed bin (17) unal; 961 2 1 /* BEGIN INCLUDE FILE its.incl.pl1 2 2* modified 27 July 79 by JRDavis to add its_unsigned 2 3* Internal format of ITS pointer, including ring-number field for follow-on processor */ 2 4 2 5 dcl 1 its based aligned, /* declaration for ITS type pointer */ 2 6 2 pad1 bit (3) unaligned, 2 7 2 segno bit (15) unaligned, /* segment number within the pointer */ 2 8 2 ringno bit (3) unaligned, /* ring number within the pointer */ 2 9 2 pad2 bit (9) unaligned, 2 10 2 its_mod bit (6) unaligned, /* should be 43(8) */ 2 11 2 12 2 offset bit (18) unaligned, /* word offset within the addressed segment */ 2 13 2 pad3 bit (3) unaligned, 2 14 2 bit_offset bit (6) unaligned, /* bit offset within the word */ 2 15 2 pad4 bit (3) unaligned, 2 16 2 mod bit (6) unaligned; /* further modification */ 2 17 2 18 dcl 1 itp based aligned, /* declaration for ITP type pointer */ 2 19 2 pr_no bit (3) unaligned, /* number of pointer register to use */ 2 20 2 pad1 bit (27) unaligned, 2 21 2 itp_mod bit (6) unaligned, /* should be 41(8) */ 2 22 2 23 2 offset bit (18) unaligned, /* word offset from pointer register word offset */ 2 24 2 pad2 bit (3) unaligned, 2 25 2 bit_offset bit (6) unaligned, /* bit offset relative to new word offset */ 2 26 2 pad3 bit (3) unaligned, 2 27 2 mod bit (6) unaligned; /* further modification */ 2 28 2 29 2 30 dcl 1 its_unsigned based aligned, /* just like its, but with unsigned binary */ 2 31 2 pad1 bit (3) unaligned, 2 32 2 segno fixed bin (15) unsigned unaligned, 2 33 2 ringno fixed bin (3) unsigned unaligned, 2 34 2 pad2 bit (9) unaligned, 2 35 2 its_mod bit (6) unaligned, 2 36 2 37 2 offset fixed bin (18) unsigned unaligned, 2 38 2 pad3 bit (3) unaligned, 2 39 2 bit_offset fixed bin (6) unsigned unaligned, 2 40 2 pad4 bit (3) unaligned, 2 41 2 mod bit (6) unaligned; 2 42 2 43 dcl 1 itp_unsigned based aligned, /* just like itp, but with unsigned binary where appropriate */ 2 44 2 pr_no fixed bin (3) unsigned unaligned, 2 45 2 pad1 bit (27) unaligned, 2 46 2 itp_mod bit (6) unaligned, 2 47 2 48 2 offset fixed bin (18) unsigned unaligned, 2 49 2 pad2 bit (3) unaligned, 2 50 2 bit_offset fixed bin (6) unsigned unaligned, 2 51 2 pad3 bit (3) unaligned, 2 52 2 mod bit (6) unaligned; 2 53 2 54 2 55 dcl ITS_MODIFIER bit (6) unaligned internal static options (constant) init ("43"b3); 2 56 dcl ITP_MODIFIER bit (6) unaligned internal static options (constant) init ("41"b3); 2 57 2 58 /* END INCLUDE FILE its.incl.pl1 */ 962 963 964 965 offset = fixed (rel (item_ptr), 18) - 1; 966 offset = offset * 2; 967 if addr (item_ptr) -> its.bit_offset 968 then offset = offset + 1; 969 return (offset); 970 971 end core_offset; 972 973 detach_segment: 974 proc; 975 dcl status bit (72); 976 977 call gcos_gsr_read_$gsr_read_close (INPUT, code); 978 call ios_$detach (INPUT, "", "", status); 979 980 end detach_segment; 981 982 983 984 985 print_symbol: 986 proc (print_count, offset, name); 987 988 dcl print_count fixed bin; 989 dcl offset fixed bin; 990 dcl name bit (36); 991 992 dcl i fixed bin; 993 994 do i = 1 to b.num_segs while (offset >= b.segs (i).offset); 995 end; 996 i = i - 1; 997 998 if mod (print_count, 4) = 0 999 then call ioa_$ioa_switch_nnl (b.list_ptr, "^/ "); 1000 call ioa_$ioa_switch_nnl (b.list_ptr, "^6a ^25a", ascii (name), b.segs (i).seg_name); 1001 print_count = print_count + 1; 1002 1003 end print_symbol; 1004 1005 abort: 1006 proc (code, message); 1007 1008 dcl code fixed bin (35); 1009 dcl message char (*); 1010 1011 fatal_error = "1"b; 1012 call com_err_ (code, "bind_fnp", message); 1013 call detach_segment; 1014 goto RETURN; 1015 1016 end abort; 1017 1018 1019 1020 1021 print: 1022 proc (); 1023 1024 fatal_error = "1"b; 1025 if b.list 1026 then do; 1027 if ^b.error_header 1028 then do; 1029 b.error_header = "1"b; 1030 call ioa_$ioa_switch (b.list_ptr, "ERROR MESSAGES^/"); 1031 end; 1032 call ioa_$ioa_switch (b.list_ptr, substr (message, 1, message_len)); 1033 end; 1034 call ioa_$ioa_switch (iox_$error_output, "bind_fnp: ^a", substr (message, 1, message_len)); 1035 1036 end print; 1037 1038 /* This shell sort is taken from Knuth, The Art of Computer Probramming, Volume 3, "Sorting and Searching", via Tom Casey 1039**/ 1040 1041 1042 shell_sort: 1043 proc (array, len); 1044 1045 dcl 1 array (*) aligned like bind_fnp_info.def; 1046 dcl len fixed bin; /* number of defs */ 1047 dcl (incr, next_incr) fixed bin; 1048 1049 incr = 4; 1050 next_incr = 13; 1051 do while (next_incr < len); 1052 incr = next_incr; 1053 next_incr = 3 * next_incr + 1; 1054 end; 1055 1056 do while (incr > 1); 1057 incr = divide (incr - 1, 3, 17, 0); 1058 call insertion_sort (array, len, incr); 1059 end; 1060 1061 return; 1062 1063 1064 1065 1066 insertion_sort: 1067 proc (array, len, h); 1068 1069 dcl 1 array (*) aligned like bind_fnp_info.def; 1070 dcl (len, h, i, j) fixed bin; 1071 dcl 1 temp aligned like bind_fnp_info.def; 1072 1073 do j = h + 1 to len; 1074 temp = array (j); 1075 if fixed (temp.name, 36, 0) < fixed (array (j - h).name, 36, 0) 1076 then do; 1077 do i = j - h repeat i - h while (i > 0 & fixed (temp.name, 36, 0) < fixed (array (i).name, 36, 0)); 1078 array (i + h) = array (i); 1079 end; 1080 array (i + h) = temp; 1081 end; 1082 end; 1083 1084 end insertion_sort; 1085 1086 end shell_sort; 1087 1088 end bind_fnp_load_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/15/82 1449.8 bind_fnp_load_.pl1 >dumps>old>recomp>bind_fnp_load_.pl1 161 1 06/19/81 2115.0 bind_fnp_info.incl.pl1 >ldd>include>bind_fnp_info.incl.pl1 962 2 11/26/79 1320.6 its.incl.pl1 >ldd>include>its.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. BIN_CARD constant bit(3) initial unaligned dcl 394 ref 433 CHAIN_ID constant bit(12) initial unaligned dcl 395 ref 442 442 FIRST_HSLA_CH constant fixed bin(17,0) initial dcl 871 ref 917 918 919 920 FIRST_LSLA_CH constant fixed bin(17,0) initial dcl 871 ref 925 926 927 928 929 INPUT 000006 constant char(8) initial unaligned dcl 156 set ref 319* 324* 327* 403* 412* 614* 977* 978* LOAD_BASE constant fixed bin(17,0) initial dcl 158 ref 943 LOAD_MOD 000000 constant fixed bin(17,0) initial array dcl 401 ref 422 422 LOW_CORE_SIZE constant fixed bin(17,0) initial dcl 159 ref 943 MAX_HSLA constant fixed bin(17,0) initial dcl 561 ref 567 MAX_LSLA constant fixed bin(17,0) initial dcl 560 ref 565 METER_ID constant bit(6) initial unaligned dcl 399 ref 466 466 NOP 007620 constant bit(18) initial unaligned dcl 837 ref 847 REL_CARD 007622 constant bit(12) initial unaligned dcl 591 ref 659 TRACE constant fixed bin(17,0) initial dcl 157 ref 891 TRACE_ID constant bit(6) initial unaligned dcl 397 ref 458 458 TRA_OPCODE 007621 constant bit(6) initial unaligned dcl 836 ref 841 addr builtin function dcl 64 ref 163 163 164 164 213 213 294 294 294 294 320 325 327 328 333 333 619 619 620 623 623 624 711 712 715 880 880 884 884 920 920 929 929 936 937 937 938 967 address based bit level 2 in structure "sym_ref" packed unaligned dcl 692 in procedure "load" ref 715 address 000100 automatic fixed bin(17,0) dcl 33 in procedure "bind_fnp_load_" set ref 201* 202 204 213* 215 array parameter structure array level 1 dcl 1045 in procedure "shell_sort" set ref 1042 1058* array parameter structure array level 1 dcl 1069 in procedure "insertion_sort" set ref 1066 1074 1078* 1078 1080* b based structure level 1 dcl 68 base_rel_offset 0(18) based fixed bin(17,0) level 2 packed unaligned dcl 652 ref 663 bin builtin function dcl 64 ref 772 binary based structure level 1 dcl 362 bind_fnp_info based structure level 1 dcl 1-7 bind_fnp_ptr parameter pointer dcl 28 ref 12 40 163 163 163 163 163 163 163 163 163 163 164 164 170 171 177 182 184 188 188 188 199 200 201 204 206 210 211 213 213 215 216 221 223 224 227 229 232 232 232 237 239 240 240 240 242 244 245 245 245 245 245 245 245 245 253 255 257 259 260 260 260 260 260 260 263 264 266 268 271 274 318 319 322 322 333 405 408 415 415 426 428 429 447 452 461 469 474 480 485 493 500 502 502 502 502 508 509 510 512 517 517 528 536 536 563 563 565 565 567 567 635 699 717 721 725 728 729 731 733 736 742 746 772 775 785 785 791 800 805 807 818 818 841 843 847 876 877 877 878 880 880 880 880 880 880 880 881 881 882 882 884 884 884 884 884 884 884 885 885 886 886 887 887 888 888 889 890 891 891 892 892 894 895 903 903 903 903 905 905 905 905 907 907 907 908 910 910 910 910 910 910 910 910 910 914 914 914 916 917 917 917 918 918 918 919 919 919 920 920 920 920 920 920 920 920 920 920 920 924 925 925 925 926 926 926 927 927 927 928 928 928 929 929 929 929 929 929 929 929 929 929 929 929 929 936 937 937 938 946 947 947 994 994 998 1000 1000 1025 1027 1029 1030 1032 bit builtin function dcl 64 ref 452 bit_offset 1(21) based bit(6) level 2 packed unaligned dcl 2-5 ref 967 bit_string parameter bit unaligned dcl 289 set ref 286 293 294 294 buffer_page_table_entry 345 based fixed bin(17,0) level 3 packed unaligned dcl 72 set ref 882* card_id 000101 automatic bit(12) unaligned dcl 34 set ref 403* 412* 614* card_len 000102 automatic fixed bin(17,0) dcl 35 set ref 403* 412* 614* card_ptr 000104 automatic pointer dcl 36 set ref 403* 407 407 407 407 408 408 408 412* 421 423 424 433 435 440 442 452 453 458 461 466 469 474 480 485 490 498 508 510 524 614* 617* 619 619 620 699 703 709 742 chain_links 000106 automatic fixed bin(17,0) dcl 37 set ref 410* 444* 444 445 447* 526 769 char_string 000376 automatic char(80) unaligned dcl 290 set ref 294 294 296 cleanup 000344 stack reference condition dcl 63 ref 168 clock_ 000010 constant entry external dcl 136 ref 876 cnt 000450 automatic fixed bin(17,0) dcl 356 in procedure "preface_cards" set ref 410* 523* 523 524 cnt 000343 automatic fixed bin(17,0) dcl 61 in procedure "bind_fnp_load_" set ref 197* 206 210* code based fixed bin(35,0) dcl 316 in procedure "get_segment" set ref 320 325 327* 328 333 333* code 000107 automatic fixed bin(35,0) dcl 38 in procedure "bind_fnp_load_" set ref 403* 412* 413 417* 614* 977* code parameter fixed bin(35,0) dcl 1008 in procedure "abort" set ref 1005 1012* com_err_ 000034 constant entry external dcl 146 ref 1012 console 16(02) based bit(1) level 3 packed unaligned dcl 68 ref 903 copyright_notice 371 based char(28) level 3 packed unaligned dcl 72 set ref 895* core based structure level 1 dcl 69 core_fragment based structure level 1 dcl 129 core_image based structure level 1 packed unaligned dcl 72 core_len 000110 automatic fixed bin(17,0) dcl 39 set ref 163* 422 422 634 637* 663* 699 728 746 749* 749 935* 935 935 936 937 937 937 938 939* 939 943 946 core_loc 30535 based fixed bin(17,0) array level 3 dcl 68 set ref 199 728* count based fixed bin(35,0) level 2 packed unaligned dcl 72 set ref 947* cpu_page_table 341(18) based fixed bin(17,0) level 3 packed unaligned dcl 72 set ref 880* 881 882 cpu_page_table_entry 342 based fixed bin(17,0) level 3 packed unaligned dcl 72 set ref 881* crash_loc 400 based fixed bin(17,0) level 3 packed unaligned dcl 72 set ref 213 213 889* crash_op 400(18) based bit(18) level 3 packed unaligned dcl 72 set ref 890* cross_ref 16(05) based bit(1) level 3 packed unaligned dcl 68 ref 253 date 753 based char(15) array level 3 dcl 68 set ref 245* 408* date_time_ 000012 constant entry external dcl 137 ref 239 date_time_loaded 321 based fixed bin(71,0) level 3 packed unaligned dcl 72 set ref 239 876* day 13(12) based bit(12) level 2 packed unaligned dcl 380 set ref 408* def 14445 based structure array level 2 in structure "b" dcl 68 in procedure "bind_fnp_load_" set ref 40 223* def 14445 based structure array level 2 in structure "bind_fnp_info" dcl 1-7 in procedure "bind_fnp_load_" def_module 14447 based fixed bin(17,0) array level 3 dcl 68 set ref 259 502 509* def_used 000111 automatic bit unaligned dcl 40 set ref 165* 182 188 513* 732* device_number based bit(3) array level 4 packed unaligned dcl 72 set ref 919* 927* device_speed based bit(4) array level 4 packed unaligned dcl 72 set ref 928* device_type based fixed bin(4,0) array level 4 packed unaligned dcl 72 set ref 903* 905* 907* 910* 910* 910* 914* 918* 926* dir_found 757 based char(168) array level 3 dcl 68 set ref 245* 322* 415* 517* 536* directory 63 based varying char(168) array level 2 dcl 68 ref 319 322 333 divide builtin function dcl 64 ref 293 407 435 946 1057 end 0(18) based fixed bin(17,0) level 2 packed unaligned dcl 862 set ref 937* entry 23 based char(8) level 2 dcl 68 ref 510 entry_offset 000111 automatic fixed bin(17,0) dcl 41 set ref 512* 938 eof 000112 automatic bit(1) unaligned dcl 42 set ref 403* 412* 613 614* 615 error_header 16(03) based bit(1) level 3 packed unaligned dcl 68 set ref 1027 1029* error_table_$noentry 000014 external static fixed bin(35,0) dcl 138 set ref 333 337* extra based structure level 1 packed unaligned dcl 652 in procedure "setup_block" extra based bit(18) array level 2 in structure "core_fragment" packed unaligned dcl 129 in procedure "bind_fnp_load_" set ref 635* extra based structure level 1 packed unaligned dcl 605 in procedure "relocate_text" extra_len 000113 automatic fixed bin(17,0) dcl 43 set ref 634* 635 635 fatal_error parameter bit(1) unaligned dcl 29 set ref 12 1011* 1024* fixed builtin function dcl 64 ref 163 163 215 421 423 424 435 524 662 702 711 880 880 884 884 903 905 907 910 910 910 914 917 918 919 920 920 920 925 926 927 928 929 929 929 965 1075 1075 1077 1077 flags 16 based structure level 2 dcl 68 gcos_cv_gebcd_ascii_ 000036 constant entry external dcl 147 ref 294 gcos_gsr_read_ 000042 constant entry external dcl 149 ref 403 412 614 gcos_gsr_read_$gsr_read_close 000044 constant entry external dcl 150 ref 977 gcos_gsr_read_$gsr_read_init 000040 constant entry external dcl 148 ref 327 get_group_id_ 000046 constant entry external dcl 151 ref 240 240 get_wdir_ 000050 constant entry external dcl 152 ref 240 240 h parameter fixed bin(17,0) dcl 1070 in procedure "insertion_sort" ref 1066 1073 1075 1077 1078 1079 1080 h based structure level 1 dcl 380 in procedure "preface_cards" hbound builtin function dcl 64 ref 40 header 1 based structure level 2 packed unaligned dcl 72 hsla_table based bit level 3 packed unaligned dcl 72 set ref 920 920 i 000624 automatic fixed bin(17,0) dcl 1070 in procedure "insertion_sort" set ref 1077* 1077 1077* 1078 1078* 1079 1080 i 000432 automatic fixed bin(17,0) dcl 314 in procedure "get_segment" set ref 318* 319 322 333* i 000514 automatic fixed bin(17,0) dcl 686 in procedure "load" set ref 698* 699 699 702 703 709 742* i 000554 automatic fixed bin(35,0) dcl 860 in procedure "set_load_info" set ref 916* 917 918 919 919 920 920 920* 924* 925 926 927 927 928 929 929 929* i 000464 automatic fixed bin(17,0) dcl 556 in procedure "special_module" set ref 563* 563* 565 567 i 000474 automatic fixed bin(17,0) dcl 585 in procedure "relocate_text" set ref 621* 622* 623* 625* 625 840* 841 843 847* i 000446 automatic fixed bin(17,0) dcl 355 in procedure "preface_cards" set ref 408* 421* 422 422 436* 440 442 452 453 458 461 466 469 474 480 485 490 498 508 510* i 000576 automatic fixed bin(17,0) dcl 992 in procedure "print_symbol" set ref 994* 994* 996* 996 1000 i 000340 automatic fixed bin(17,0) dcl 61 in procedure "bind_fnp_load_" set ref 187* 188 188 188 188* 198* 199 200* 226* 227 232 232* 244* 245 245 245 245 245 245 245* 256* 257 259 260 260 260 264* id based bit(12) level 2 in structure "extra" packed unaligned dcl 652 in procedure "setup_block" ref 659 id 0(21) based bit level 2 in structure "sym_ref" packed unaligned dcl 692 in procedure "load" set ref 711 712* id_1 based bit(3) level 3 packed unaligned dcl 362 ref 433 incr 000614 automatic fixed bin(17,0) dcl 1047 set ref 1049* 1052* 1056 1057* 1057 1058* index_def 30536 based fixed bin(17,0) array level 3 dcl 68 set ref 200 729* index_rel parameter fixed bin(17,0) dcl 683 ref 680 699 703 709 742 input_attached 000114 automatic bit(1) unaligned dcl 44 set ref 165* 323* instr 1 based bit(18) array level 2 in structure "extra" packed unaligned dcl 605 in procedure "relocate_text" set ref 623 623 instr based bit(18) array unaligned dcl 691 in procedure "load" ref 699 702 instr 4(18) based bit(18) array level 2 in structure "text" packed unaligned dcl 596 in procedure "relocate_text" set ref 619 619 ioa_$ioa_switch 000016 constant entry external dcl 139 ref 184 206 224 229 240 242 245 255 260 268 274 1030 1032 1034 ioa_$ioa_switch_nnl 000020 constant entry external dcl 140 ref 232 998 1000 ioa_$rsnnl 000022 constant entry external dcl 141 ref 408 415 447 474 502 517 528 536 717 736 742 775 785 800 843 iom_channel based structure array level 3 packed unaligned dcl 72 set ref 884 884 iom_table 326(18) based fixed bin(17,0) level 3 packed unaligned dcl 72 set ref 884* ios_$attach 000024 constant entry external dcl 142 ref 319 ios_$detach 000026 constant entry external dcl 143 ref 978 ios_$setsize 000030 constant entry external dcl 144 ref 324 iox_$error_output 000032 external static pointer dcl 145 set ref 1034* iseg 000115 automatic fixed bin(17,0) dcl 45 set ref 170* 171* 322 408 415 415 428 429 447 474 502 509 517 517 528 536 536 563 717 733 736 742 775 785 791 792 800 843 item_ptr parameter pointer dcl 959 set ref 956 965 967 its based structure level 1 dcl 2-5 j 000625 automatic fixed bin(17,0) dcl 1070 in procedure "insertion_sort" set ref 1073* 1074 1075 1077* j 000515 automatic fixed bin(17,0) dcl 686 in procedure "load" set ref 711* 713 713 721* 721 725 729 731 732 733 736* j 000341 automatic fixed bin(17,0) dcl 61 in procedure "bind_fnp_load_" set ref 186* 188* 199* 210* 215 216 263* 264 266 271* j 000447 automatic fixed bin(17,0) dcl 355 in procedure "preface_cards" set ref 480* 480* 482 485 493 500 502 502 508 509 512 513 k 000342 automatic fixed bin(17,0) dcl 61 set ref 200* 201 210 211 259* 260 260 last_chain 000116 automatic fixed bin(17,0) dcl 46 set ref 164* 177 452 453* 772 last_loc_memory 325(18) based fixed bin(17,0) level 3 packed unaligned dcl 72 set ref 877* len parameter fixed bin(17,0) dcl 1070 in procedure "insertion_sort" ref 1066 1073 len parameter fixed bin(17,0) dcl 1046 in procedure "shell_sort" set ref 1042 1051 1058* length 1 based fixed bin(17,0) level 2 in structure "trailer" packed unaligned dcl 862 in procedure "set_load_info" set ref 937* length builtin function dcl 64 in procedure "bind_fnp_load_" ref 266 266 293 442 458 466 length 752(18) based fixed bin(17,0) array level 3 in structure "b" packed unaligned dcl 68 in procedure "bind_fnp_load_" set ref 245* 429* list 16 based bit(1) level 3 packed unaligned dcl 68 ref 182 204 221 237 405 426 1025 list_ptr 14 based pointer level 2 dcl 68 set ref 184* 206* 224* 229* 232* 240* 242* 245* 255* 260* 268* 274* 998* 1000* 1030* 1032* load_mod_code 2(18) based bit(3) level 3 packed unaligned dcl 362 ref 421 load_offset 000117 automatic fixed bin(17,0) dcl 47 set ref 410* 419 422* 428 452 453 461 469 508 633* 633 634 635 637 663 703 843 loc 1 based bit(18) array level 2 packed unaligned dcl 69 set ref 177* 215 216* 452* 699* 746* 772 841 847* 936 937 937 938 lsla_table based bit level 3 packed unaligned dcl 72 set ref 929 929 mask 60 based bit(18) level 2 dcl 68 ref 805 887 memory 22 based fixed bin(17,0) level 2 dcl 68 ref 163 163 877 878 880 880 884 884 903 905 907 908 910 910 910 914 917 918 919 920 920 920 925 926 927 928 929 929 929 message 000120 automatic char(300) unaligned dcl 48 in procedure "bind_fnp_load_" set ref 415* 417* 447* 474* 502* 517* 519* 528* 536* 538* 717* 736* 742* 775* 785* 800* 843* 1032 1032 1034 1034 message parameter char unaligned dcl 1009 in procedure "abort" set ref 1005 1012* message_len 000233 automatic fixed bin(17,0) dcl 49 set ref 415* 447* 474* 502* 517* 528* 536* 717* 736* 742* 775* 785* 800* 843* 1032 1032 1034 1034 meter_flag 343 based fixed bin(17,0) level 3 packed unaligned dcl 72 set ref 892* 894* meter_offset 30371 based fixed bin(17,0) array level 2 dcl 68 set ref 469* 818* metering_enabled 16(06) based bit(1) level 3 packed unaligned dcl 68 ref 818 892 mod builtin function dcl 64 ref 229 422 935 998 modnum 1031 based fixed bin(17,0) array level 3 dcl 68 set ref 245 245* 791* module 25 based structure array level 2 dcl 68 module_chain 330(18) based fixed bin(17,0) level 3 packed unaligned dcl 72 set ref 164 164 module_num 000526 automatic fixed bin(17,0) dcl 766 set ref 772* 773 773 775* 781 783 785* 785 791 792 798 805 module_nums_used 000234 automatic fixed bin(17,0) array dcl 50 set ref 167* 242 783 785 792* month 13 based bit(12) level 2 packed unaligned dcl 380 set ref 408* multiple_channel based bit(1) array level 4 packed unaligned dcl 72 set ref 917* 925* name parameter bit(36) unaligned dcl 990 in procedure "print_symbol" set ref 985 1000* name 25 based varying char(25) array level 3 in structure "b" dcl 68 in procedure "bind_fnp_load_" ref 563 name parameter varying char dcl 310 in procedure "get_segment" ref 307 319 333 337 name 000626 automatic bit(36) level 2 in structure "temp" packed unaligned dcl 1071 in procedure "insertion_sort" set ref 1075 1077 name 3 based bit(36) array level 3 in structure "binary" dcl 362 in procedure "preface_cards" ref 442 458 466 474 480 485 510 name 14445 based bit(36) array level 3 in structure "b" packed unaligned dcl 68 in procedure "bind_fnp_load_" set ref 188* 210* 232* 260* 480 485* 502* name parameter bit(36) array level 2 in structure "array" packed unaligned dcl 1069 in procedure "insertion_sort" set ref 1075 1077 next_block based bit(18) level 2 in structure "extra" packed unaligned dcl 605 in procedure "relocate_text" set ref 624 next_block based bit(18) level 2 in structure "text" packed unaligned dcl 596 in procedure "relocate_text" set ref 620 next_incr 000615 automatic fixed bin(17,0) dcl 1047 set ref 1050* 1051 1052 1053* 1053 num 0(12) based bit(6) level 2 packed unaligned dcl 652 ref 662 num_chars 000422 automatic fixed bin(17,0) dcl 291 set ref 293* 294* 296 num_defs 000256 automatic fixed bin(17,0) dcl 51 set ref 166* 182 187 223* 226 256 480 482 484* 484 num_directories 62 based fixed bin(17,0) level 2 dcl 68 ref 318 num_hsla 327 based fixed bin(17,0) level 3 in structure "core_image" packed unaligned dcl 72 in procedure "bind_fnp_load_" set ref 885* num_hsla 20 based fixed bin(17,0) level 2 in structure "b" dcl 68 in procedure "bind_fnp_load_" ref 163 163 163 163 567 880 880 884 884 885 903 905 907 910 910 910 914 916 917 918 919 920 920 920 920 920 925 926 927 928 929 929 929 929 929 num_instr 000475 automatic fixed bin(17,0) dcl 586 set ref 620 621 624 625 662* 698 num_instr_loaded parameter fixed bin(17,0) dcl 649 ref 646 659 num_lsla 327(18) based fixed bin(17,0) level 3 in structure "core_image" packed unaligned dcl 72 in procedure "bind_fnp_load_" set ref 886* num_lsla 21 based fixed bin(17,0) level 2 in structure "b" dcl 68 in procedure "bind_fnp_load_" ref 163 163 565 886 924 929 929 num_meter_defs 000261 automatic fixed bin(17,0) dcl 54 set ref 410* 468* 468 469 818 818* num_refs 000257 automatic fixed bin(17,0) dcl 52 set ref 410* 492* 492 493 713 num_segs 61 based fixed bin(17,0) level 2 dcl 68 ref 170 244 263 994 num_symbols 000452 automatic fixed bin(17,0) dcl 358 set ref 435* 436 523 num_symbols_2 2(21) based bit(15) level 3 packed unaligned dcl 362 ref 524 num_trace_defs 000260 automatic fixed bin(17,0) dcl 53 set ref 410* 460* 460 461 795 807* num_unresolved 000352 automatic fixed bin(17,0) dcl 1-51 set ref 166* 198 727* 727 728 729 obj_date 000262 automatic char(32) unaligned dcl 55 set ref 239* 240* obj_len 10 based fixed bin(17,0) level 2 dcl 68 set ref 946* 947 obj_name based char(32) level 2 dcl 68 set ref 240* obj_ptr 12 based pointer level 2 dcl 68 ref 163 163 164 164 177 213 213 215 216 239 452 635 699 746 772 841 847 876 877 880 880 880 881 881 882 882 884 884 884 885 886 887 888 889 890 891 892 894 895 903 905 907 910 910 910 914 917 918 919 920 920 920 925 926 927 928 929 929 929 936 937 937 938 947 offset 000566 automatic fixed bin(17,0) unaligned dcl 960 in procedure "core_offset" set ref 965* 966* 966 967* 967 969 offset 752 based fixed bin(17,0) array level 3 in structure "b" packed unaligned dcl 68 in procedure "bind_fnp_load_" set ref 245* 260 428* 994 offset 4 based fixed bin(17,0) array level 3 in structure "binary" packed unaligned dcl 362 in procedure "preface_cards" ref 452 453 461 469 508 offset 14446 based fixed bin(17,0) array level 3 in structure "b" dcl 68 in procedure "bind_fnp_load_" set ref 188 188* 201 211* 227 232* 257 260* 260 500 508* 512 725 731 offset parameter fixed bin(17,0) dcl 989 in procedure "print_symbol" ref 985 994 offset based fixed bin(17,0) array level 4 in structure "core_image" packed unaligned dcl 72 in procedure "bind_fnp_load_" set ref 920* 929* offset_array parameter fixed bin(17,0) array dcl 833 ref 825 841 843 847 one_hr 12(06) based fixed bin(5,0) level 2 packed unaligned dcl 380 ref 407 one_min 12(24) based fixed bin(5,0) level 2 packed unaligned dcl 380 ref 407 p parameter pointer dcl 684 in procedure "load" ref 680 699 702 p parameter pointer dcl 650 in procedure "setup_block" ref 646 659 662 663 p 000476 automatic pointer dcl 587 in procedure "relocate_text" set ref 620* 622* 623 623 624* 624 p_num_defs parameter fixed bin(17,0) dcl 832 ref 825 840 page_table based bit level 3 packed unaligned dcl 72 set ref 880 880 preface_len 0(12) based bit(6) level 3 packed unaligned dcl 362 ref 435 print_count 000272 automatic fixed bin(17,0) dcl 56 in procedure "bind_fnp_load_" set ref 225* 229 231* 231 print_count parameter fixed bin(17,0) dcl 988 in procedure "print_symbol" set ref 985 998 1001* 1001 printer 16(01) based bit(1) level 3 packed unaligned dcl 68 ref 905 ref 14045 based fixed bin(17,0) array level 2 dcl 68 set ref 493* 721 ref_modules 14450 based bit(108) array level 3 packed unaligned dcl 68 set ref 264 733* reflist 000275 automatic varying char(130) dcl 59 set ref 262* 266 268* 269* 271* 271 274 274* rel builtin function dcl 64 ref 965 reloc 2 based bit(2) array level 2 packed unaligned dcl 596 set ref 699 703 709 742* seg_name 741 based varying char(32) array level 3 dcl 68 set ref 171* 245* 260* 266 271 415* 447* 474* 502* 502* 517* 528* 536* 563 717* 736* 742* 775* 785* 785* 800* 843* 1000* segs 741 based structure array level 2 dcl 68 size 35 based fixed bin(17,0) array level 3 dcl 68 ref 565 567 891 start based fixed bin(17,0) level 2 packed unaligned dcl 862 set ref 936* start_entry 1(18) based fixed bin(17,0) level 2 packed unaligned dcl 862 set ref 938* start_load based fixed bin(17,0) level 3 packed unaligned dcl 72 set ref 163 163 status 000100 automatic bit(72) unaligned dcl 975 in procedure "detach_segment" set ref 978* status 000434 automatic bit(72) unaligned dcl 315 in procedure "get_segment" set ref 319* 320 324* 325 327 328 333 333 substr builtin function dcl 64 set ref 182 188 216 264 296 442 458 466 513* 732* 733* 746 805 841 880 880 919 920 920 927 929 929 1032 1032 1034 1034 sym_field_len 000273 automatic fixed bin(17,0) dcl 57 set ref 424* 711 712 715 715 sym_ref based structure level 1 packed unaligned dcl 692 sym_ref_field 0(03) based bit(6) level 3 packed unaligned dcl 362 ref 424 symbol 3 based structure array level 2 dcl 362 symbol_code 4(33) based bit(3) array level 3 packed unaligned dcl 362 ref 440 490 498 temp 000626 automatic structure level 1 dcl 1071 set ref 1074* 1080 ten_hr 12 based fixed bin(5,0) level 2 packed unaligned dcl 380 ref 407 ten_min 12(18) based fixed bin(5,0) level 2 packed unaligned dcl 380 ref 407 text based structure level 1 packed unaligned dcl 596 text_len 0(18) based bit(18) level 3 in structure "binary" packed unaligned dcl 362 in procedure "preface_cards" ref 423 text_len parameter fixed bin(17,0) dcl 554 in procedure "special_module" set ref 551 565* 565 567* 567 text_size 000274 automatic fixed bin(17,0) dcl 58 set ref 423* 425* 429 633 time 000451 automatic fixed bin(17,0) dcl 357 set ref 407* 408* trace_mask 331(18) based bit(18) level 3 packed unaligned dcl 72 set ref 887* trace_offset 30225 based fixed bin(17,0) array level 2 dcl 68 set ref 461* 807* trace_size 342(18) based fixed bin(17,0) level 3 packed unaligned dcl 72 set ref 891* trailer based structure level 1 packed unaligned dcl 862 type_name parameter char unaligned dcl 834 set ref 825 843* unresolved 30535 based structure array level 2 dcl 68 unspec builtin function dcl 64 set ref 216 242 635* 746 919 927 version 335 based char(4) level 3 in structure "core_image" packed unaligned dcl 72 in procedure "bind_fnp_load_" set ref 888* version 17 based char(4) level 2 in structure "b" dcl 68 in procedure "bind_fnp_load_" set ref 240* 888 word 000516 automatic fixed bin(35,0) dcl 687 in procedure "load" set ref 702* 703* 703 711 712 715 731* 731 746 word 000337 automatic fixed bin(35,0) dcl 60 in procedure "bind_fnp_load_" set ref 215* 216 word_1 based structure level 2 dcl 362 word_3 2 based structure level 2 dcl 362 year 13(24) based bit(12) level 2 packed unaligned dcl 380 set ref 408* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ITP_MODIFIER internal static bit(6) initial unaligned dcl 2-56 ITS_MODIFIER internal static bit(6) initial unaligned dcl 2-55 MCS_BCD internal static bit(36) initial unaligned dcl 868 i automatic fixed bin(17,0) dcl 765 itp based structure level 1 dcl 2-18 itp_unsigned based structure level 1 dcl 2-43 its_unsigned based structure level 1 dcl 2-30 NAMES DECLARED BY EXPLICIT CONTEXT. RETURN 002360 constant label dcl 280 ref 1014 abort 007071 constant entry internal dcl 1005 ref 333 337 417 519 538 943 ascii 002361 constant entry internal dcl 286 ref 232 260 408 408 408 474 502 510 1000 bind_fnp_load_ 000710 constant entry external dcl 12 core_offset 006627 constant entry internal dcl 956 ref 163 164 213 880 884 920 929 detach_segment 006663 constant entry internal dcl 973 ref 168 174 1013 get_segment 002427 constant entry internal dcl 307 ref 171 insertion_sort 007347 constant entry internal dcl 1066 ref 1058 load 004633 constant entry internal dcl 680 ref 619 623 patch_defs 005501 constant entry internal dcl 825 ref 807 818 preface_cards 003001 constant entry internal dcl 350 ref 172 print 007146 constant entry internal dcl 1021 ref 449 476 505 530 719 738 744 777 787 802 845 print_symbol 006732 constant entry internal dcl 985 ref 188 210 process_meter_defs 005445 constant entry internal dcl 811 ref 632 process_trace_defs 005203 constant entry internal dcl 762 ref 631 relocate_text 004421 constant entry internal dcl 582 ref 173 set_load_info 005631 constant entry internal dcl 857 ref 178 setup_block 004571 constant entry internal dcl 646 ref 617 622 shell_sort 007275 constant entry internal dcl 1042 ref 223 special_module 004336 constant entry internal dcl 551 ref 425 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 10074 10146 7641 10104 Length 10422 7641 52 237 232 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME bind_fnp_load_ 1121 external procedure is an external procedure. on unit on line 168 64 on unit ascii internal procedure shares stack frame of external procedure bind_fnp_load_. get_segment internal procedure shares stack frame of external procedure bind_fnp_load_. preface_cards internal procedure shares stack frame of external procedure bind_fnp_load_. special_module internal procedure shares stack frame of external procedure bind_fnp_load_. relocate_text internal procedure shares stack frame of external procedure bind_fnp_load_. setup_block internal procedure shares stack frame of external procedure bind_fnp_load_. load internal procedure shares stack frame of external procedure bind_fnp_load_. process_trace_defs internal procedure shares stack frame of external procedure bind_fnp_load_. process_meter_defs internal procedure shares stack frame of external procedure bind_fnp_load_. patch_defs internal procedure shares stack frame of external procedure bind_fnp_load_. set_load_info internal procedure shares stack frame of external procedure bind_fnp_load_. core_offset internal procedure shares stack frame of external procedure bind_fnp_load_. detach_segment 96 internal procedure is called by several nonquick procedures. print_symbol internal procedure shares stack frame of external procedure bind_fnp_load_. abort 82 internal procedure is called during a stack extension. print internal procedure shares stack frame of external procedure bind_fnp_load_. shell_sort internal procedure shares stack frame of external procedure bind_fnp_load_. insertion_sort internal procedure shares stack frame of external procedure bind_fnp_load_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME bind_fnp_load_ 000100 address bind_fnp_load_ 000101 card_id bind_fnp_load_ 000102 card_len bind_fnp_load_ 000104 card_ptr bind_fnp_load_ 000106 chain_links bind_fnp_load_ 000107 code bind_fnp_load_ 000110 core_len bind_fnp_load_ 000111 def_used bind_fnp_load_ 000111 entry_offset bind_fnp_load_ 000112 eof bind_fnp_load_ 000113 extra_len bind_fnp_load_ 000114 input_attached bind_fnp_load_ 000115 iseg bind_fnp_load_ 000116 last_chain bind_fnp_load_ 000117 load_offset bind_fnp_load_ 000120 message bind_fnp_load_ 000233 message_len bind_fnp_load_ 000234 module_nums_used bind_fnp_load_ 000256 num_defs bind_fnp_load_ 000257 num_refs bind_fnp_load_ 000260 num_trace_defs bind_fnp_load_ 000261 num_meter_defs bind_fnp_load_ 000262 obj_date bind_fnp_load_ 000272 print_count bind_fnp_load_ 000273 sym_field_len bind_fnp_load_ 000274 text_size bind_fnp_load_ 000275 reflist bind_fnp_load_ 000337 word bind_fnp_load_ 000340 i bind_fnp_load_ 000341 j bind_fnp_load_ 000342 k bind_fnp_load_ 000343 cnt bind_fnp_load_ 000352 num_unresolved bind_fnp_load_ 000376 char_string ascii 000422 num_chars ascii 000432 i get_segment 000434 status get_segment 000446 i preface_cards 000447 j preface_cards 000450 cnt preface_cards 000451 time preface_cards 000452 num_symbols preface_cards 000464 i special_module 000474 i relocate_text 000475 num_instr relocate_text 000476 p relocate_text 000514 i load 000515 j load 000516 word load 000526 module_num process_trace_defs 000554 i set_load_info 000566 offset core_offset 000576 i print_symbol 000614 incr shell_sort 000615 next_incr shell_sort 000624 i insertion_sort 000625 j insertion_sort 000626 temp insertion_sort detach_segment 000100 status detach_segment THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as r_ge_a alloc_cs alloc_bs cat_realloc_cs call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other return bs_to_fx2 tra_ext alloc_auto_adj mpfx2 mod_fx1 enable shorten_stack ext_entry int_entry int_entry_desc set_bs_eis divide_fx3 THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. clock_ com_err_ date_time_ gcos_cv_gebcd_ascii_ gcos_gsr_read_ gcos_gsr_read_$gsr_read_close gcos_gsr_read_$gsr_read_init get_group_id_ get_wdir_ ioa_$ioa_switch ioa_$ioa_switch_nnl ioa_$rsnnl ios_$attach ios_$detach ios_$setsize THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$noentry iox_$error_output LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 12 000704 40 000715 163 000724 164 000763 165 000775 166 001005 167 001007 168 001017 170 001041 171 001053 172 001067 173 001070 174 001071 175 001075 177 001077 178 001110 182 001111 184 001130 186 001151 187 001152 188 001161 190 001211 197 001213 198 001214 199 001223 200 001232 201 001234 202 001237 204 001240 206 001245 210 001267 211 001306 213 001316 215 001325 216 001345 217 001351 221 001353 223 001361 224 001375 225 001420 226 001421 227 001430 229 001436 231 001457 232 001460 234 001542 237 001544 239 001552 240 001576 242 001664 244 001720 245 001732 248 002017 253 002021 255 002027 256 002047 257 002056 259 002065 260 002070 262 002170 263 002171 264 002203 266 002220 268 002230 269 002253 271 002254 272 002320 273 002321 274 002323 277 002356 280 002360 286 002361 293 002372 294 002374 296 002414 307 002427 318 002440 319 002452 320 002560 322 002565 323 002601 324 002603 325 002626 327 002630 328 002645 331 002650 333 002651 335 002737 337 002742 339 002777 350 003001 403 003002 405 003037 407 003045 408 003075 410 003220 412 003226 413 003263 415 003265 417 003326 419 003342 421 003344 422 003351 423 003362 424 003365 425 003372 426 003374 428 003402 429 003411 433 003414 435 003420 436 003435 440 003443 442 003452 444 003456 445 003457 447 003462 449 003522 452 003523 453 003553 454 003556 458 003557 460 003565 461 003566 462 003576 466 003577 468 003601 469 003602 470 003612 474 003613 476 003661 478 003662 480 003663 481 003706 482 003710 484 003713 485 003714 490 003726 492 003736 493 003737 494 003745 498 003746 500 003750 502 003760 505 004046 508 004047 509 004065 510 004067 512 004104 513 004112 515 004117 517 004120 519 004161 522 004176 523 004200 524 004202 526 004214 528 004216 530 004253 532 004254 534 004255 536 004256 538 004317 540 004334 542 004335 551 004336 563 004340 564 004364 565 004366 567 004404 570 004420 582 004421 613 004422 614 004425 615 004462 617 004465 619 004473 620 004503 621 004511 622 004513 623 004520 624 004525 625 004533 626 004535 629 004536 631 004537 632 004540 633 004541 634 004545 635 004550 637 004566 639 004570 646 004571 659 004573 662 004604 663 004612 664 004621 667 004626 680 004633 698 004635 699 004644 702 004676 703 004710 709 004720 711 004722 712 004731 713 004735 715 004741 717 004753 719 005010 721 005011 725 005017 727 005023 728 005024 729 005031 730 005033 731 005034 732 005040 733 005045 734 005056 736 005057 738 005117 740 005120 742 005121 744 005165 746 005166 749 005177 750 005200 751 005202 762 005203 769 005204 772 005210 773 005224 775 005230 777 005265 778 005266 781 005267 783 005271 785 005273 787 005337 788 005340 791 005341 792 005346 795 005351 798 005354 800 005356 802 005410 805 005411 807 005422 809 005444 811 005445 818 005446 821 005500 825 005501 840 005512 841 005522 843 005550 845 005620 846 005621 847 005622 848 005626 849 005630 857 005631 876 005632 877 005652 878 005662 880 005665 881 005707 882 005722 884 005735 885 005771 886 005777 887 006005 888 006010 889 006013 890 006016 891 006021 892 006030 894 006037 895 006042 903 006045 905 006066 907 006107 908 006126 910 006131 914 006150 916 006155 917 006164 918 006214 919 006222 920 006230 922 006317 924 006324 925 006336 926 006366 927 006374 928 006402 929 006410 931 006504 935 006511 936 006521 937 006531 938 006554 939 006563 943 006565 946 006611 947 006620 949 006626 956 006627 965 006631 966 006640 967 006645 969 006656 973 006662 977 006670 978 006705 980 006731 985 006732 994 006734 995 006757 996 006761 998 006763 1000 007012 1001 007065 1003 007067 1005 007070 1011 007104 1012 007112 1013 007136 1014 007143 1021 007146 1024 007147 1025 007154 1027 007161 1029 007164 1030 007166 1032 007207 1033 007236 1034 007237 1036 007273 1042 007275 1049 007301 1050 007303 1051 007305 1052 007311 1053 007312 1054 007315 1056 007316 1057 007321 1058 007324 1059 007345 1061 007346 1066 007347 1073 007353 1074 007364 1075 007403 1077 007417 1078 007446 1079 007461 1080 007464 1082 007477 1084 007501 ----------------------------------------------------------- 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