COMPILATION LISTING OF SEGMENT amu_fdump_translate_ Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Bull, Phx. Az., Sys-M Compiled on: 07/28/87 0931.4 mst Tue Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 6* * * 7* *********************************************************** */ 8 9 10 11 /****^ HISTORY COMMENTS: 12* 1) change(87-07-09,Parisek), approve(87-07-09,MCR7746), 13* audit(87-07-16,Fawcett), install(87-07-28,MR12.1-1049): 14* Correct dump segment length reference. 15* END HISTORY COMMENTS */ 16 17 18 /* Modified 02/20/86 by Paul Leatherman to make lth = lth - 1 */ 19 20 amu_fdump_translate_: proc (); 21 22 return; /* not an entrypoint */ 23 24 /* format: style4,delnl,insnl,ifthenstmt,indnoniterend,ifthendo,ifthen,^thendo */ 25 26 dcl ( 27 P_amu_info_ptr pointer, 28 P_seg_ptr pointer, 29 P_translation_ptr pointer, 30 P_seg_lth fixed bin (19), 31 P_code fixed bin (35) 32 ) parameter; 33 34 dcl (base, base_2) pointer; 35 dcl (lth, lth_2) fixed bin (19); 36 dcl segno fixed bin (15); 37 dcl temp_seg_name char (32); 38 dcl process_idx fixed bin; 39 40 dcl copy_seg_ptr pointer; 41 42 dcl 1 copy_seg aligned based (copy_seg_ptr), 43 2 part1 (lth) bit (36) aligned, 44 2 part2 (lth_2) bit (36) aligned; 45 46 dcl copy_part1 (lth) bit (36) aligned based (base); 47 dcl copy_part2 (lth_2) bit (36) aligned based (base_2); 48 49 dcl amu_et_$seg_not_dumped fixed bin (35) external; 50 dcl amu_error_ entry options (variable); 51 dcl amu_$temp_seg_get entry (pointer, char (*), pointer, pointer); 52 dcl ioa_$rsnnl entry options (variable); 53 54 dcl (addr, binary, baseno, divide, mod, null, pointer) builtin; 55 56 57 amu_fdump_translate_$get_translation: 58 entry (P_amu_info_ptr, P_seg_ptr, P_translation_ptr, P_code); 59 60 /* This entry fills in a translation for the specified pointer, without regard 61* to whether it is split across dump segment boundaries. It is used when initializing 62* the translation array for the first time. */ 63 64 call get_amu_info (); /* set up pointers and indexes */ 65 translation_ptr = P_translation_ptr; 66 segno = binary (baseno (P_seg_ptr), 15); 67 68 call locate_segment (segno, process_idx); /* sets base & lth */ 69 if base = null () then do; 70 P_code = amu_et_$seg_not_dumped; 71 return; 72 end; 73 translation.flags = "0"b; 74 translation.segno = segno; 75 translation.part1.ptr = base; 76 translation.part1.lth = lth; 77 translation.flags.in_dump = "1"b; 78 translation.part2.ptr = base_2; 79 if base_2 ^= null then do; 80 translation.part2.lth = lth_2; 81 translation.flags.two_part = "1"b; 82 end; 83 else do; 84 translation.part2.lth = 0; 85 86 end; 87 88 89 return; /* end of code for this entrypoint */ 90 91 92 93 amu_fdump_translate_$contiguous: 94 entry (P_amu_info_ptr, P_seg_ptr, P_translation_ptr, P_code); 95 96 /* This entry fills in a translation for the specified pointer, copying the segment 97* contents into a temp segment before doing so if it spans dump segment boundaries. 98* This is used the first time it is necessary to have a contiguous segment to reference. 99**/ 100 101 call get_amu_info (); /* set up pointers and indexes */ 102 translation_ptr = P_translation_ptr; 103 segno = binary (baseno (P_seg_ptr), 15); 104 105 call locate_segment (segno, process_idx); /* sets base & lth */ 106 if base = null () then do; 107 P_code = amu_et_$seg_not_dumped; 108 return; 109 end; 110 translation.flags = "0"b; 111 if base_2 = null () then do; /* already contiguous or nonexistent */ 112 translation.part1.ptr = base; 113 translation.part1.lth = lth; 114 translation.part2.ptr = null (); 115 translation.part2.lth = 0; 116 translation.segno = segno; 117 translation.flags.in_dump = "1"b; 118 return; 119 end; 120 121 call ioa_$rsnnl ("ERF ^a: seg ^o, proc ^d", temp_seg_name, (0), fdump_info.erf_name, segno, process_idx); 122 123 call amu_$temp_seg_get (amu_info_ptr, temp_seg_name, fdump_info.copy_block_ptr, copy_seg_ptr); 124 125 copy_seg.part1 = copy_part1; /* now, copy the info */ 126 copy_seg.part2 = copy_part2; 127 translation.flags = "0"b; 128 translation.part1.ptr = copy_seg_ptr; 129 translation.part1.lth = lth + lth_2; 130 translation.part2.ptr = null (); 131 translation.part2.lth = 0; 132 translation.segno = segno; 133 translation.flags.in_temp_seg = "1"b; 134 return; /* all done */ 135 136 137 amu_fdump_translate_$to_temp_seg: 138 entry (P_amu_info_ptr, P_seg_ptr, P_translation_ptr, P_code); 139 140 /* This entry will translate a seg no from the ERF to a tempseg Put in for stacks */ 141 142 143 call get_amu_info (); /* set up pointers and indexes */ 144 translation_ptr = P_translation_ptr; 145 segno = binary (baseno (P_seg_ptr), 15); 146 147 call locate_segment (segno, process_idx); /* sets base & lth */ 148 if base = null () then do; 149 P_code = amu_et_$seg_not_dumped; 150 return; 151 end; 152 153 call ioa_$rsnnl ("ERF ^a: seg ^o, proc ^d", temp_seg_name, (0), fdump_info.erf_name, segno, process_idx); 154 155 call amu_$temp_seg_get (amu_info_ptr, temp_seg_name, fdump_info.copy_block_ptr, copy_seg_ptr); 156 157 copy_seg.part1 = copy_part1; /* now, copy the info */ 158 if base_2 ^= null then copy_seg.part2 = copy_part2; 159 translation.flags = "0"b; 160 translation.part1.ptr = copy_seg_ptr; 161 translation.part1.lth = lth + lth_2; 162 translation.part2.ptr = null (); 163 translation.part2.lth = 0; 164 translation.segno = segno; 165 translation.flags.in_temp_seg = "1"b; 166 return; /* all done */ 167 168 amu_fdump_translate_$get_seg_lth: 169 entry (P_amu_info_ptr, P_seg_ptr, P_seg_lth, P_code); 170 171 /* This entrypoint returns the length of a segment in process 1. */ 172 173 call get_amu_info (); 174 175 call locate_segment (binary (baseno (P_seg_ptr), 15), 1); 176 if base = null () then do; 177 P_code = amu_et_$seg_not_dumped; 178 return; 179 end; 180 181 P_code = 0; 182 P_seg_lth = lth + lth_2; 183 184 185 return; /* all done for this entrypoint */ 186 187 188 189 get_amu_info: 190 proc (); 191 192 /* This procedure sets amu_info_ptr and process_idx, and also generates an error 193* for any attempt to use an invalid amu_info. */ 194 195 amu_info_ptr = P_amu_info_ptr; 196 197 if amu_info.type = FDUMP_TYPE then process_idx = 0; 198 else if amu_info.type = FDUMP_PROCESS_TYPE then process_idx = amu_info.process_idx; 199 else call amu_error_ (amu_info_ptr, 0, "Invalid type for FDUMP amu_info ^d.", amu_info.type); 200 201 P_code = 0; /* until something happens */ 202 203 return; 204 end get_amu_info; 205 206 207 208 locate_segment: 209 proc (P_segno, P_process_idx); 210 211 /* This procedure attempts to locate the specified segment from the set of segments dumped 212* for the specified process. It sets base, lth, base_2, and lth_2 as its output. 213**/ 214 215 dcl ( 216 P_segno fixed bin (15), 217 P_process_idx fixed bin 218 ) parameter; 219 220 dcl segx fixed bin; 221 dcl dump_seg_idx fixed bin; 222 dcl offset fixed bin (24); 223 dcl total_lth fixed bin (19); 224 225 226 if (P_process_idx < 0) | (P_process_idx > fdump_process_table.size) then 227 call amu_error_ (amu_info_ptr, 0, "Process index out of range. ^d", P_process_idx); 228 fp_table_ptr = addr (fdump_process_table.array (P_process_idx)); 229 230 dumpptr = fdump_info.dump_seg_ptr (0); /* make the segment table addressable */ 231 232 offset = fp_table.dmp_seg_offset; /* start the offset at the start of the process */ 233 234 do segx = fp_table.first_seg to fp_table.last_seg; 235 if binary (dump.segs (segx).segno, 15) = P_segno then /* found it */ goto FOUND_SEGMENT; 236 offset = offset + (64 * binary (dump.segs (segx).length, 18)); 237 end; 238 239 base = null (); /* didn't find it */ 240 base_2 = null (); 241 return; 242 243 FOUND_SEGMENT: /* KLUDGEY mechanism for resolving addresses */ 244 dump_seg_idx = fp_table.dmp_seg_indx + (divide (offset, fdump_info.dump_seg_lth (0), 17, 0)); 245 /* HIGHLY dependent on exact behaviour of BOS */ 246 offset = mod (offset, fdump_info.dump_seg_lth (0)); 247 248 base = pointer (fdump_info.dump_seg_ptr (dump_seg_idx), offset); 249 250 total_lth = binary (dump.segs (segx).length) * 64;/* length of segment */ 251 252 if (offset + total_lth) <= fdump_info.dump_seg_lth (dump_seg_idx) then do; 253 lth = total_lth - 1; /* image is whole in single dump segment */ 254 base_2 = null (); 255 lth_2 = 0; 256 end; 257 258 else do; /* otherwise, it's split */ 259 lth = fdump_info.dump_seg_lth (dump_seg_idx) - offset; 260 /* First, use all that remains here */ 261 262 dump_seg_idx = dump_seg_idx + 1; /* go on to next segment */ 263 if fdump_info.dump_seg_ptr (dump_seg_idx) = null then goto LOC_ERR; 264 base_2 = pointer (fdump_info.dump_seg_ptr (dump_seg_idx), 0); 265 /* start at the base */ 266 lth_2 = (total_lth - lth) - 1; /* and use up the rest */ 267 end; 268 269 if dump_seg_idx > fdump_info.n_dump_segs then do; 270 LOC_ERR: call amu_error_ (amu_info_ptr, 0, 271 "While resolving segment ^o in process ^d, referenced nonexistent dump segment ^d.", P_segno, 272 P_process_idx, dump_seg_idx); 273 base = null; 274 end; 275 return; 276 end locate_segment; 277 278 1 1 /* BEGIN INCLUDE FILE amu_info.incl.pl1 */ 1 2 1 3 dcl 1 amu_info aligned based (amu_info_ptr), 1 4 2 version char (8) aligned, /* AMU_INFO_VERSION */ 1 5 2 flags aligned, 1 6 3 early_dump bit(1) unal, 1 7 3 pad bit(35) unal, 1 8 2 type fixed bin unal, /* One of the types below */ 1 9 2 time_created fixed bin (71) aligned, /* time created -- for debugging purposes */ 1 10 2 chain, /* a chain of all the amu_info's which exist */ 1 11 3 prev pointer unaligned, 1 12 3 next pointer unaligned, 1 13 1 14 2 area_ptr pointer, /* pointer to area used for allocating things */ 1 15 1 16 2 translation_table_ptr pointer, /* pointer to address map -- always present */ 1 17 /* SEE: amu_translation.incl.pl1 */ 1 18 2 fdump_info_ptr pointer, 1 19 /* pointer to FDUMP info, present if looking at an FDUMP */ 1 20 /* SEE: amu_fdump_info.incl.pl1 */ 1 21 /* old_uid_table pointer if looking at a SAVED PROC. */ 1 22 /* See: amu_old_uid_table */ 1 23 1 24 1 25 2 hardcore_info_ptr pointer, /* pointer to hardcore information -- always present */ 1 26 /* SEE: amu_hardcore_info.incl.pl1 */ 1 27 2 copy_chain pointer, /* pointer to info about segment copies */ 1 28 /* SEE: amu_copy_info.incl.pl1 */ 1 29 2 process_info_ptr pointer, /* pointer to process info for this translation */ 1 30 /* SEE: amu_process_info.incl.pl1 */ 1 31 2 process_idx fixed bin, /* index of process in translation-specifc process table */ 1 32 1 33 2 proc_idx_hold fixed bin, /* a place to keep the index when a changing to another proc */ 1 34 1 35 2 error_info, /* various info about how amu_error_ is to behave */ 1 36 3 error_flags aligned, 1 37 4 handler_exists bit (1) unaligned, /* set to indicate existence of an amu_error handler */ 1 38 4 in_subsystem bit (1) unaligned, /* This amu_info belongs to an ssu_ maintained subsystem */ 1 39 4 pad bit (34) unaligned, 1 40 3 sci_ptr pointer, /* sci_ptr for subsystem, if in_subsystem = "1"b */ 1 41 2 definitions_info_ptr ptr; 1 42 1 43 dcl amu_area area based (amu_info.area_ptr); 1 44 1 45 dcl amu_info_ptr pointer; 1 46 1 47 dcl (FDUMP_TYPE init (1037), /* the various legitimate types of amu_info's */ 1 48 FDUMP_PROCESS_TYPE init (1038), 1 49 ONLINE_TYPE init (1039), 1 50 ONLINE_PROCESS_TYPE init (1040), 1 51 NETWORK_FDUMP_TYPE init (1041), 1 52 NETWORK_ONLINE_TYPE init (1042), 1 53 SAVED_PROC_TYPE init (1043), 1 54 INDIRECT_TYPE init (1044)) fixed bin internal static options (constant); 1 55 1 56 dcl AMU_INFO_VERSION_1 char (8) internal static options (constant) init ("amu_v1"); 1 57 dcl AMU_INFO_VERSION char (8) internal static options (constant) init ("amu_v1"); 1 58 dcl AMU_INFO_VERSION_2 char (8) internal static options (constant) init ("amu_v2"); 1 59 1 60 dcl PDIR_SUFFIX char(4) init("pdir") int static options(constant); 1 61 1 62 /* END INCLUDE FILE amu_info.incl.pl1 */ 279 280 2 1 /* BEGIN INCLUDE FILE amu_fdump_info.incl.pl1 */ 2 2 2 3 dcl 1 fdump_info aligned based (amu_info.fdump_info_ptr), 2 4 2 version char (8), 2 5 2 ref_count fixed bin, /* number of initiations */ 2 6 2 7 2 erf_name char (32), /* ERF name for this dump */ 2 8 2 dump_dname char (168), /* location of the dump */ 2 9 2 dump_ename char (32), /* ename of component zero */ 2 10 2 system_id char (8), /* the system_id of this erf */ 2 11 2 version_id char (8), /* the version id of this erf */ 2 12 2 dump_seg_0_uid bit (36) aligned, /* for determining EQ-ness and gullibility checking */ 2 13 2 14 2 n_dump_segs fixed bin, /* number of real segs in the dump */ 2 15 2 copy_block_ptr pointer, /* pointer to chain of temp segment blocks */ 2 16 2 17 2 dump_seg_ptr (0:31) pointer, /* pointer and length arrays */ 2 18 2 dump_seg_lth (0:31) fixed bin (18), 2 19 2 20 2 fdump_process_table_ptr pointer; /* pointer to array describing processes */ 2 21 2 22 2 23 dcl 1 fdump_process_table aligned based (fdump_info.fdump_process_table_ptr), 2 24 2 size fixed bin, /* number of entries */ 2 25 2 26 2 array (0:alloc_fdump_process_table_size - 1 refer (fdump_process_table.size)) like fp_table; 2 27 2 28 dcl 1 fp_table based (fp_table_ptr), 2 29 2 first_seg fixed bin, 2 30 2 last_seg fixed bin, 2 31 2 process_info_ptr pointer unaligned, /* pointer to process_info structure, if filled in */ 2 32 2 dmp_seg_indx fixed bin, /* dump seg index where process can be found */ 2 33 2 dmp_seg_offset fixed bin (24), /* offset in the segment refered to by dmp_seg_indx where process starts */ 2 34 2 cpu_name char (1), 2 35 2 dbr fixed bin (24), /* address portion of DBR */ 2 36 2 apte_offset fixed bin (18); 2 37 2 38 dcl fp_table_ptr ptr; 2 39 2 40 dcl alloc_fdump_process_table_size fixed bin; 2 41 2 42 dcl AMU_FDUMP_INFO_VERSION_1 char (8) internal static options (constant) init ("amu_erf1"); 2 43 dcl AMU_FDUMP_INFO_VERSION char (8) internal static options (constant) init ("amu_erf1"); 2 44 2 45 /* END INCLUDE FILE amu_fdump_info.incl.pl1 */ 281 282 3 1 /* BEGIN INCLUDE FILE amu_translation.incl.pl1 */ 3 2 3 3 3 4 3 5 /****^ HISTORY COMMENTS: 3 6* 1) change(87-01-16,Parisek), approve(87-07-16,MCR7746), 3 7* audit(87-07-16,Fawcett), install(87-07-28,MR12.1-1049): 3 8* Added the "replaced" field to record whether a segment was replaced by 3 9* another segment via the "replace" request. 3 10* END HISTORY COMMENTS */ 3 11 3 12 3 13 dcl 1 translation_table aligned based (amu_info.translation_table_ptr), 3 14 2 n_entries fixed bin, 3 15 2 max_entries fixed bin, 3 16 3 17 2 valid_array aligned, /* one bit for each valid segno */ 3 18 3 valid (0 : 4095) bit (1) unaligned, 3 19 2 used_array aligned, /* one bit for each existing translation */ 3 20 3 used (0 : 4095) bit (1) unaligned, 3 21 3 22 2 array (alloc_translation_table_max_entries refer (translation_table.max_entries)) like translation; 3 23 3 24 dcl 1 translation aligned based (translation_ptr), /* a single translation */ 3 25 2 segno fixed bin (18) unsigned unaligned, /* foreign segno for this translation */ 3 26 2 flags unaligned, 3 27 3 two_part bit (1) unaligned, /* segment is in two pieces -- from an FDUMP */ 3 28 3 in_dump bit (1) unaligned, /* segment is part of an FDUMP image */ 3 29 3 in_temp_seg bit (1) unaligned, /* segment is a copy at the base of a temp segment */ 3 30 3 in_perm_seg bit (1) unaligned, /* segment is in the file system */ 3 31 3 in_dp_dir bit (1) unaligned, 3 32 3 replaced bit (1) unaligned, 3 33 3 pad bit (12) unaligned, 3 34 2 part1, /* pointer to first (possibly only) part of segment */ 3 35 3 ptr pointer unaligned, 3 36 3 lth fixed bin (19), 3 37 2 part2 like translation.part1; 3 38 3 39 dcl alloc_translation_table_max_entries fixed bin; 3 40 dcl translation_ptr pointer; 3 41 3 42 /* END INCLUDE FILE amu_translation.incl.pl1 */ 283 284 4 1 /* BEGIN INCLUDE FILE ... bos_dump.incl.pl1 ... */ 4 2 /* Modified 1 September 1976 */ 4 3 /* Modified 11/11/80 by J. A. Bush for the DPS8/70M CPU */ 4 4 /* Modified 6/12/81 by Rich Coppola to extend the dps8 extended fault reg to 4 5* 15 bits */ 4 6 /* Modified 02/23/81, W. Olin Sibert, to describe old and new FDUMP styles */ 4 7 4 8 4 9 dcl dumpptr ptr; /* pointer to following structure */ 4 10 4 11 dcl 1 dump based (dumpptr) aligned, /* header of dump by fdump */ 4 12 2 dump_header aligned like dump_header, 4 13 4 14 2 segs (1008), /* segment array */ 4 15 3 segno bit (18) unal, /* segment number */ 4 16 3 length bit (18) unal, /* length of segment in sector sized blocks */ 4 17 4 18 2 amptwregs (0 : 63) bit (36), /* assoc. mem. page table word regs */ 4 19 2 amptwptrs (0 : 63) bit (36), /* assoc. mem. page table word pointers */ 4 20 2 amsdwregs (0 : 63) bit (72), /* assoc. mem. segment descriptor word registers */ 4 21 2 amsdwptrs (0 : 63) bit (36), /* assoc. mem. segment descriptor word pointers */ 4 22 4 23 2 ouhist (0 : 63) bit (72), /* operations unit history registers */ 4 24 2 cuhist (0 : 63) bit (72), /* control unit history registers */ 4 25 2 duhist (0 : 63) bit (72), /* decimal unit history registers */ 4 26 2 auhist (0 : 63) bit (72), /* appending unit history registers */ 4 27 4 28 2 prs (0 : 7) ptr, /* pointer registers */ 4 29 4 30 2 regs aligned like dump_registers, /* assorted machine registers */ 4 31 4 32 2 low_order_port bit (3), /* from which clock is read */ 4 33 2 pad4 bit (36), 4 34 2 mctime fixed bin (52), /* time conditions were taken */ 4 35 2 pad5 (0 : 3) bit (36), 4 36 4 37 2 misc_registers like dump_misc_registers, /* Assorted registers & processor data */ 4 38 4 39 2 ptrlen (0 : 7) bit (36), /* pointers and lengths for EIS */ 4 40 4 41 2 coreblocks (0 : 7), 4 42 3 num_first bit (18) unal, /* first addr in coreblock */ 4 43 3 num_blocks bit (18) unal, /* number of blocks used */ 4 44 2 pad7 (112) fixed bin; 4 45 4 46 4 47 dcl 1 dump_header aligned based, /* Standard header for FDUMP */ 4 48 2 words_dumped fixed bin (35), /* total words in dump */ 4 49 2 valid bit (1), /* = 1 if there is a 6180 dump to be had */ 4 50 2 time fixed bin (71), /* time of dump */ 4 51 2 erfno fixed bin (18), /* Error Report Form Number */ 4 52 2 num_segs fixed bin, /* number of segments dumped */ 4 53 2 valid_355 bit (1), /* = 1 if there is a dn355 dump to be had */ 4 54 2 dumped_355s bit (4), /* indicates which 355s were dumped */ 4 55 2 time_355 fixed bin (71), /* time of 355 dump */ 4 56 2 version fixed bin, /* currently 2 */ 4 57 2 pad0 (5) fixed bin; /* pad0 to 16 words */ 4 58 4 59 dcl 1 dump_registers aligned based, /* Standard (SREG) arrangement of registers in dump */ 4 60 (2 x (0 : 7) bit (18), /* index registers */ 4 61 2 a bit (36), /* the a register */ 4 62 2 q bit (36), /* the q register */ 4 63 2 e bit (8), /* the e register */ 4 64 2 pad2 bit (28), /* pad */ 4 65 2 t bit (27), /* timer register */ 4 66 2 pad3 bit (6), /* pad */ 4 67 2 ralr bit (3)) unaligned; /* ring alarm register */ 4 68 4 69 dcl 1 dump_misc_registers aligned based, 4 70 2 scu (0 : 7) bit (36), /* from store control unit instr. */ 4 71 2 mcm (0 : 7) bit (72), /* memory controller masks every 64 K */ 4 72 2 dbr bit (72), /* descriptor segment base register */ 4 73 2 intrpts bit (36), /* interrupts */ 4 74 2 bar bit (36), /* base address register */ 4 75 2 modereg bit (36), /* mode register */ 4 76 2 cmodereg bit (36), /* cache mode register */ 4 77 2 faultreg bit (36), /* fault register */ 4 78 2 ext_fault_reg bit (15) unaligned, /* DPS8 extended fault register */ 4 79 2 pad6 bit (21) unaligned; 4 80 4 81 4 82 4 83 dcl 1 v1_dump aligned based (dumpptr), /* Old version of FDUMP (pre March, 1981) */ 4 84 2 dump_header aligned like dump_header, 4 85 4 86 2 segs (688), /* segment array */ 4 87 3 segno bit (18) unal, /* segment number */ 4 88 3 length bit (18) unal, /* length of segment in sector sized blocks */ 4 89 4 90 2 amsdwregs (0 : 15) bit (72), /* assoc. mem. segment descriptor word registers */ 4 91 2 amsdwptrs (0 : 15) bit (36), /* assoc. mem. segment descriptor word pointers */ 4 92 2 amptwregs (0 : 15) bit (36), /* assoc. mem. page table word regs */ 4 93 2 amptwptrs (0 : 15) bit (36), /* assoc. mem. page table word pointers */ 4 94 2 pad1 (0 : 15) bit (36), 4 95 4 96 2 ouhist (0 : 15) bit (72), /* operations unit history registers */ 4 97 2 cuhist (0 : 15) bit (72), /* control unit history registers */ 4 98 2 auhist (0 : 15) bit (72), /* appending unit history registers */ 4 99 2 duhist (0 : 15) bit (72), /* decimal unit history registers */ 4 100 4 101 2 prs (0 : 7) ptr, /* pointer registers */ 4 102 4 103 2 regs aligned like dump_registers, /* assorted machine registers */ 4 104 4 105 2 mctime fixed bin (52), /* time conditions were taken */ 4 106 2 pad4 (0 : 5) bit (36), 4 107 4 108 2 misc_registers aligned like dump_misc_registers, /* Assorted registers */ 4 109 4 110 2 pad5 bit (36), 4 111 2 ptrlen (0 : 7) bit (36), /* pointers and lengths for EIS */ 4 112 2 pad6 (15) bit (36), 4 113 2 low_order_port bit (3), /* from which clock was read */ 4 114 4 115 2 coreblocks (0 : 7), 4 116 3 num_first bit (18) unal, /* first addr in coreblock */ 4 117 3 num_blocks bit (18) unal; /* number of blocks used */ 4 118 4 119 4 120 dcl DUMP_VERSION_1 fixed bin internal static options (constant) init (1); 4 121 dcl DUMP_VERSION_2 fixed bin internal static options (constant) init (2); 4 122 4 123 /* END INCLUDE FILE ... bos_dump.incl.pl1 ... */ 285 286 287 end amu_fdump_translate_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 07/28/87 0924.4 amu_fdump_translate_.pl1 >spec>install>MR12.1-1049>amu_fdump_translate_.pl1 279 1 11/20/84 0856.1 amu_info.incl.pl1 >ldd>include>amu_info.incl.pl1 281 2 09/22/83 1102.5 amu_fdump_info.incl.pl1 >ldd>include>amu_fdump_info.incl.pl1 283 3 07/28/87 0927.3 amu_translation.incl.pl1 >spec>install>MR12.1-1049>amu_translation.incl.pl1 285 4 08/12/81 2025.8 bos_dump.incl.pl1 >ldd>include>bos_dump.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. FDUMP_PROCESS_TYPE constant fixed bin(17,0) initial dcl 1-47 ref 198 FDUMP_TYPE constant fixed bin(17,0) initial dcl 1-47 ref 197 P_amu_info_ptr parameter pointer dcl 26 ref 57 93 137 168 195 P_code parameter fixed bin(35,0) dcl 26 set ref 57 70* 93 107* 137 149* 168 177* 181* 201* P_process_idx parameter fixed bin(17,0) dcl 215 set ref 208 226 226 226* 228 270* P_seg_lth parameter fixed bin(19,0) dcl 26 set ref 168 182* P_seg_ptr parameter pointer dcl 26 ref 57 66 93 103 137 145 168 175 175 P_segno parameter fixed bin(15,0) dcl 215 set ref 208 235 270* P_translation_ptr parameter pointer dcl 26 ref 57 65 93 102 137 144 addr builtin function dcl 54 ref 228 amu_$temp_seg_get 000014 constant entry external dcl 51 ref 123 155 amu_error_ 000012 constant entry external dcl 50 ref 199 226 270 amu_et_$seg_not_dumped 000010 external static fixed bin(35,0) dcl 49 ref 70 107 149 177 amu_info based structure level 1 dcl 1-3 amu_info_ptr 000122 automatic pointer dcl 1-45 set ref 121 123* 123 153 155* 155 195* 197 198 198 199* 199 226 226* 228 230 243 246 248 252 259 263 264 269 270* array 1 based structure array level 2 dcl 2-23 set ref 228 base 000100 automatic pointer dcl 34 set ref 69 75 106 112 125 148 157 176 239* 248* 273* base_2 000102 automatic pointer dcl 34 set ref 78 79 111 126 158 158 240* 254* 264* baseno builtin function dcl 54 ref 66 103 145 175 175 binary builtin function dcl 54 ref 66 103 145 175 175 235 236 250 copy_block_ptr 104 based pointer level 2 dcl 2-3 set ref 123* 155* copy_part1 based bit(36) array dcl 46 ref 125 157 copy_part2 based bit(36) array dcl 47 ref 126 158 copy_seg based structure level 1 dcl 42 copy_seg_ptr 000120 automatic pointer dcl 40 set ref 123* 125 126 128 155* 157 158 160 divide builtin function dcl 54 ref 243 dmp_seg_indx 3 based fixed bin(17,0) level 2 dcl 2-28 ref 243 dmp_seg_offset 4 based fixed bin(24,0) level 2 dcl 2-28 ref 232 dump based structure level 1 dcl 4-11 dump_header based structure level 1 dcl 4-47 dump_misc_registers based structure level 1 dcl 4-69 dump_registers based structure level 1 dcl 4-59 dump_seg_idx 000147 automatic fixed bin(17,0) dcl 221 set ref 243* 248 252 259 262* 262 263 264 269 270* dump_seg_lth 206 based fixed bin(18,0) array level 2 dcl 2-3 ref 243 246 252 259 dump_seg_ptr 106 based pointer array level 2 dcl 2-3 ref 230 248 263 264 dumpptr 000130 automatic pointer dcl 4-9 set ref 230* 235 236 250 erf_name 3 based char(32) level 2 dcl 2-3 set ref 121* 153* fdump_info based structure level 1 dcl 2-3 fdump_info_ptr 14 based pointer level 2 dcl 1-3 ref 121 123 153 155 226 228 230 243 246 248 252 259 263 264 269 fdump_process_table based structure level 1 dcl 2-23 fdump_process_table_ptr 246 based pointer level 2 dcl 2-3 ref 226 228 first_seg based fixed bin(17,0) level 2 dcl 2-28 ref 234 flags 0(18) based structure level 2 packed unaligned dcl 3-24 set ref 73* 110* 127* 159* fp_table based structure level 1 unaligned dcl 2-28 fp_table_ptr 000124 automatic pointer dcl 2-38 set ref 228* 232 234 234 243 in_dump 0(19) based bit(1) level 3 packed unaligned dcl 3-24 set ref 77* 117* in_temp_seg 0(20) based bit(1) level 3 packed unaligned dcl 3-24 set ref 133* 165* ioa_$rsnnl 000016 constant entry external dcl 52 ref 121 153 last_seg 1 based fixed bin(17,0) level 2 dcl 2-28 ref 234 length 20(18) based bit(18) array level 3 packed unaligned dcl 4-11 ref 236 250 lth 2 based fixed bin(19,0) level 3 in structure "translation" dcl 3-24 in procedure "amu_fdump_translate_" set ref 76* 113* 129* 161* lth 000104 automatic fixed bin(19,0) dcl 35 in procedure "amu_fdump_translate_" set ref 76 113 125 126 129 157 158 161 182 253* 259* 266 lth 4 based fixed bin(19,0) level 3 in structure "translation" dcl 3-24 in procedure "amu_fdump_translate_" set ref 80* 84* 115* 131* 163* lth_2 000105 automatic fixed bin(19,0) dcl 35 set ref 80 126 129 158 161 182 255* 266* mod builtin function dcl 54 ref 246 n_dump_segs 102 based fixed bin(17,0) level 2 dcl 2-3 ref 269 null builtin function dcl 54 ref 69 79 106 111 114 130 148 158 162 176 239 240 254 263 273 offset 000150 automatic fixed bin(24,0) dcl 222 set ref 232* 236* 236 243 246* 246 248 252 259 part1 based bit(36) array level 2 in structure "copy_seg" dcl 42 in procedure "amu_fdump_translate_" set ref 125* 157* part1 347 based structure array level 3 in structure "translation_table" dcl 3-13 in procedure "amu_fdump_translate_" part1 1 based structure level 2 in structure "translation" dcl 3-24 in procedure "amu_fdump_translate_" part2 based bit(36) array level 2 in structure "copy_seg" dcl 42 in procedure "amu_fdump_translate_" set ref 126* 158* part2 3 based structure level 2 in structure "translation" dcl 3-24 in procedure "amu_fdump_translate_" pointer builtin function dcl 54 ref 248 264 process_idx 000117 automatic fixed bin(17,0) dcl 38 in procedure "amu_fdump_translate_" set ref 68* 105* 121* 147* 153* 197* 198* process_idx 24 based fixed bin(17,0) level 2 in structure "amu_info" dcl 1-3 in procedure "amu_fdump_translate_" ref 198 ptr 1 based pointer level 3 in structure "translation" packed unaligned dcl 3-24 in procedure "amu_fdump_translate_" set ref 75* 112* 128* 160* ptr 3 based pointer level 3 in structure "translation" packed unaligned dcl 3-24 in procedure "amu_fdump_translate_" set ref 78* 114* 130* 162* segno 000106 automatic fixed bin(15,0) dcl 36 in procedure "amu_fdump_translate_" set ref 66* 68* 74 103* 105* 116 121* 132 145* 147* 153* 164 segno based fixed bin(18,0) level 2 in structure "translation" packed unsigned unaligned dcl 3-24 in procedure "amu_fdump_translate_" set ref 74* 116* 132* 164* segno 20 based bit(18) array level 3 in structure "dump" packed unaligned dcl 4-11 in procedure "amu_fdump_translate_" ref 235 segs 20 based structure array level 2 dcl 4-11 segx 000146 automatic fixed bin(17,0) dcl 220 set ref 234* 235 236* 250 size based fixed bin(17,0) level 2 dcl 2-23 ref 226 temp_seg_name 000107 automatic char(32) unaligned dcl 37 set ref 121* 123* 153* 155* total_lth 000151 automatic fixed bin(19,0) dcl 223 set ref 250* 252 253 266 translation based structure level 1 dcl 3-24 translation_ptr 000126 automatic pointer dcl 3-40 set ref 65* 73 74 75 76 77 78 80 81 84 102* 110 112 113 114 115 116 117 127 128 129 130 131 132 133 144* 159 160 161 162 163 164 165 two_part 0(18) based bit(1) level 3 packed unaligned dcl 3-24 set ref 81* type 3 based fixed bin(17,0) level 2 packed unaligned dcl 1-3 set ref 197 198 199* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. AMU_FDUMP_INFO_VERSION internal static char(8) initial unaligned dcl 2-43 AMU_FDUMP_INFO_VERSION_1 internal static char(8) initial unaligned dcl 2-42 AMU_INFO_VERSION internal static char(8) initial unaligned dcl 1-57 AMU_INFO_VERSION_1 internal static char(8) initial unaligned dcl 1-56 AMU_INFO_VERSION_2 internal static char(8) initial unaligned dcl 1-58 DUMP_VERSION_1 internal static fixed bin(17,0) initial dcl 4-120 DUMP_VERSION_2 internal static fixed bin(17,0) initial dcl 4-121 INDIRECT_TYPE internal static fixed bin(17,0) initial dcl 1-47 NETWORK_FDUMP_TYPE internal static fixed bin(17,0) initial dcl 1-47 NETWORK_ONLINE_TYPE internal static fixed bin(17,0) initial dcl 1-47 ONLINE_PROCESS_TYPE internal static fixed bin(17,0) initial dcl 1-47 ONLINE_TYPE internal static fixed bin(17,0) initial dcl 1-47 PDIR_SUFFIX internal static char(4) initial unaligned dcl 1-60 SAVED_PROC_TYPE internal static fixed bin(17,0) initial dcl 1-47 alloc_fdump_process_table_size automatic fixed bin(17,0) dcl 2-40 alloc_translation_table_max_entries automatic fixed bin(17,0) dcl 3-39 amu_area based area(1024) dcl 1-43 translation_table based structure level 1 dcl 3-13 v1_dump based structure level 1 dcl 4-83 NAMES DECLARED BY EXPLICIT CONTEXT. FOUND_SEGMENT 001114 constant label dcl 243 ref 235 LOC_ERR 001207 constant label dcl 270 ref 263 amu_fdump_translate_ 000075 constant entry external dcl 20 amu_fdump_translate_$contiguous 000213 constant entry external dcl 93 amu_fdump_translate_$get_seg_lth 000670 constant entry external dcl 168 amu_fdump_translate_$get_translation 000110 constant entry external dcl 57 amu_fdump_translate_$to_temp_seg 000456 constant entry external dcl 137 get_amu_info 000730 constant entry internal dcl 189 ref 64 101 143 173 locate_segment 001005 constant entry internal dcl 208 ref 68 105 147 175 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1476 1516 1276 1506 Length 2000 1276 20 246 177 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME amu_fdump_translate_ 248 external procedure is an external procedure. get_amu_info internal procedure shares stack frame of external procedure amu_fdump_translate_. locate_segment internal procedure shares stack frame of external procedure amu_fdump_translate_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME amu_fdump_translate_ 000100 base amu_fdump_translate_ 000102 base_2 amu_fdump_translate_ 000104 lth amu_fdump_translate_ 000105 lth_2 amu_fdump_translate_ 000106 segno amu_fdump_translate_ 000107 temp_seg_name amu_fdump_translate_ 000117 process_idx amu_fdump_translate_ 000120 copy_seg_ptr amu_fdump_translate_ 000122 amu_info_ptr amu_fdump_translate_ 000124 fp_table_ptr amu_fdump_translate_ 000126 translation_ptr amu_fdump_translate_ 000130 dumpptr amu_fdump_translate_ 000146 segx locate_segment 000147 dump_seg_idx locate_segment 000150 offset locate_segment 000151 total_lth locate_segment THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc return_mac mpfx2 mdfx1 ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. amu_$temp_seg_get amu_error_ ioa_$rsnnl THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. amu_et_$seg_not_dumped LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 20 000074 22 000102 57 000103 64 000115 65 000116 66 000122 68 000130 69 000132 70 000136 71 000142 73 000143 74 000161 75 000165 76 000170 77 000172 78 000174 79 000176 80 000202 81 000204 82 000206 84 000207 89 000210 93 000211 101 000220 102 000221 103 000225 105 000233 106 000235 107 000241 108 000245 110 000246 111 000264 112 000270 113 000273 114 000275 115 000277 116 000300 117 000303 118 000305 121 000306 123 000354 125 000401 126 000410 127 000420 128 000436 129 000440 130 000443 131 000445 132 000446 133 000451 134 000453 137 000454 143 000463 144 000464 145 000470 147 000476 148 000500 149 000504 150 000510 153 000511 155 000557 157 000604 158 000613 159 000627 160 000645 161 000647 162 000652 163 000654 164 000655 165 000660 166 000662 168 000663 173 000675 175 000676 176 000711 177 000715 178 000721 181 000722 182 000724 185 000727 189 000730 195 000731 197 000735 198 000744 199 000751 201 001002 203 001004 208 001005 226 001007 228 001047 230 001057 232 001061 234 001063 235 001073 236 001101 237 001106 239 001110 240 001112 241 001113 243 001114 246 001123 248 001127 250 001136 252 001147 253 001153 254 001156 255 001160 256 001161 259 001162 262 001165 263 001166 264 001175 266 001200 269 001204 270 001207 273 001247 275 001251 ----------------------------------------------------------- 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