COMPILATION LISTING OF SEGMENT amu_do_translation_ 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 0927.5 mst Tue Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 4* * * 5* *********************************************************** */ 6 amu_do_translation_: 7 proc (P_amu_info_ptr, P_segno, P_buf_ptr, P_offset, P_range, P_code); 8 9 /* format: style4,delnl,insnl,ifthenstmt,indnoniterend,ifthendo,ifthen,^thendo */ 10 11 dcl P_amu_info_ptr ptr; 12 dcl P_segno fixed bin; 13 dcl P_offset fixed bin (18); 14 dcl P_range fixed bin (18); 15 dcl P_buf_ptr ptr; 16 dcl P_code fixed bin (35); 17 dcl P_seg_ptr ptr; 18 dcl P_ret_ptr ptr; 19 20 21 dcl error_table_$out_of_bounds fixed bin (35) ext; 22 23 dcl old_proc_idx fixed bin; 24 dcl segno fixed bin; 25 dcl seg_base_ptr ptr; 26 dcl offset fixed bin (18); 27 dcl range fixed bin (18); 28 dcl buf_ptr ptr; 29 dcl dump_data_ptr ptr; 30 dcl buf_size fixed bin (24); 31 dcl buf char (buf_size) based (buf_ptr); 32 dcl code fixed bin (35); 33 dcl (range_1, range_2) fixed bin; 34 dcl total_length fixed bin (24); 35 dcl (hunt_entry, by_ptr_entry, ptr_entry) bit (1); 36 dcl temp_ptr ptr; 37 dcl bit_count fixed bin (24); 38 dcl 1 trans_space like translation; 39 40 dcl amu_$dp_expand_to_ptr entry (ptr, fixed bin, ptr, fixed bin (24)); 41 dcl amu_$translate_get entry (ptr, fixed bin, ptr, fixed bin (35)); 42 dcl amu_$translate_add entry (ptr, ptr, fixed bin, fixed bin (35)); 43 dcl amu_$fdump_translate_get_translation entry (ptr, ptr, ptr, fixed bin (35)); 44 dcl amu_$fdump_mpt_change_idx entry (ptr, fixed bin); 45 dcl amu_$return_val_per_process entry (ptr, fixed bin) returns (bit (1)); 46 dcl amu_$get_name_ptr_count entry (ptr, ptr, ptr, fixed bin (24)); 47 48 dcl (addr, addrel, baseno, baseptr, 49 divide, fixed, null, rel) builtin; 50 51 dcl ( 52 error_table_$seg_not_found, 53 amu_et_$invalid_segno, 54 amu_et_$no_translation 55 ) fixed bin (35) ext; 56 57 58 59 by_ptr_entry = "0"b; 60 hunt_entry = "0"b; 61 ptr_entry = "0"b; 62 goto common_do; 63 64 amu_do_translation_$hunt: 65 entry (P_amu_info_ptr, P_segno, P_buf_ptr, P_offset, P_range, P_code); 66 67 hunt_entry = "1"b; 68 ptr_entry = "0"b; 69 by_ptr_entry = "0"b; 70 goto common_do; 71 72 amu_do_translation_$hunt_ptr: 73 entry (P_amu_info_ptr, P_seg_ptr, P_ret_ptr, P_code); 74 hunt_entry = "1"b; 75 ptr_entry = "1"b; 76 by_ptr_entry = "1"b; 77 goto common_do; 78 79 amu_do_translation_$ptr_given_segno: 80 entry (P_amu_info_ptr, P_segno, P_ret_ptr, P_code); 81 82 /* Given a segno, returns the ptr of the segment. */ 83 84 hunt_entry = "1"b; 85 ptr_entry = "1"b; 86 by_ptr_entry = "0"b; 87 amu_info_ptr = P_amu_info_ptr; 88 P_code = 0; 89 if P_segno >= 4096 then do; 90 P_code = amu_et_$invalid_segno; 91 return; 92 end; 93 offset, range = 0; 94 segno = P_segno; 95 P_ret_ptr, buf_ptr = null(); 96 goto GET_IT; 97 98 amu_do_translation_$by_ptr: 99 entry (P_amu_info_ptr, P_seg_ptr, P_range, P_buf_ptr, P_code); 100 hunt_entry = "0"b; 101 ptr_entry = "0"b; 102 by_ptr_entry = "1"b; 103 goto common_do; 104 105 106 common_do: 107 amu_info_ptr = P_amu_info_ptr; 108 P_code = 0; 109 if ^by_ptr_entry then do; 110 if P_segno >= 4096 then do; 111 P_code = amu_et_$invalid_segno; 112 return; 113 end; 114 end; 115 else do; 116 if fixed(baseno(P_seg_ptr),17) >= 4096 then do; 117 P_code = amu_et_$invalid_segno; 118 return; 119 end; 120 end; 121 122 if ^ptr_entry then do; 123 range = P_range; 124 buf_ptr = P_buf_ptr; 125 if ^by_ptr_entry then do; 126 segno = P_segno; 127 offset = P_offset; 128 end; 129 else do; 130 segno = fixed (baseno (P_seg_ptr), 17); 131 offset = fixed (rel (P_seg_ptr), 18); 132 end; 133 end; 134 else do; 135 range = 0; 136 segno = fixed (baseno (P_seg_ptr), 17); 137 offset = fixed (rel (P_seg_ptr), 18); 138 buf_ptr = null; 139 end; 140 141 142 GET_IT: 143 translation_ptr = addr (trans_space); 144 old_proc_idx = -1; 145 if ^amu_$return_val_per_process (amu_info_ptr, segno) then do; 146 old_proc_idx = amu_info.process_idx; 147 if amu_info.type ^= SAVED_PROC_TYPE then call amu_$fdump_mpt_change_idx (amu_info_ptr, 0); 148 end; 149 150 call amu_$translate_get (amu_info_ptr, segno, translation_ptr, code); 151 if code ^= 0 then do; 152 if code = amu_et_$no_translation then do; 153 translation_ptr = addr (trans_space); 154 seg_base_ptr = baseptr (segno); 155 if amu_info.type = FDUMP_TYPE | amu_info.type = FDUMP_PROCESS_TYPE then do; 156 call amu_$fdump_translate_get_translation (amu_info_ptr, seg_base_ptr, translation_ptr, code); 157 158 if code ^= 0 then do; 159 if hunt_entry then do; 160 call hunt_for_seg; 161 if code = 0 then goto add_trans; 162 end; 163 164 if old_proc_idx >= 0 then call amu_$fdump_mpt_change_idx (amu_info_ptr, old_proc_idx); 165 P_code = code; 166 return; 167 end; 168 end; 169 170 if amu_info.type = SAVED_PROC_TYPE then do; 171 if hunt_entry then do; 172 call hunt_for_seg; 173 if code = 0 then goto add_trans; 174 end; 175 P_code = code; 176 return; 177 end; 178 179 180 end; 181 add_trans: 182 call amu_$translate_add (amu_info_ptr, translation_ptr, segno, code); 183 if code = 0 then 184 goto start_do; 185 else do; 186 if old_proc_idx >= 0 then call amu_$fdump_mpt_change_idx (amu_info_ptr, old_proc_idx); 187 P_code = code; 188 return; 189 end; 190 end; 191 192 start_do: 193 if ^translation.two_part | translation.in_temp_seg then do; 194 if offset > translation.part1.lth then do; 195 if ^ptr_entry then 196 P_range = 0; 197 else P_ret_ptr = null (); 198 P_code = error_table_$out_of_bounds; 199 if old_proc_idx >= 0 then call amu_$fdump_mpt_change_idx (amu_info_ptr, old_proc_idx); 200 return; 201 end; 202 if ptr_entry then do; 203 P_ret_ptr = addrel (translation.part1.ptr, offset); 204 P_code = 0; 205 if old_proc_idx >= 0 then call amu_$fdump_mpt_change_idx (amu_info_ptr, old_proc_idx); 206 return; 207 end; 208 209 210 if offset = translation.part1.lth then range = 1; 211 else if (offset + range) > translation.part1.lth then range = translation.part1.lth - offset; 212 buf_size = 4 * range; 213 dump_data_ptr = addrel (translation.part1.ptr, offset); 214 buf = dump_data_ptr -> buf; 215 P_code = 0; 216 if ^ptr_entry then P_range = range; 217 if old_proc_idx >= 0 then call amu_$fdump_mpt_change_idx (amu_info_ptr, old_proc_idx); 218 return; 219 end; 220 else do; 221 total_length = (translation.part1.lth + translation.part2.lth); 222 if offset > total_length then do; 223 if ^ptr_entry then 224 P_range = 0; 225 else P_ret_ptr = null (); 226 P_code = error_table_$out_of_bounds; 227 if old_proc_idx >= 0 then call amu_$fdump_mpt_change_idx (amu_info_ptr, old_proc_idx); 228 return; 229 end; 230 if ptr_entry then do; 231 if offset > translation.part1.lth then 232 P_ret_ptr = addrel (translation.part2.ptr, (offset - translation.part1.lth)); 233 else P_ret_ptr = addrel (translation.part1.ptr, offset); 234 if old_proc_idx >= 0 then call amu_$fdump_mpt_change_idx (amu_info_ptr, old_proc_idx); 235 P_code = 0; 236 return; 237 end; 238 239 240 if offset = total_length then range = 1; 241 else if (offset + range) > total_length then range = total_length - offset; 242 if offset <= translation.part1.lth then do; 243 if (offset + range) <= translation.part1.lth then do; 244 buf_size = 4 * range; 245 dump_data_ptr = addrel (translation.part1.ptr, offset); 246 buf = dump_data_ptr -> buf; 247 P_code = 0; 248 P_range = range; 249 if old_proc_idx >= 0 then call amu_$fdump_mpt_change_idx (amu_info_ptr, old_proc_idx); 250 return; 251 end; 252 else do; 253 range_1 = translation.part1.lth - offset; 254 range_2 = range - range_1; 255 buf_size = range_1 * 4; 256 dump_data_ptr = addrel (translation.part1.ptr, offset); 257 buf = dump_data_ptr -> buf; 258 buf_size = range_2 * 4; 259 buf_ptr = addrel (buf_ptr, range_1); 260 dump_data_ptr = translation.part2.ptr; 261 buf = dump_data_ptr -> buf; 262 P_code = 0; 263 P_range = range; 264 if old_proc_idx >= 0 then call amu_$fdump_mpt_change_idx (amu_info_ptr, old_proc_idx); 265 return; 266 end; 267 end; 268 else do; 269 offset = offset - translation.part1.lth; 270 buf_size = range * 4; 271 buf = addrel (translation.part2.ptr, offset) -> buf; 272 P_code = 0; 273 P_range = range; 274 if old_proc_idx >= 0 then call amu_$fdump_mpt_change_idx (amu_info_ptr, old_proc_idx); 275 return; 276 end; 277 end; 278 if old_proc_idx >= 0 then call amu_$fdump_mpt_change_idx (amu_info_ptr, old_proc_idx); 279 280 hunt_for_seg: 281 proc; 282 283 code = 0; 284 translation_ptr = addr (trans_space); 285 translation.segno = segno; 286 translation.flags = ""b; 287 translation.part2.ptr = null (); 288 translation.part2.lth = 0; 289 if amu_info.type = FDUMP_PROCESS_TYPE then 290 call amu_$get_name_ptr_count (amu_info_ptr, baseptr (segno), temp_ptr, bit_count); 291 else call amu_$dp_expand_to_ptr (amu_info_ptr, (segno), temp_ptr, bit_count); 292 if temp_ptr = null () then do; 293 code = error_table_$seg_not_found; 294 return; 295 end; 296 translation.part1.ptr = temp_ptr; 297 translation.part1.lth = divide (bit_count, 36, 19); 298 translation.flags.in_perm_seg = "1"b; 299 return; 300 end hunt_for_seg; 301 1 1 /* BEGIN INCLUDE FILE amu_translation.incl.pl1 */ 1 2 1 3 1 4 1 5 /****^ HISTORY COMMENTS: 1 6* 1) change(87-01-16,Parisek), approve(87-07-16,MCR7746), 1 7* audit(87-07-16,Fawcett), install(87-07-28,MR12.1-1049): 1 8* Added the "replaced" field to record whether a segment was replaced by 1 9* another segment via the "replace" request. 1 10* END HISTORY COMMENTS */ 1 11 1 12 1 13 dcl 1 translation_table aligned based (amu_info.translation_table_ptr), 1 14 2 n_entries fixed bin, 1 15 2 max_entries fixed bin, 1 16 1 17 2 valid_array aligned, /* one bit for each valid segno */ 1 18 3 valid (0 : 4095) bit (1) unaligned, 1 19 2 used_array aligned, /* one bit for each existing translation */ 1 20 3 used (0 : 4095) bit (1) unaligned, 1 21 1 22 2 array (alloc_translation_table_max_entries refer (translation_table.max_entries)) like translation; 1 23 1 24 dcl 1 translation aligned based (translation_ptr), /* a single translation */ 1 25 2 segno fixed bin (18) unsigned unaligned, /* foreign segno for this translation */ 1 26 2 flags unaligned, 1 27 3 two_part bit (1) unaligned, /* segment is in two pieces -- from an FDUMP */ 1 28 3 in_dump bit (1) unaligned, /* segment is part of an FDUMP image */ 1 29 3 in_temp_seg bit (1) unaligned, /* segment is a copy at the base of a temp segment */ 1 30 3 in_perm_seg bit (1) unaligned, /* segment is in the file system */ 1 31 3 in_dp_dir bit (1) unaligned, 1 32 3 replaced bit (1) unaligned, 1 33 3 pad bit (12) unaligned, 1 34 2 part1, /* pointer to first (possibly only) part of segment */ 1 35 3 ptr pointer unaligned, 1 36 3 lth fixed bin (19), 1 37 2 part2 like translation.part1; 1 38 1 39 dcl alloc_translation_table_max_entries fixed bin; 1 40 dcl translation_ptr pointer; 1 41 1 42 /* END INCLUDE FILE amu_translation.incl.pl1 */ 302 303 2 1 /* BEGIN INCLUDE FILE amu_info.incl.pl1 */ 2 2 2 3 dcl 1 amu_info aligned based (amu_info_ptr), 2 4 2 version char (8) aligned, /* AMU_INFO_VERSION */ 2 5 2 flags aligned, 2 6 3 early_dump bit(1) unal, 2 7 3 pad bit(35) unal, 2 8 2 type fixed bin unal, /* One of the types below */ 2 9 2 time_created fixed bin (71) aligned, /* time created -- for debugging purposes */ 2 10 2 chain, /* a chain of all the amu_info's which exist */ 2 11 3 prev pointer unaligned, 2 12 3 next pointer unaligned, 2 13 2 14 2 area_ptr pointer, /* pointer to area used for allocating things */ 2 15 2 16 2 translation_table_ptr pointer, /* pointer to address map -- always present */ 2 17 /* SEE: amu_translation.incl.pl1 */ 2 18 2 fdump_info_ptr pointer, 2 19 /* pointer to FDUMP info, present if looking at an FDUMP */ 2 20 /* SEE: amu_fdump_info.incl.pl1 */ 2 21 /* old_uid_table pointer if looking at a SAVED PROC. */ 2 22 /* See: amu_old_uid_table */ 2 23 2 24 2 25 2 hardcore_info_ptr pointer, /* pointer to hardcore information -- always present */ 2 26 /* SEE: amu_hardcore_info.incl.pl1 */ 2 27 2 copy_chain pointer, /* pointer to info about segment copies */ 2 28 /* SEE: amu_copy_info.incl.pl1 */ 2 29 2 process_info_ptr pointer, /* pointer to process info for this translation */ 2 30 /* SEE: amu_process_info.incl.pl1 */ 2 31 2 process_idx fixed bin, /* index of process in translation-specifc process table */ 2 32 2 33 2 proc_idx_hold fixed bin, /* a place to keep the index when a changing to another proc */ 2 34 2 35 2 error_info, /* various info about how amu_error_ is to behave */ 2 36 3 error_flags aligned, 2 37 4 handler_exists bit (1) unaligned, /* set to indicate existence of an amu_error handler */ 2 38 4 in_subsystem bit (1) unaligned, /* This amu_info belongs to an ssu_ maintained subsystem */ 2 39 4 pad bit (34) unaligned, 2 40 3 sci_ptr pointer, /* sci_ptr for subsystem, if in_subsystem = "1"b */ 2 41 2 definitions_info_ptr ptr; 2 42 2 43 dcl amu_area area based (amu_info.area_ptr); 2 44 2 45 dcl amu_info_ptr pointer; 2 46 2 47 dcl (FDUMP_TYPE init (1037), /* the various legitimate types of amu_info's */ 2 48 FDUMP_PROCESS_TYPE init (1038), 2 49 ONLINE_TYPE init (1039), 2 50 ONLINE_PROCESS_TYPE init (1040), 2 51 NETWORK_FDUMP_TYPE init (1041), 2 52 NETWORK_ONLINE_TYPE init (1042), 2 53 SAVED_PROC_TYPE init (1043), 2 54 INDIRECT_TYPE init (1044)) fixed bin internal static options (constant); 2 55 2 56 dcl AMU_INFO_VERSION_1 char (8) internal static options (constant) init ("amu_v1"); 2 57 dcl AMU_INFO_VERSION char (8) internal static options (constant) init ("amu_v1"); 2 58 dcl AMU_INFO_VERSION_2 char (8) internal static options (constant) init ("amu_v2"); 2 59 2 60 dcl PDIR_SUFFIX char(4) init("pdir") int static options(constant); 2 61 2 62 /* END INCLUDE FILE amu_info.incl.pl1 */ 304 305 306 307 end amu_do_translation_; 308 309 310 311 SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 07/28/87 0927.5 amu_do_translation_.pl1 >spec>install>MR12.1-1049>amu_do_translation_.pl1 302 1 07/28/87 0927.3 amu_translation.incl.pl1 >spec>install>MR12.1-1049>amu_translation.incl.pl1 304 2 11/20/84 0856.1 amu_info.incl.pl1 >ldd>include>amu_info.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. FDUMP_PROCESS_TYPE constant fixed bin(17,0) initial dcl 2-47 ref 155 289 FDUMP_TYPE constant fixed bin(17,0) initial dcl 2-47 ref 155 P_amu_info_ptr parameter pointer dcl 11 ref 6 64 72 79 87 98 106 P_buf_ptr parameter pointer dcl 15 ref 6 64 98 124 P_code parameter fixed bin(35,0) dcl 16 set ref 6 64 72 79 88* 90* 98 108* 111* 117* 165* 175* 187* 198* 204* 215* 226* 235* 247* 262* 272* P_offset parameter fixed bin(18,0) dcl 13 ref 6 64 127 P_range parameter fixed bin(18,0) dcl 14 set ref 6 64 98 123 195* 216* 223* 248* 263* 273* P_ret_ptr parameter pointer dcl 18 set ref 72 79 95* 197* 203* 225* 231* 233* P_seg_ptr parameter pointer dcl 17 ref 72 98 116 130 131 136 137 P_segno parameter fixed bin(17,0) dcl 12 ref 6 64 79 89 94 110 126 SAVED_PROC_TYPE constant fixed bin(17,0) initial dcl 2-47 ref 147 170 addr builtin function dcl 48 ref 142 153 284 addrel builtin function dcl 48 ref 203 213 231 233 245 256 259 271 amu_$dp_expand_to_ptr 000012 constant entry external dcl 40 ref 291 amu_$fdump_mpt_change_idx 000022 constant entry external dcl 44 ref 147 164 186 199 205 217 227 234 249 264 274 278 amu_$fdump_translate_get_translation 000020 constant entry external dcl 43 ref 156 amu_$get_name_ptr_count 000026 constant entry external dcl 46 ref 289 amu_$return_val_per_process 000024 constant entry external dcl 45 ref 145 amu_$translate_add 000016 constant entry external dcl 42 ref 181 amu_$translate_get 000014 constant entry external dcl 41 ref 150 amu_et_$invalid_segno 000032 external static fixed bin(35,0) dcl 51 ref 90 111 117 amu_et_$no_translation 000034 external static fixed bin(35,0) dcl 51 ref 152 amu_info based structure level 1 dcl 2-3 amu_info_ptr 000134 automatic pointer dcl 2-45 set ref 87* 106* 145* 146 147 147* 150* 155 155 156* 164* 170 181* 186* 199* 205* 217* 227* 234* 249* 264* 274* 278* 289 289* 291* baseno builtin function dcl 48 ref 116 130 136 baseptr builtin function dcl 48 ref 154 289 289 bit_count 000124 automatic fixed bin(24,0) dcl 37 set ref 289* 291* 297 buf based char unaligned dcl 31 set ref 214* 214 246* 246 257* 257 261* 261 271* 271 buf_ptr 000106 automatic pointer dcl 28 set ref 95* 124* 138* 214 246 257 259* 259 261 271 buf_size 000112 automatic fixed bin(24,0) dcl 30 set ref 212* 214 214 244* 246 246 255* 257 257 258* 261 261 270* 271 271 by_ptr_entry 000120 automatic bit(1) unaligned dcl 35 set ref 59* 69* 76* 86* 102* 109 125 code 000113 automatic fixed bin(35,0) dcl 32 set ref 150* 151 152 156* 158 161 165 173 175 181* 183 187 283* 293* divide builtin function dcl 48 ref 297 dump_data_ptr 000110 automatic pointer dcl 29 set ref 213* 214 245* 246 256* 257 260* 261 error_table_$out_of_bounds 000010 external static fixed bin(35,0) dcl 21 ref 198 226 error_table_$seg_not_found 000030 external static fixed bin(35,0) dcl 51 ref 293 fixed builtin function dcl 48 ref 116 130 131 136 137 flags 0(18) based structure level 2 packed unaligned dcl 1-24 set ref 286* hunt_entry 000117 automatic bit(1) unaligned dcl 35 set ref 60* 67* 74* 84* 100* 159 171 in_perm_seg 0(21) based bit(1) level 3 packed unaligned dcl 1-24 set ref 298* in_temp_seg 0(20) based bit(1) level 3 packed unaligned dcl 1-24 set ref 192 lth 4 based fixed bin(19,0) level 3 in structure "translation" dcl 1-24 in procedure "amu_do_translation_" set ref 221 288* lth 2 based fixed bin(19,0) level 3 in structure "translation" dcl 1-24 in procedure "amu_do_translation_" set ref 194 210 211 211 221 231 231 242 243 253 269 297* null builtin function dcl 48 ref 95 138 197 225 287 292 offset 000104 automatic fixed bin(18,0) dcl 26 set ref 93* 127* 131* 137* 194 203 210 211 211 213 222 231 231 233 240 241 241 242 243 245 253 256 269* 269 271 old_proc_idx 000100 automatic fixed bin(17,0) dcl 23 set ref 144* 146* 164 164* 186 186* 199 199* 205 205* 217 217* 227 227* 234 234* 249 249* 264 264* 274 274* 278 278* part1 1 based structure level 2 in structure "translation" dcl 1-24 in procedure "amu_do_translation_" part1 1 000125 automatic structure level 2 in structure "trans_space" unaligned dcl 38 in procedure "amu_do_translation_" part1 347 based structure array level 3 in structure "translation_table" dcl 1-13 in procedure "amu_do_translation_" part2 3 based structure level 2 dcl 1-24 process_idx 24 based fixed bin(17,0) level 2 dcl 2-3 ref 146 ptr 3 based pointer level 3 in structure "translation" packed unaligned dcl 1-24 in procedure "amu_do_translation_" set ref 231 260 271 287* ptr 1 based pointer level 3 in structure "translation" packed unaligned dcl 1-24 in procedure "amu_do_translation_" set ref 203 213 233 245 256 296* ptr_entry 000121 automatic bit(1) unaligned dcl 35 set ref 61* 68* 75* 85* 101* 122 195 202 216 223 230 range 000105 automatic fixed bin(18,0) dcl 27 set ref 93* 123* 135* 210* 211 211* 212 216 240* 241 241* 243 244 248 254 263 270 273 range_1 000114 automatic fixed bin(17,0) dcl 33 set ref 253* 254 255 259 range_2 000115 automatic fixed bin(17,0) dcl 33 set ref 254* 258 rel builtin function dcl 48 ref 131 137 seg_base_ptr 000102 automatic pointer dcl 25 set ref 154* 156* segno based fixed bin(18,0) level 2 in structure "translation" packed unsigned unaligned dcl 1-24 in procedure "amu_do_translation_" set ref 285* segno 000101 automatic fixed bin(17,0) dcl 24 in procedure "amu_do_translation_" set ref 94* 126* 130* 136* 145* 150* 154 181* 285 289 289 291 temp_ptr 000122 automatic pointer dcl 36 set ref 289* 291* 292 296 total_length 000116 automatic fixed bin(24,0) dcl 34 set ref 221* 222 240 241 241 trans_space 000125 automatic structure level 1 unaligned dcl 38 set ref 142 153 284 translation based structure level 1 dcl 1-24 translation_ptr 000132 automatic pointer dcl 1-40 set ref 142* 150* 153* 156* 181* 192 192 194 203 210 211 211 213 221 221 231 231 231 233 242 243 245 253 256 260 269 271 284* 285 286 287 288 296 297 298 two_part 0(18) based bit(1) level 3 packed unaligned dcl 1-24 set ref 192 type 3 based fixed bin(17,0) level 2 packed unaligned dcl 2-3 ref 147 155 155 170 289 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. AMU_INFO_VERSION internal static char(8) initial unaligned dcl 2-57 AMU_INFO_VERSION_1 internal static char(8) initial unaligned dcl 2-56 AMU_INFO_VERSION_2 internal static char(8) initial unaligned dcl 2-58 INDIRECT_TYPE internal static fixed bin(17,0) initial dcl 2-47 NETWORK_FDUMP_TYPE internal static fixed bin(17,0) initial dcl 2-47 NETWORK_ONLINE_TYPE internal static fixed bin(17,0) initial dcl 2-47 ONLINE_PROCESS_TYPE internal static fixed bin(17,0) initial dcl 2-47 ONLINE_TYPE internal static fixed bin(17,0) initial dcl 2-47 PDIR_SUFFIX internal static char(4) initial unaligned dcl 2-60 alloc_translation_table_max_entries automatic fixed bin(17,0) dcl 1-39 amu_area based area(1024) dcl 2-43 translation_table based structure level 1 dcl 1-13 NAMES DECLARED BY EXPLICIT CONTEXT. GET_IT 000300 constant label dcl 142 ref 96 add_trans 000461 constant label dcl 181 ref 161 173 amu_do_translation_ 000016 constant entry external dcl 6 amu_do_translation_$by_ptr 000154 constant entry external dcl 98 amu_do_translation_$hunt 000040 constant entry external dcl 64 amu_do_translation_$hunt_ptr 000066 constant entry external dcl 72 amu_do_translation_$ptr_given_segno 000110 constant entry external dcl 79 common_do 000175 constant label dcl 106 ref 62 70 77 103 hunt_for_seg 001156 constant entry internal dcl 280 ref 160 172 start_do 000516 constant label dcl 192 ref 183 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1574 1632 1305 1604 Length 2104 1305 36 236 267 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME amu_do_translation_ 153 external procedure is an external procedure. hunt_for_seg internal procedure shares stack frame of external procedure amu_do_translation_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME amu_do_translation_ 000100 old_proc_idx amu_do_translation_ 000101 segno amu_do_translation_ 000102 seg_base_ptr amu_do_translation_ 000104 offset amu_do_translation_ 000105 range amu_do_translation_ 000106 buf_ptr amu_do_translation_ 000110 dump_data_ptr amu_do_translation_ 000112 buf_size amu_do_translation_ 000113 code amu_do_translation_ 000114 range_1 amu_do_translation_ 000115 range_2 amu_do_translation_ 000116 total_length amu_do_translation_ 000117 hunt_entry amu_do_translation_ 000120 by_ptr_entry amu_do_translation_ 000121 ptr_entry amu_do_translation_ 000122 temp_ptr amu_do_translation_ 000124 bit_count amu_do_translation_ 000125 trans_space amu_do_translation_ 000132 translation_ptr amu_do_translation_ 000134 amu_info_ptr amu_do_translation_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out return_mac ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. amu_$dp_expand_to_ptr amu_$fdump_mpt_change_idx amu_$fdump_translate_get_translation amu_$get_name_ptr_count amu_$return_val_per_process amu_$translate_add amu_$translate_get THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. amu_et_$invalid_segno amu_et_$no_translation error_table_$out_of_bounds error_table_$seg_not_found LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 6 000010 59 000032 60 000033 61 000034 62 000035 64 000036 67 000054 68 000056 69 000057 70 000060 72 000061 74 000076 75 000100 76 000101 77 000102 79 000103 84 000120 85 000122 86 000123 87 000124 88 000130 89 000131 90 000134 91 000137 93 000140 94 000142 95 000143 96 000146 98 000147 100 000170 101 000171 102 000172 103 000174 106 000175 108 000201 109 000202 110 000206 111 000211 112 000214 114 000215 116 000216 117 000225 118 000230 122 000231 123 000233 124 000235 125 000240 126 000242 127 000245 128 000247 130 000250 131 000257 133 000262 135 000263 136 000264 137 000273 138 000276 142 000300 144 000302 145 000304 146 000322 147 000325 150 000343 151 000360 152 000362 153 000365 154 000367 155 000373 156 000403 158 000417 159 000421 160 000423 161 000424 164 000426 165 000441 166 000443 170 000444 171 000451 172 000453 173 000454 175 000456 176 000460 181 000461 183 000476 186 000500 187 000513 188 000515 192 000516 194 000524 195 000530 197 000534 198 000537 199 000542 200 000554 202 000555 203 000557 204 000564 205 000565 206 000601 210 000602 211 000607 212 000615 213 000620 214 000625 215 000632 216 000633 217 000640 218 000653 221 000654 222 000660 223 000662 225 000666 226 000671 227 000674 228 000706 230 000707 231 000711 233 000723 234 000731 235 000744 236 000745 240 000746 241 000753 242 000762 243 000765 244 000770 245 000773 246 001000 247 001005 248 001006 249 001010 250 001024 253 001025 254 001030 255 001033 256 001036 257 001043 258 001050 259 001053 260 001056 261 001060 262 001064 263 001065 264 001067 265 001103 269 001104 270 001106 271 001111 272 001122 273 001123 274 001125 275 001141 278 001142 307 001155 280 001156 283 001157 284 001160 285 001162 286 001165 287 001203 288 001205 289 001206 291 001235 292 001254 293 001260 294 001263 296 001264 297 001267 298 001272 299 001274 ----------------------------------------------------------- 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