COMPILATION LISTING OF SEGMENT print_instructions_ Compiled by: Multics PL/I Compiler, Release 31a, of October 12, 1988 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 10/24/88 1557.6 mst Mon Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1988 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 13 14 /****^ HISTORY COMMENTS: 15* 1) change(88-09-07,WAAnderson), approve(88-09-30,MCR7952), 16* audit(88-09-30,JRGray), install(88-10-24,MR12.2-1184): 17* Added format control comment to make the source more readable. 18* END HISTORY COMMENTS */ 19 20 21 /* format: style1,insnl,ifthendo,indthenelse,^indnoniterdo,^inditerdo,indcom,^indthenbegin,^indprocbody,ind2,ll78,initcol0,dclind4,idind24,struclvlind1,comcol41 */ 22 23 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 24 25 print_instructions_: 26 proc (P_data_ptr, P_count, P_switch); 27 28 /* prints P_count instructions starting at P_data_ptr on switch P_switch 29* 30* an instruction may be several words long 31* 32* James R. Davis 20 May 79 33* Modified 21 Sept 79 to print address and raw words, too. JRD 34* 35* FEATURES that it would be nice to put in someday: 36* decoding the special tags (used by puls1, puls2 s9bd, s6bd, s4bd, 37* sbd,stba,stbq,stca and stcq) 38* 39* showing either the address of the operand (for a tra, or pl1_operators_ ref) or i$ 40* the contents of the word addressed - one or two words, depending 41**/ 42 /* Fixed not to print more than P_count words despite multi-word instructions 09/01/83 S. Herbst */ 43 44 dcl P_data_ptr ptr parameter; 45 /* input: to probe_info structure */ 46 dcl P_count fixed bin parameter; 47 /* input: number of instructions to print */ 48 dcl P_switch ptr aligned parameter; 49 /* input: to switch */ 50 51 /* the following variables are used globally throughout - but not altered */ 52 dcl ip ptr; /* to current instruction's first word */ 53 dcl oswitch ptr; /* copy of P_switch */ 54 dcl op_index fixed bin;/* the op code, an index into instruction info tables */ 55 dcl op_code char (6) aligned; 56 /* mnemonic name of op_index */ 57 dcl number_of_words fixed bin;/* number of words in current instruction */ 58 dcl COLUMN_SPACING fixed bin internal static 59 options (constant) init (8); 60 /* bewteen op_code and address */ 61 62 dcl (addrel, char, divide, fixed, hbound, lbound, rel) 63 builtin; 64 dcl instruction_count fixed bin;/* number of the current instruction */ 65 66 dcl ( 67 ioa_$rsnnl, 68 ioa_$ioa_switch, 69 ioa_$ioa_switch_nnl 70 ) entry options (variable); 71 72 73 dcl 1 instr_pr aligned based (ip), 74 2 address unal, 75 3 pr fixed bin (3) unsigned unal, 76 3 offset fixed bin (14) unal, 77 2 opcode fixed bin (10) unsigned unal, 78 2 inhibit bit (1) unal, 79 2 use_pr bit (1) unal, 80 2 tag fixed bin (6) unsigned unal; 81 82 dcl 1 instr aligned based (ip), 83 2 address unal, 84 3 offset fixed bin (17), 85 2 opcode fixed bin (10) unsigned unal, 86 2 inhibit bit (1) unal, 87 2 use_pr bit (1) unal, 88 2 tag fixed bin (6) unsigned unal; 89 1 1 /* BEGIN INCLUDE FILE ... op_mnemonic_format.incl.pl1 1 2* 1 3* James R. Davis 20 May 79 */ 1 4 1 5 dcl 1 op_mnemonic_$op_mnemonic (0:1023) external static aligned, 1 6 2 opcode char (6) unal, 1 7 2 dtype fixed bin (2) unal, /* 0 = alpha, 1 = bit, 2 = numeric */ 1 8 2 num_desc fixed bin (5) unal, 1 9 2 num_words fixed bin (8) unal; 1 10 1 11 dcl modifier (0:63) char (3) aligned int static options (constant) init ( 1 12 " ", "au", "qu", "du", "ic", "al", "ql", "dl", 1 13 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", 1 14 "*", "au*", "qu*", "...", "ic*", "al*", "ql*", "...", 1 15 "x0*", "x1*", "x2*", "x3*", "x4*", "x5*", "x6*", "x7*", 1 16 "f", "itp", "...", "its", "sd", "scr", "f2", "f3", 1 17 "ci", "i", "sc", "ad", "di", "dic", "id", "idc", 1 18 "*n", "*au", "*qu", "*du", "*ic", "*al", "*ql", "*dl", 1 19 "*x0", "*x1", "*x2", "*x3", "*x4", "*x5", "*x6", "*x7"); 1 20 1 21 /* Note: if num_words = 1, then num_desc is a flag 1 22* if non0, the tag field of the instruction is to be interpreted specially 1 23* for example, stba or stca 1 24**/ 1 25 /* END INCLUDE FILE op_mnemonic_format.incl.pl1 */ 90 91 92 ip = P_data_ptr; 93 oswitch = P_switch; 94 95 do instruction_count = 1 to P_count; 96 97 op_index = ip -> instr.opcode; 98 op_code = op_mnemonic_$op_mnemonic (op_index).opcode; 99 number_of_words = op_mnemonic_$op_mnemonic (op_index).num_words; 100 101 if number_of_words > 1 /* must be EIS */ 102 then call disassemble_eis; 103 else if is_repeat_instr (op_code) 104 then call disassemble_repeat; 105 else call disassemble_normal; 106 107 ip = addrel (ip, number_of_words); 108 109 instruction_count = instruction_count + number_of_words - 1; 110 end; /* loop over N instructions */ 111 return; 112 113 114 disassemble_normal: 115 proc; 116 117 call print_addr_and_raw (ip); 118 call ioa_$ioa_switch (oswitch, " ^a^vt^a^[,^a^]", 119 op_code, 120 COLUMN_SPACING, 121 address_field (ip, (ip -> instr.use_pr)), 122 instr.tag ^= 0, tag_field ((instr.tag))); 123 124 /* add code to print what is pointed to */ 125 end disassemble_normal; 126 127 128 129 130 disassemble_repeat: 131 proc; 132 133 134 call print_addr_and_raw (ip); 135 call ioa_$ioa_switch (oswitch, 136 " ^a^[a^]^[b^]^[^vt^d^;x^vt^s^],^d^[,tze^]^,tmi^]^[,tpl^]^[,trc^]^[tnc^]", 137 op_code, 138 ip -> repeat_instr.a, 139 ip -> repeat_instr.b, 140 ip -> repeat_instr.use_tally, COLUMN_SPACING, ip -> repeat_instr.tally, 141 ip -> repeat_instr.delta, 142 ip -> repeat_instr.zero_on, 143 ip -> repeat_instr.zero_off, 144 ip -> repeat_instr.neg_on, 145 ip -> repeat_instr.neg_off, 146 ip -> repeat_instr.carry_on, /* CSNY ? */ 147 ip -> repeat_instr.carry_off); 148 149 dcl 1 repeat_instr aligned based, 150 2 tally fixed bin (8) unsigned unal, 151 2 a bit (1) unal, 152 2 b bit (1) unal, 153 2 use_tally bit (1) unal, 154 2 term_conditions unal, 155 3 zero_on bit (1) unal, 156 3 zero_off bit (1) unal, 157 3 neg_on bit (1) unal, 158 3 neg_off bit (1) unal, 159 3 carry_on bit (1) unal, 160 3 carry_off bit (1) unal, 161 2 process_overflow bit (1) unal, 162 2 opcode fixed bin (10) unsigned unal, 163 2 pad bit (2) unal, 164 2 delta fixed bin (6) unsigned unal; 165 166 end disassemble_repeat; 167 168 disassemble_eis: 169 proc; 170 171 dcl data_type fixed bin; 172 dcl ndesc fixed bin;/* how many descriptors it has */ 173 dcl ( 174 ALPHA_TYPE init (0), 175 BIT_TYPE init (1), 176 OTHER_TYPE init (2) 177 ) fixed bin internal static options (constant); 178 dcl dp ptr; /* to a descriptor */ 179 dcl descx fixed bin;/* index as we step over descriptors */ 180 181 dcl 1 eis_instr_all_descs aligned based (ip), 182 2 pad1 bit (2) unal, 183 2 mf3 unal like mod_factor, 184 2 enablefault bit (1) unal, 185 2 pad2 bit (1) unal, 186 2 mf2 unal like mod_factor, 187 2 pad3 bit (11) unal, 188 2 mf1 unal like mod_factor; 189 190 dcl 1 mod_factor aligned based, 191 2 ext_base bit (1) unal, 192 /* there is a pr number in address */ 193 2 length_in_reg bit (1) unal, 194 /* the length of the operand is in a reg */ 195 2 indirect_descriptor bit (1) unal, 196 /* the descriptor is an indirect ptr */ 197 2 tag fixed bin (4) unsigned unal; 198 199 dcl 1 eis_args_info (3) aligned like mod_factor; 200 201 ndesc = op_mnemonic_$op_mnemonic (op_index).num_desc; 202 data_type = op_mnemonic_$op_mnemonic (op_index).dtype; 203 if data_type > OTHER_TYPE 204 then data_type = OTHER_TYPE; 205 206 eis_args_info (1) = eis_instr_all_descs.mf1; 207 eis_args_info (2) = eis_instr_all_descs.mf2; 208 eis_args_info (3) = eis_instr_all_descs.mf3; 209 210 call print_addr_and_raw (ip); 211 call print_instr_word; 212 213 dp = ip; 214 do descx = 1 to number_of_words - 1; 215 dp = addrel (dp, 1); 216 call print_addr_and_raw (dp); 217 218 /* CASE on what kind of descriptor we have */ 219 220 if descx > ndesc /* it is an arg, not a desc */ 221 then call print_ind_desc (dp, eis_args_info (descx)); 222 else if eis_args_info (descx).indirect_descriptor 223 then call print_ind_desc (dp, eis_args_info (descx)); 224 else if desc_is_obscure (op_code, descx) 225 /* abnormal type, such as MOP ptr of mvne */ 226 then call print_obscure_desc (dp, eis_args_info (descx)); 227 else if data_type = ALPHA_TYPE 228 then call print_alpha_desc (dp, eis_args_info (descx)); 229 else if data_type = BIT_TYPE 230 then call print_bit_desc (dp, eis_args_info (descx)); 231 else call print_numeric_desc (dp, eis_args_info (descx)); 232 end; /* of loop over all descriptors */ 233 234 235 print_instr_word: 236 proc; 237 238 dcl descx fixed bin; 239 dcl need_comma bit (1) aligned; 240 dcl line char (256) varying; 241 /* holds output as built */ 242 dcl HT char (1) internal static options (constant) 243 init (" "); 244 245 dcl 1 eis_alpha_fill based (ip), 246 2 field bit (9) unal, 247 2 pad bit (27) unal; 248 249 dcl 1 eis_bit_fill based (ip), 250 2 field bit (1) unal, 251 2 pad bit (4) unal, 252 2 bolr fixed bin (4) unsigned unal, 253 2 pad1 bit (27) unal; 254 255 dcl 1 eis_numeric_fill aligned based (dp), 256 2 pad bit (10) unal, 257 2 round bit (1) unal, 258 2 pad2 bit (25) unal; 259 260 dcl bool_word (0:15) char (6) internal static 261 options (constant) init 262 ("clear", "and", "02", "03", "04", "05", "xor", 263 "or", 264 "10", "11", "12", "13", "invert", "15", "nand", 265 "set"); 266 267 line = op_code; 268 line = line || HT; 269 270 do descx = 1 to ndesc; 271 line = line || "("; 272 need_comma = "0"b; 273 274 if eis_args_info (descx).ext_base 275 then call add_option ("pr"); 276 if eis_args_info (descx).length_in_reg 277 then call add_option ("rl"); 278 if eis_args_info (descx).indirect_descriptor 279 then call add_option ("id"); 280 if eis_args_info (descx).tag ^= 0 281 then call add_option (tag_field ((eis_args_info (descx).tag))); 282 line = line || ")"; 283 284 if descx < ndesc /* more to come */ 285 then line = line || ","; 286 end; /* of loop over all MFs */ 287 288 if eis_instr_all_descs.enablefault 289 then line = line || ",enablefault"; 290 291 if data_type = ALPHA_TYPE 292 then do; 293 if has_fill (op_code) 294 then do; 295 line = line || ",fill("; 296 line = line || octalize (eis_alpha_fill.field); 297 line = line || ")"; 298 end; 299 else if has_mask (op_code) 300 then do; 301 line = line || ",mask("; 302 line = line || octalize (eis_alpha_fill.field); 303 line = line || ")"; 304 end; /* mask */ 305 end; /* ALPHA type */ 306 else if data_type = BIT_TYPE 307 then do; 308 line = line || ", fill ("; 309 line = line || char (eis_bit_fill.field); 310 line = line || ")"; 311 312 if has_boolean (op_code) then do; 313 line = line || ", bool ("; 314 line = line || bool_word (eis_bit_fill.bolr); 315 line = line || ")"; 316 end; /* bolr hacking */ 317 end; /* BIT type */ 318 else do; 319 if eis_numeric_fill.round 320 then line = line || ", round"; 321 end; /* NUMERIC */ 322 323 call ioa_$ioa_switch (oswitch, " ^a", line); 324 return; 325 326 add_option: 327 proc (c2); 328 329 330 dcl c2 char (2) aligned parameter; 331 332 if need_comma /* we have previously written in this MF, need a separator */ 333 then line = line || ","; 334 need_comma = "1"b; 335 line = line || c2; 336 end add_option; 337 338 339 octalize: 340 proc (b9) returns (char (3) aligned); 341 342 343 dcl c3 char (3) aligned; 344 dcl b9 bit (9) parameter; 345 346 call ioa_$rsnnl ("^.3b", c3, (0), b9); 347 return (c3); 348 end octalize; 349 350 351 end print_instr_word; 352 353 354 /* here are internal procedures to print the various kinds of descriptors- 355* obscure (which isn't nearly as clever as it ought to be) 356* indirect 357* alphanumeric 358* bit 359* numeric 360* 361**/ 362 363 print_obscure_desc: 364 proc (descp, mf); 365 366 dcl descp ptr parameter; 367 dcl 1 mf aligned parameter like mod_factor; 368 369 call ioa_$ioa_switch (oswitch, " too obscure a descriptor too decode"); 370 end print_obscure_desc; 371 372 373 print_ind_desc: 374 proc (descp, mf); 375 376 377 dcl descp ptr aligned parameter; 378 dcl 1 mf aligned parameter like mod_factor; 379 380 call ioa_$ioa_switch (oswitch, " arg^vt^a^[,^a^]", 381 COLUMN_SPACING, 382 address_field (descp, (mf.ext_base)), 383 descp -> instr.tag ^= 0, tag_field ((descp -> instr.tag))); 384 end print_ind_desc; 385 386 print_alpha_desc: 387 proc (descp, mf); 388 389 390 dcl descp ptr aligned parameter; 391 dcl 1 mf aligned parameter like mod_factor; 392 393 dcl alpha_types (0:3) char (1) internal static 394 options (constant) init ("9", "6", "4", "?"); 395 dcl NINE_BIT fixed bin internal static 396 options (constant) init (0); 397 398 dcl 1 alpha_desc aligned based (descp), 399 2 y bit (18) unal, 400 2 char_no fixed bin (3) unsigned unal, 401 2 type_code fixed bin (2) unsigned unal, 402 2 pad bit (1) unal, 403 2 length fixed bin (12) unsigned unal; 404 405 call ioa_$ioa_switch (oswitch, 406 " desc^aa^vt^a(^[^d^s^;^s^d^]),^[^a^s^;^s^d^]", 407 alpha_types (type_code), 408 COLUMN_SPACING, 409 address_field (descp, (mf.ext_base)), 410 alpha_desc.type_code = NINE_BIT, divide (char_no, 2, 17, 0), char_no, 411 mf.length_in_reg, tag_field ((alpha_desc.length)), alpha_desc.length); 412 end print_alpha_desc; 413 414 415 print_bit_desc: 416 proc (descp, mf); 417 418 419 dcl descp ptr aligned parameter; 420 dcl 1 mf aligned parameter like mod_factor; 421 422 dcl 1 bit_desc aligned based (descp), 423 2 y bit (18) unal, 424 2 char_no fixed bin (2) unsigned unal, 425 2 bit_no fixed bin (4) unsigned unal, 426 2 length fixed bin (12) unsigned unal; 427 428 call ioa_$ioa_switch (oswitch, " descb^vt^a(^d),^[^a^s^;^s^d^]", 429 COLUMN_SPACING, 430 address_field (descp, (mf.ext_base)), 431 char_no * 9 + bit_no, 432 mf.length_in_reg, 433 tag_field ((bit_desc.length)), 434 bit_desc.length); 435 end print_bit_desc; 436 437 438 print_numeric_desc: 439 proc (descp, mf); 440 441 442 dcl descp ptr aligned parameter; 443 /* aren't you getting bored? */ 444 dcl 1 mf aligned parameter like mod_factor; 445 446 dcl sign_name (0:3) char (2) aligned internal static 447 options (constant) 448 init ("fl", "ls", "ts", "ns"); 449 450 dcl 1 numeric_desc aligned based (descp), 451 2 y bit (18) unal, 452 2 char_no fixed bin (3) unsigned unal, 453 2 type4 bit (1) unal, 454 2 sign_type fixed bin (2) unsigned unal, 455 2 scale_factor fixed bin (5) unal, 456 2 length fixed bin (6) unsigned unal; 457 458 call ioa_$ioa_switch (oswitch, 459 " desc^[4^;9^]^a^vt^a(^[^d^s^;^s^d^]),^[^a^s^;^s^d^]^[,^d^]", 460 numeric_desc.type4, /* which type ? */ 461 sign_name (numeric_desc.sign_type), 462 COLUMN_SPACING, 463 address_field (descp, (mf.ext_base)), 464 type4, numeric_desc.length, divide (numeric_desc.length, 2, 17, 0), 465 mf.length_in_reg, tag_field ((numeric_desc.length)), 466 numeric_desc.length, 467 scale_factor ^= 0, scale_factor); 468 end print_numeric_desc; 469 470 471 desc_is_obscure: 472 proc (op_name, desc_no) returns (bit (1) aligned); 473 474 475 /* for certain ops, one of the descriptors will not be of the expected type */ 476 477 dcl op_name char (6) aligned parameter; 478 dcl desc_no fixed bin parameter; 479 /* input, which desc */ 480 481 return ( 482 (op_name = "btd" & desc_no = 1) | 483 (op_name = "dtb" & desc_no = 2) | 484 (op_name = "mvne" & desc_no = 2) 485 ); 486 end desc_is_obscure; 487 end disassemble_eis; 488 489 490 /* miscellaneous useful things */ 491 492 493 print_addr_and_raw: 494 proc (p); 495 496 497 dcl p ptr parameter; 498 dcl based_word bit (36) aligned based (p); 499 call ioa_$ioa_switch_nnl (oswitch, " ^6o ^w", 500 fixed (rel (p), 18, 0), based_word); 501 end print_addr_and_raw; 502 503 address_field: 504 proc (p, use_pr) returns (char (10) aligned); 505 506 507 dcl p ptr aligned parameter; 508 /* to instruction */ 509 dcl use_pr bit (1) aligned parameter; 510 /* which format is it ? */ 511 dcl rs char (9) aligned; 512 call ioa_$rsnnl ("^[pr^d|^d^s^;^s^s^d^]", rs, (0), 513 use_pr, p -> instr_pr.address.pr, p -> instr_pr.address.offset, 514 p -> instr.address.offset); 515 return (rs); 516 517 end address_field; 518 519 520 521 tag_field: 522 proc (tag) returns (char (3) aligned); 523 524 525 /* this proc exists to isolate references to the modifier data base - 526* hope to make it part of op_mnemonic some day */ 527 528 dcl tag fixed bin parameter; 529 530 if tag < lbound (modifier, 1) | tag > hbound (modifier, 1) 531 then return ("bad"); 532 else return (modifier (tag)); 533 end tag_field; 534 535 536 /* predicates on instruction types */ 537 538 is_repeat_instr: 539 proc (op_name) returns (bit (1) aligned); 540 541 542 dcl op_name char (6) aligned parameter; 543 544 return (op_name = "rpd" | op_name = "rpl" | op_name = "rpt"); 545 546 is_tra_instr: 547 entry (op_name) returns (bit (1) aligned); 548 549 return ( 550 op_name = "teo" | op_name = "teu" | op_name = "tmi" 551 | op_name = "tmoz" | op_name = "tnc" | 552 op_name = "tnz" | op_name = "tov" | op_name = "tpl" 553 | op_name = "tpnz" | op_name = "tra" | 554 op_name = "trc" | op_name = "trtf" | op_name = "trtm" 555 | op_name = "tsp0" | op_name = "tsp1" | 556 op_name = "tsp2" | op_name = "tsp3" | op_name = "tsp4" 557 | op_name = "tsp5" | op_name = "tsp6" | 558 op_name = "tsp7" | op_name = "tss" | op_name = "tsx0" 559 | op_name = "tsx1" | op_name = "tsx2" | 560 op_name = "tsx3" | op_name = "tsx4" | op_name = "tsx5" 561 | op_name = "tsx6" | op_name = "tsx7" | 562 op_name = "ttf" | op_name = "ttm" | op_name = "tze"); 563 564 is_double_instr: 565 entry (op_name) returns (bit (1) aligned); 566 567 return (op_name = "adaq" | op_name = "adlaq" | op_name = "anaq" 568 | op_name = "canaq" | 569 op_name = "cmpaq" | op_name = "cnaaq" | 570 571 /* need all the df?? ops */ 572 573 op_name = "eaq" | op_name = "epaq" | op_name = "eraq" 574 | op_name = "lcaq" | op_name = "ldaq" | 575 op_name = "oraq" | op_name = "sbaq" | op_name = "sblaq" 576 | op_name = "staq"); 577 578 579 has_fill: 580 entry (op_name) returns (bit (1) aligned); 581 582 return (op_name = "cmpc" | op_name = "mlr" | op_name = "mvt"); 583 584 has_boolean: 585 entry (op_name) returns (bit (1) aligned); 586 587 return (op_name = "csl" | op_name = "csr" | op_name = "sztl" 588 | op_name = "sztr"); 589 590 has_mask: 591 entry (op_name) returns (bit (1) aligned); 592 593 return (op_name = "scm"); 594 595 596 end; /* is_XXXXX_instr */ 597 598 599 end print_instructions_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/24/88 1340.3 print_instructions_.pl1 >special_ldd>install>MR12.2-1184>print_instructions_.pl1 90 1 11/26/79 1320.6 op_mnemonic_format.incl.pl1 >ldd>include>op_mnemonic_format.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. ALPHA_TYPE constant fixed bin(17,0) initial dcl 173 ref 227 291 BIT_TYPE constant fixed bin(17,0) initial dcl 173 ref 229 306 COLUMN_SPACING 000256 constant fixed bin(17,0) initial dcl 58 set ref 118* 135* 380* 405* 428* 458* HT 004106 constant char(1) initial packed unaligned dcl 242 ref 268 NINE_BIT constant fixed bin(17,0) initial dcl 395 ref 405 OTHER_TYPE constant fixed bin(17,0) initial dcl 173 ref 203 203 P_count parameter fixed bin(17,0) dcl 46 ref 25 95 P_data_ptr parameter pointer dcl 44 ref 25 92 P_switch parameter pointer dcl 48 ref 25 93 a 0(08) based bit(1) level 2 packed packed unaligned dcl 149 set ref 135* addrel builtin function dcl 62 ref 107 215 address based structure level 2 in structure "instr" packed packed unaligned dcl 82 in procedure "print_instructions_" address based structure level 2 in structure "instr_pr" packed packed unaligned dcl 73 in procedure "print_instructions_" alpha_desc based structure level 1 dcl 398 alpha_types 000004 constant char(1) initial array packed unaligned dcl 393 set ref 405* b 0(09) based bit(1) level 2 packed packed unaligned dcl 149 set ref 135* b9 parameter bit(9) packed unaligned dcl 344 set ref 339 346* based_word based bit(36) dcl 498 set ref 499* bit_desc based structure level 1 dcl 422 bit_no 0(20) based fixed bin(4,0) level 2 packed packed unsigned unaligned dcl 422 ref 428 bolr 0(05) based fixed bin(4,0) level 2 packed packed unsigned unaligned dcl 249 ref 314 bool_word 000005 constant char(6) initial array packed unaligned dcl 260 ref 314 c2 parameter char(2) dcl 330 ref 326 335 c3 000276 automatic char(3) dcl 343 set ref 346* 347 carry_off 0(16) based bit(1) level 3 packed packed unaligned dcl 149 set ref 135* carry_on 0(15) based bit(1) level 3 packed packed unaligned dcl 149 set ref 135* char builtin function dcl 62 ref 309 char_no 0(18) based fixed bin(2,0) level 2 in structure "bit_desc" packed packed unsigned unaligned dcl 422 in procedure "print_bit_desc" ref 428 char_no 0(18) based fixed bin(3,0) level 2 in structure "alpha_desc" packed packed unsigned unaligned dcl 398 in procedure "print_alpha_desc" set ref 405 405 405* data_type 000136 automatic fixed bin(17,0) dcl 171 set ref 202* 203 203* 227 229 291 306 delta 0(30) based fixed bin(6,0) level 2 packed packed unsigned unaligned dcl 149 set ref 135* desc_no parameter fixed bin(17,0) dcl 478 ref 471 481 481 481 descp parameter pointer dcl 377 in procedure "print_ind_desc" set ref 373 380* 380* 380 380 380 descp parameter pointer dcl 442 in procedure "print_numeric_desc" set ref 438 458 458 458* 458* 458 458 458 458 458 458 458 458 458 descp parameter pointer dcl 419 in procedure "print_bit_desc" set ref 415 428* 428* 428 428 428 428 428 descp parameter pointer dcl 390 in procedure "print_alpha_desc" set ref 386 405 405* 405* 405 405 405 405 405 405 405 descp parameter pointer dcl 366 in procedure "print_obscure_desc" ref 363 descx 000142 automatic fixed bin(17,0) dcl 179 in procedure "disassemble_eis" set ref 214* 220 220 222 222 224* 224 227 229 231* descx 000156 automatic fixed bin(17,0) dcl 238 in procedure "print_instr_word" set ref 270* 274 276 278 280 280 280 284* divide builtin function dcl 62 ref 405 405 458 458 dp 000140 automatic pointer dcl 178 set ref 213* 215* 215 216* 220* 222* 224* 227* 229* 231* 319 dtype 1(18) 000016 external static fixed bin(2,0) array level 2 packed packed unaligned dcl 1-5 ref 202 eis_alpha_fill based structure level 1 packed packed unaligned dcl 245 eis_args_info 000143 automatic structure array level 1 dcl 199 set ref 206* 207* 208* 220* 222* 224* 227* 229* 231* eis_bit_fill based structure level 1 packed packed unaligned dcl 249 eis_instr_all_descs based structure level 1 dcl 181 eis_numeric_fill based structure level 1 dcl 255 enablefault 0(09) based bit(1) level 2 packed packed unaligned dcl 181 ref 288 ext_base 000143 automatic bit(1) array level 2 in structure "eis_args_info" packed packed unaligned dcl 199 in procedure "disassemble_eis" set ref 274 ext_base parameter bit(1) level 2 in structure "mf" packed packed unaligned dcl 444 in procedure "print_numeric_desc" ref 458 458 ext_base parameter bit(1) level 2 in structure "mf" packed packed unaligned dcl 420 in procedure "print_bit_desc" ref 428 428 ext_base parameter bit(1) level 2 in structure "mf" packed packed unaligned dcl 391 in procedure "print_alpha_desc" ref 405 405 ext_base parameter bit(1) level 2 in structure "mf" packed packed unaligned dcl 378 in procedure "print_ind_desc" ref 380 380 field based bit(1) level 2 in structure "eis_bit_fill" packed packed unaligned dcl 249 in procedure "print_instr_word" ref 309 field based bit(9) level 2 in structure "eis_alpha_fill" packed packed unaligned dcl 245 in procedure "print_instr_word" set ref 296* 302* fixed builtin function dcl 62 ref 499 499 hbound builtin function dcl 62 ref 530 indirect_descriptor 0(02) 000143 automatic bit(1) array level 2 packed packed unaligned dcl 199 set ref 222 278 instr based structure level 1 dcl 82 instr_pr based structure level 1 dcl 73 instruction_count 000111 automatic fixed bin(17,0) dcl 64 set ref 95* 109* 109* ioa_$ioa_switch 000012 constant entry external dcl 66 ref 118 135 323 369 380 405 428 458 ioa_$ioa_switch_nnl 000014 constant entry external dcl 66 ref 499 ioa_$rsnnl 000010 constant entry external dcl 66 ref 346 512 ip 000100 automatic pointer dcl 52 set ref 92* 97 107* 107 117* 118* 118 118* 118 118 118 118 134* 135 135 135 135 135 135 135 135 135 135 135 206 207 208 210* 213 288 296 302 309 314 lbound builtin function dcl 62 ref 530 length 0(30) based fixed bin(6,0) level 2 in structure "numeric_desc" packed packed unsigned unaligned dcl 450 in procedure "print_numeric_desc" set ref 458* 458 458 458 458 458* length 0(24) based fixed bin(12,0) level 2 in structure "bit_desc" packed packed unsigned unaligned dcl 422 in procedure "print_bit_desc" set ref 428 428 428* length 0(24) based fixed bin(12,0) level 2 in structure "alpha_desc" packed packed unsigned unaligned dcl 398 in procedure "print_alpha_desc" set ref 405 405 405* length_in_reg 0(01) 000143 automatic bit(1) array level 2 in structure "eis_args_info" packed packed unaligned dcl 199 in procedure "disassemble_eis" set ref 276 length_in_reg 0(01) parameter bit(1) level 2 in structure "mf" packed packed unaligned dcl 444 in procedure "print_numeric_desc" set ref 458* length_in_reg 0(01) parameter bit(1) level 2 in structure "mf" packed packed unaligned dcl 391 in procedure "print_alpha_desc" set ref 405* length_in_reg 0(01) parameter bit(1) level 2 in structure "mf" packed packed unaligned dcl 420 in procedure "print_bit_desc" set ref 428* line 000160 automatic varying char(256) dcl 240 set ref 267* 268* 268 271* 271 282* 282 284* 284 288* 288 295* 295 296* 296 297* 297 301* 301 302* 302 303* 303 308* 308 309* 309 310* 310 313* 313 314* 314 315* 315 319* 319 323* 332* 332 335* 335 mf parameter structure level 1 dcl 367 in procedure "print_obscure_desc" ref 363 mf parameter structure level 1 dcl 378 in procedure "print_ind_desc" ref 373 mf parameter structure level 1 dcl 444 in procedure "print_numeric_desc" set ref 438 mf parameter structure level 1 dcl 420 in procedure "print_bit_desc" set ref 415 mf parameter structure level 1 dcl 391 in procedure "print_alpha_desc" set ref 386 mf1 0(29) based structure level 2 packed packed unaligned dcl 181 ref 206 mf2 0(11) based structure level 2 packed packed unaligned dcl 181 ref 207 mf3 0(02) based structure level 2 packed packed unaligned dcl 181 ref 208 mod_factor based structure level 1 dcl 190 modifier 000035 constant char(3) initial array dcl 1-11 ref 530 530 532 ndesc 000137 automatic fixed bin(17,0) dcl 172 set ref 201* 220 270 284 need_comma 000157 automatic bit(1) dcl 239 set ref 272* 332 334* neg_off 0(14) based bit(1) level 3 packed packed unaligned dcl 149 set ref 135* neg_on 0(13) based bit(1) level 3 packed packed unaligned dcl 149 set ref 135* num_desc 1(21) 000016 external static fixed bin(5,0) array level 2 packed packed unaligned dcl 1-5 ref 201 num_words 1(27) 000016 external static fixed bin(8,0) array level 2 packed packed unaligned dcl 1-5 ref 99 number_of_words 000110 automatic fixed bin(17,0) dcl 57 set ref 99* 101 107 109 214 numeric_desc based structure level 1 dcl 450 offset based fixed bin(17,0) level 3 in structure "instr" packed packed unaligned dcl 82 in procedure "print_instructions_" set ref 512* offset 0(03) based fixed bin(14,0) level 3 in structure "instr_pr" packed packed unaligned dcl 73 in procedure "print_instructions_" set ref 512* op_code 000106 automatic char(6) dcl 55 set ref 98* 103* 118* 135* 224* 267 293* 299* 312* op_index 000104 automatic fixed bin(17,0) dcl 54 set ref 97* 98 99 201 202 op_mnemonic_$op_mnemonic 000016 external static structure array level 1 dcl 1-5 op_name parameter char(6) dcl 477 in procedure "desc_is_obscure" ref 471 481 481 481 op_name parameter char(6) dcl 542 in procedure "is_repeat_instr" ref 538 544 544 544 546 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 549 564 567 567 567 567 567 567 567 567 567 567 567 567 567 567 567 579 582 582 582 584 587 587 587 587 590 593 opcode 000016 external static char(6) array level 2 in structure "op_mnemonic_$op_mnemonic" packed packed unaligned dcl 1-5 in procedure "print_instructions_" ref 98 opcode 0(18) based fixed bin(10,0) level 2 in structure "instr" packed packed unsigned unaligned dcl 82 in procedure "print_instructions_" ref 97 oswitch 000102 automatic pointer dcl 53 set ref 93* 118* 135* 323* 369* 380* 405* 428* 458* 499* p parameter pointer dcl 507 in procedure "address_field" ref 503 512 512 512 p parameter pointer dcl 497 in procedure "print_addr_and_raw" ref 493 499 499 499 pr based fixed bin(3,0) level 3 packed packed unsigned unaligned dcl 73 set ref 512* rel builtin function dcl 62 ref 499 499 repeat_instr based structure level 1 dcl 149 round 0(10) based bit(1) level 2 packed packed unaligned dcl 255 ref 319 rs 000360 automatic char(9) dcl 511 set ref 512* 515 scale_factor 0(24) based fixed bin(5,0) level 2 packed packed unaligned dcl 450 set ref 458 458* sign_name 000000 constant char(2) initial array dcl 446 set ref 458* sign_type 0(22) based fixed bin(2,0) level 2 packed packed unsigned unaligned dcl 450 ref 458 tag 0(03) 000143 automatic fixed bin(4,0) array level 2 in structure "eis_args_info" packed packed unsigned unaligned dcl 199 in procedure "disassemble_eis" set ref 280 280 280 tag 0(30) based fixed bin(6,0) level 2 in structure "instr" packed packed unsigned unaligned dcl 82 in procedure "print_instructions_" ref 118 118 118 380 380 380 tag parameter fixed bin(17,0) dcl 528 in procedure "tag_field" ref 521 530 530 532 tally based fixed bin(8,0) level 2 packed packed unsigned unaligned dcl 149 set ref 135* term_conditions 0(11) based structure level 2 packed packed unaligned dcl 149 type4 0(21) based bit(1) level 2 packed packed unaligned dcl 450 set ref 458* 458* type_code 0(21) based fixed bin(2,0) level 2 packed packed unsigned unaligned dcl 398 ref 405 405 use_pr parameter bit(1) dcl 509 in procedure "address_field" set ref 503 512* use_pr 0(29) based bit(1) level 2 in structure "instr" packed packed unaligned dcl 82 in procedure "print_instructions_" ref 118 118 use_tally 0(10) based bit(1) level 2 packed packed unaligned dcl 149 set ref 135* zero_off 0(12) based bit(1) level 3 packed packed unaligned dcl 149 set ref 135* zero_on 0(11) based bit(1) level 3 packed packed unaligned dcl 149 set ref 135* NAMES DECLARED BY EXPLICIT CONTEXT. add_option 001704 constant entry internal dcl 326 ref 274 276 278 280 address_field 002673 constant entry internal dcl 503 ref 118 118 380 380 405 405 428 428 458 458 desc_is_obscure 002560 constant entry internal dcl 471 ref 224 disassemble_eis 000766 constant entry internal dcl 168 ref 101 disassemble_normal 000552 constant entry internal dcl 114 ref 105 disassemble_repeat 000642 constant entry internal dcl 130 ref 103 has_boolean 003702 constant entry internal dcl 584 ref 312 has_fill 003642 constant entry internal dcl 579 ref 293 has_mask 003752 constant entry internal dcl 590 ref 299 is_double_instr 003447 constant entry internal dcl 564 is_repeat_instr 002770 constant entry internal dcl 538 ref 103 is_tra_instr 003027 constant entry internal dcl 546 octalize 001735 constant entry internal dcl 339 ref 296 302 print_addr_and_raw 002632 constant entry internal dcl 493 ref 117 134 210 216 print_alpha_desc 002114 constant entry internal dcl 386 ref 227 print_bit_desc 002260 constant entry internal dcl 415 ref 229 print_ind_desc 002020 constant entry internal dcl 373 ref 220 222 print_instr_word 001241 constant entry internal dcl 235 ref 211 print_instructions_ 000457 constant entry external dcl 25 print_numeric_desc 002377 constant entry internal dcl 438 ref 231 print_obscure_desc 001775 constant entry internal dcl 363 ref 224 tag_field 002754 constant entry internal dcl 521 ref 118 118 280 280 380 380 405 405 428 428 458 458 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 4176 4216 4112 4206 Length 4420 4112 20 166 64 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME print_instructions_ 972 external procedure is an external procedure. disassemble_normal internal procedure shares stack frame of external procedure print_instructions_. disassemble_repeat internal procedure shares stack frame of external procedure print_instructions_. disassemble_eis internal procedure shares stack frame of external procedure print_instructions_. print_instr_word internal procedure shares stack frame of external procedure print_instructions_. add_option internal procedure shares stack frame of external procedure print_instructions_. octalize internal procedure shares stack frame of external procedure print_instructions_. print_obscure_desc internal procedure shares stack frame of external procedure print_instructions_. print_ind_desc internal procedure shares stack frame of external procedure print_instructions_. print_alpha_desc internal procedure shares stack frame of external procedure print_instructions_. print_bit_desc internal procedure shares stack frame of external procedure print_instructions_. print_numeric_desc internal procedure shares stack frame of external procedure print_instructions_. desc_is_obscure internal procedure shares stack frame of external procedure print_instructions_. print_addr_and_raw internal procedure shares stack frame of external procedure print_instructions_. address_field internal procedure shares stack frame of external procedure print_instructions_. tag_field internal procedure shares stack frame of external procedure print_instructions_. is_repeat_instr internal procedure shares stack frame of external procedure print_instructions_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME print_instructions_ 000100 ip print_instructions_ 000102 oswitch print_instructions_ 000104 op_index print_instructions_ 000106 op_code print_instructions_ 000110 number_of_words print_instructions_ 000111 instruction_count print_instructions_ 000136 data_type disassemble_eis 000137 ndesc disassemble_eis 000140 dp disassemble_eis 000142 descx disassemble_eis 000143 eis_args_info disassemble_eis 000156 descx print_instr_word 000157 need_comma print_instr_word 000160 line print_instr_word 000276 c3 octalize 000360 rs address_field THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as r_ne_as call_ext_out_desc return_mac ext_entry any_to_any_truncate_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. ioa_$ioa_switch ioa_$ioa_switch_nnl ioa_$rsnnl THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. op_mnemonic_$op_mnemonic LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 25 000453 92 000464 93 000470 95 000473 97 000503 98 000507 99 000517 101 000524 103 000530 105 000537 107 000540 109 000544 110 000547 111 000551 114 000552 117 000553 118 000555 125 000641 130 000642 134 000643 135 000645 166 000765 168 000766 201 000767 202 001000 203 001004 206 001010 207 001034 208 001060 210 001104 211 001106 213 001107 214 001111 215 001121 216 001124 220 001126 222 001142 224 001156 227 001175 229 001211 231 001225 232 001236 487 001240 235 001241 267 001242 268 001250 270 001257 271 001267 272 001276 274 001277 276 001307 278 001317 280 001327 282 001344 284 001353 286 001365 288 001367 291 001404 293 001406 295 001413 296 001425 297 001447 298 001456 299 001457 301 001464 302 001476 303 001520 305 001527 306 001530 308 001532 309 001544 310 001563 312 001572 313 001577 314 001611 315 001633 317 001642 319 001643 323 001660 324 001703 326 001704 332 001706 334 001717 335 001721 336 001734 339 001735 346 001737 347 001770 363 001775 369 001777 370 002017 373 002020 380 002022 384 002113 386 002114 405 002116 412 002257 415 002260 428 002262 435 002376 438 002377 458 002401 468 002557 471 002560 481 002562 493 002632 499 002634 501 002672 503 002673 512 002675 515 002746 521 002754 530 002756 532 002765 538 002770 544 002772 546 003027 549 003031 564 003447 567 003451 579 003642 582 003644 584 003702 587 003704 590 003752 593 003754 ----------------------------------------------------------- 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