COMPILATION LISTING OF SEGMENT print_text_ Compiled by: Multics PL/I Compiler, Release 28e, of February 14, 1985 Compiled at: Honeywell Multics Op. - System M Compiled on: 02/19/86 1047.2 mst Wed Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 12 13 /****^ HISTORY COMMENTS: 14* 1) change(85-05-13,Farley), approve(85-05-13,MCR7242), 15* audit(85-05-13,Fawcett), install(86-02-19,MR12.0-1019): 16* Added EIS Indirect Descriptors. 17* END HISTORY COMMENTS */ 18 19 20 /* Program to display output text produced by pl/1 and Fortran. A reduced version of 21* display_text. Numbers in the disassembled instruction are decimal. The offset and 22* the instruction as it apears in core are in octal. 23* 24* The numbers are really in octal, despite comment. Modified by JRDavis 19 Mar 80 25* to not call binoct (which was transfer vector to pl1 compiler lang_util_ MCR 4422 26* Modified April 1985 by Paul Farley to add EIS Indirect Descriptors. 27**/ 28 29 print_text_: proc (t_pt, arg_number, output_switch); 30 31 dcl t_pt ptr, /* points at text base */ 32 arg_number fixed bin, /* max. no. of words to print */ 33 output_switch char (*) aligned, /* switch name for printing disassembled line */ 34 arg_offset fixed bin (18), /* real offset to be printed instead of t_pt */ 35 arg_string char (*) var; /* output. Contains formatted instruction */ 36 37 38 dcl number fixed bin; /* no. of words to print */ 39 dcl desc_type fixed bin; /* descriptor type: 0 = alpha, 1 = bit, 2 = numeric */ 40 dcl comment char (50) var; 41 dcl op_name char (32) aligned; 42 dcl (p, pt) ptr, 43 (no_to_print, j, k, m, op_index, irand, nrands, ndesc) fixed bin, 44 (fract_offset, offset, scale) fixed bin (18), 45 (double, eis, eis_desc, need_comma, ext_base, has_ic, decimal, ind_desc) bit (1), 46 ht char (1) int static aligned init (" "), /* tab */ 47 htht char (2) int static aligned init (" "), /* two tabs */ 48 cstring char (12), 49 op_code char (5), 50 tag char (3), 51 line char (256), 52 buff char (12) varying, 53 pl1_operators_$operator_table fixed bin ext; 54 55 dcl repeat_inst bit (1); /* ON for rpd, rpt, rpl */ 56 dcl print_instr bit (1); /* 1= print instr; 0= return formatted string */ 57 dcl real_offset_entry bit (1) unal; /* ON if instruction ptr is different from text location */ 58 dcl real_offset fixed bin (18); /* used with $format, $offset entries */ 59 dcl ioa_$ioa_stream ext entry options (variable); 60 dcl ioa_$rsnnl ext entry options (variable); 61 dcl find_operator_name_ entry (char (*) aligned, ptr, char (32) aligned); 62 63 dcl (addr, addrel, fixed, length, ptr, rel, string, substr) builtin; 64 65 66 dcl 1 op_mnemonic_$op_mnemonic (0:1023) ext static aligned, 67 2 opcode char (6) unal, 68 2 dtype fixed bin (2) unal, /* 0 = alpha, 1 = bit, 2 = numeric */ 69 2 num_desc fixed bin (5) unal, 70 2 num_words fixed bin (8) unal; 71 72 73 dcl digit (0:9) char (1) aligned int static 74 init ("0", "1", "2", "3", "4", "5", "6", "7", "8", "9"); 75 76 77 dcl base (0:7) char (4) aligned int static 78 init ("pr0|", "pr1|", "pr2|", "pr3|", "pr4|", "pr5|", "pr6|", "pr7|"); 79 80 dcl modifier (0:63) char (3) aligned int static 81 init (" ", "au", "qu", "du", "ic", "al", "ql", "dl", 82 "0", "1", "2", "3", "4", "5", "6", "7", 83 "*", "au*", "qu*", "...", "ic*", "al*", "ql*", "...", 84 "0*", "1*", "2*", "3*", "4*", "5*", "6*", "7*", 85 "f", "itp", "...", "its", "sd", "scr", "f2", "f3", 86 "ci", "i", "sc", "ad", "di", "dic", "id", "idc", 87 "*n", "*au", "*qu", "*du", "*ic", "*al", "*ql", "*dl", 88 "*0", "*1", "*2", "*3", "*4", "*5", "*6", "*7"); 89 90 dcl word (0:1) bit (36) aligned based (p); 91 92 dcl 1 instruction based (p) aligned, 93 2 base unaligned bit (3), 94 2 offset unaligned bit (15), 95 2 op_code unaligned bit (10), 96 2 inhibit unaligned bit (1), 97 2 ext_base unaligned bit (1), 98 2 tag unaligned bit (6); 99 100 dcl 1 half based (p) aligned, 101 2 left unaligned bit (18), 102 2 right unaligned bit (18); 103 104 dcl 1 mod_factor aligned, 105 2 ext_base bit (1) unal, 106 2 length_in_reg bit (1) unal, 107 2 indirect_descriptor bit (1) unal, 108 2 tag bit (4) unal; 109 110 dcl mf (3) fixed bin (6) int static init (30, 12, 3); /* location of modification factor fields in EIS inst */ 111 112 dcl (ebase, len_reg, idesc, ic) (3) bit (1) aligned; 113 dcl desc_word char (8) varying; 114 115 dcl desc_op (0:3) char (8) varying int static init ("desc9a", "descb", "desc9fl", "desc9ls"); 116 117 dcl eis_modifier (0:15) char (3) aligned int static 118 init ("n", "au", "qu", "du", "ic", "al", "ql", "...", 119 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7"); 120 121 dcl bool_word (0:15) char (6) aligned int static varying 122 init ("clear", "and", "andnot", "move", "", "", "xor", "or", 123 "", "", "", "", "invert", "", "nand", "set"); 124 125 dcl 1 descriptor based aligned, /* EIS descriptor */ 126 2 address bit (18) unal, 127 2 char bit (2) unal, 128 2 bit bit (4) unal, 129 2 length bit (12) unal; 130 131 /* */ 132 133 number = arg_number; 134 print_instr = "1"b; 135 real_offset_entry = "0"b; 136 p = t_pt; 137 138 begin: substr (line, 11, 3) = " "; 139 eis = "0"b; 140 irand = 0; 141 142 do no_to_print = 1 to number; 143 144 comment = ""; 145 tag = " "; 146 substr (line, 7, 2) = " "; 147 cstring = binoct (p -> word (0)); 148 149 if eis then op_index = 0; 150 151 else do; 152 op_index = fixed (p -> instruction.op_code, 10); 153 op_code = opcode (op_index); 154 end; 155 156 if num_words (op_index) > 1 then call eis_instruction; 157 158 else do; 159 has_ic, double, repeat_inst = "0"b; 160 161 eis_desc = eis & (ind_desc | desc_word ^= "arg"); 162 if eis_desc then call eis_descriptor; 163 164 else do; 165 substr (line, 13, 2) = " "; 166 substr (line, 15, 6) = substr (cstring, 2, 5); 167 substr (line, 21, 5) = substr (cstring, 7, 4); 168 substr (line, 26, 8) = substr (cstring, 11, 2) || ht || op_code; 169 k = 34; 170 171 ext_base = p -> instruction.ext_base; 172 173 if op_code = "rpd " | op_code = "rpt " | op_code = "rpl " then do; 174 repeat_inst = "1"b; 175 call ioa_$rsnnl ("^d", tag, j, fixed (p -> instruction.tag, 6)); 176 offset = fixed (substr (p -> half.left, 1, 8), 8); 177 substr (line, 14, 1) = cstring; 178 call ioa_$rsnnl (" ^d", buff, j, offset); 179 substr (line, k, j) = buff; 180 k = k + j; 181 end; 182 183 else do; 184 if num_desc (op_index) ^= 0 then 185 tag = substr (binoct ((p -> instruction.tag)), 1, 2); 186 187 else do; 188 if p -> instruction.tag then tag = modifier (fixed (p -> instruction.tag, 6)); 189 double = substr (op_code, 1, 2) = "df" | substr (op_code, 3, 2) = "aq" | substr (op_code, 4, 2) = "aq"; 190 has_ic = p -> instruction.tag = "000100"b; /* IC */ 191 end; 192 call address; 193 end; 194 195 call set_tag; 196 end; 197 198 /* Print data referred to by self relative address: (tab) (tab) data offset = contents */ 199 200 if has_ic then do; 201 if real_offset_entry then pt = ptr (p, real_offset + offset - irand); 202 else pt = addrel (p, offset-irand); 203 substr (line, k, 8) = htht || binoct (rel (pt)); 204 k = k + 8; 205 206 if substr (op_code, 1, 1) ^= "t" then do; 207 comment = " = " || binoct (pt -> word (0)); 208 if double then comment = comment || " " || binoct (pt -> word (1)); 209 end; 210 end; 211 212 else if ext_base & (p -> instruction.base = "000"b) then do; /* info for pr0 only */ 213 214 if op_code = "xec " then do; 215 pt = addrel (addr (pl1_operators_$operator_table), offset); 216 op_index = fixed (pt -> instruction.op_code, 10); 217 if num_words (op_index) > 1 then do; 218 219 /* we are executing an EIS instruction in pl1_operators_ */ 220 221 call init_eis; 222 223 do j = 1 to ndesc; 224 ebase (j) = "1"b; 225 len_reg (j) = ^ decimal; 226 ic (j) = "0"b; 227 end; 228 end; 229 end; 230 231 if tag ^= " " then do; 232 call find_operator_name_ ("pl1_operators_", p, op_name); 233 if op_name ^= " " then do; 234 substr (line, k, 34) = htht || op_name; 235 k = k + 34; 236 end; 237 238 end; 239 end; 240 if ^eis_desc & ^repeat_inst & p -> instruction.inhibit then comment = comment || " interrupt inhibit"; 241 242 end; 243 244 if comment ^= "" then do; 245 j = length (comment); 246 substr (line, k, j) = comment; 247 k = k + j; 248 end; 249 250 if print_instr then call ioa_$ioa_stream (output_switch, "^6o ^a", fixed (rel (p), 17), substr (line, 11, k-11)); 251 252 else do; /* return string for one line only */ 253 j = k - 11; /* save length of strjng */ 254 k = 1; 255 call bin_to_oct (real_offset); 256 arg_string = substr (line, 1, k-1) || substr (line, 11, j); 257 return; 258 end; 259 260 if eis 261 then do; 262 irand = irand + 1; 263 if irand > nrands then do; 264 eis = "0"b; 265 irand = 0; 266 end; 267 else if irand > ndesc 268 then op_code, desc_word = "arg"; 269 end; 270 271 p = addrel (p, 1); 272 end; 273 274 return; 275 276 277 /* */ 278 /* Entry point to return a formatted string with the disassembled instruction. The 279* real offset is returned in the string. */ 280 281 print_text_$real_offset: entry (t_pt, arg_string, arg_offset); 282 283 284 p = t_pt; 285 real_offset = arg_offset; 286 number = 1; /* process one word only */ 287 print_instr = "0"b; /* return string instead */ 288 real_offset_entry = "1"b; 289 go to begin; 290 291 print_text_$format: entry (t_pt, arg_string); 292 293 number = 1; 294 p = t_pt; 295 real_offset = fixed (rel (p), 18); 296 print_instr = "0"b; 297 real_offset_entry = "0"b; 298 go to begin; 299 300 bin_to_oct: proc (number); 301 302 dcl (m, number) fixed bin (18); 303 304 call ioa_$rsnnl ("^o", buff, m, number); 305 substr (line, k, m) = buff; 306 k = k + m; 307 308 end bin_to_oct; 309 310 311 init_eis: proc; 312 313 eis = "1"b; 314 nrands = num_words (op_index) - 1; 315 ndesc = num_desc (op_index); 316 decimal = dtype (op_index) = 2; 317 desc_word = desc_op (dtype (op_index)); 318 desc_type = dtype (op_index); 319 irand = 0; 320 321 end init_eis; 322 323 /* */ 324 eis_instruction: proc; 325 326 call init_eis; 327 328 substr (line, 13, 4) = substr (cstring, 1, 3); 329 substr (line, 17, 4) = substr (cstring, 4, 3); 330 substr (line, 21, 4) = substr (cstring, 7, 3); 331 substr (line, 25, 3) = substr (cstring, 10, 3); 332 333 substr (line, 28, 1) = ht; 334 substr (line, 29, 5) = op_code; 335 substr (line, 34, 1) = ht; 336 337 k = 35; 338 339 do j = 1 to ndesc; 340 string (mod_factor) = substr (p -> word (0), mf (j), 7); 341 ebase (j) = mod_factor.ext_base; 342 len_reg (j) = mod_factor.length_in_reg; 343 idesc (j) = mod_factor.indirect_descriptor; 344 345 substr (line, k, 1) = "("; 346 k = k + 1; 347 need_comma = "0"b; 348 349 if ebase (j) then do; 350 substr (line, k, 2) = "pr"; 351 k = k + 2; 352 need_comma = "1"b; 353 end; 354 355 if len_reg (j) then do; 356 if need_comma then do; 357 substr (line, k, 1) = ","; 358 k = k + 1; 359 end; 360 substr (line, k, 2) = "rl"; 361 k = k + 2; 362 need_comma = "1"b; 363 end; 364 365 if idesc (j) then do; 366 if need_comma then do; 367 substr (line, k, 1) = ","; 368 k = k + 1; 369 end; 370 substr (line, k, 2) = "id"; 371 k = k + 2; 372 need_comma = "1"b; 373 end; 374 375 if mod_factor.tag then do; 376 if need_comma then do; 377 substr (line, k, 1) = ","; 378 k = k + 1; 379 end; 380 ic (j) = mod_factor.tag = "0100"b; /* IC */ 381 substr (line, k, 2) = eis_modifier (fixed (mod_factor.tag, 4)); 382 k = k + 2; 383 end; 384 else ic (j) = "0"b; 385 386 substr (line, k, 2) = "),"; 387 k = k + 2; 388 end; 389 390 391 if substr (p -> word (0), 10, 1) then do; 392 substr (line, k, 12) = "enablefault,"; 393 k = k + 12; 394 end; 395 396 if desc_word = "desc9a" 397 then if ndesc < 3 then do; 398 if substr (op_code, 1, 2) ^= "sc" 399 then substr (line, k, 5) = "fill("; 400 else substr (line, k, 5) = "mask("; 401 k = k + 5; 402 substr (line, k, 3) = substr (cstring, 1, 3); 403 k = k + 3; 404 substr (line, k, 1) = ")"; 405 k = k + 1; 406 end; 407 else k = k - 1; 408 else if desc_word = "descb" then do; 409 substr (line, k, 7) = "fill(" || digit (fixed (substr (p -> word (0), 1, 1), 1)) || ")"; /* fill(N) */ 410 k = k + 7; 411 412 if op_code ^= "cmpb " then do; 413 substr (line, k, 6) = ",bool("; 414 k = k + 6; 415 j = fixed (substr (p -> word (0), 6, 4), 4); 416 m = length (bool_word (j)); 417 if m > 0 then do; 418 substr (line, k, m) = bool_word (j); 419 k = k + m; 420 end; 421 else do; 422 substr (line, k, 1) = digit (fixed (substr (p -> word (0), 6, 1), 1)); 423 substr (line, k+1, 1) = digit (fixed (substr (p -> word (0), 7, 3), 3)); 424 k = k + 2; 425 end; 426 substr (line, k, 1) = ")"; 427 k = k + 1; 428 end; 429 end; 430 else if substr (p -> word (0), 11, 1) then do; 431 substr (line, k, 5) = "round"; 432 k = k + 5; 433 end; 434 else k = k - 1; 435 436 return; 437 438 end eis_instruction; 439 440 /* */ 441 442 eis_descriptor: proc; 443 444 dcl len fixed bin (18); 445 dcl type fixed bin; /* descriptor type */ 446 447 dcl 1 n_desc aligned based (p), 448 2 y bit (18) unal, /* address field */ 449 2 CN bit (3) unal, /* character position */ 450 2 TN bit (1) unal, /* type 0 = 9bit; 1 = 4 bit */ 451 2 S bit (2) unal, /* sign type 0 = fl, 1 = ls, 2 = ts, 3 = ns */ 452 2 SF bit (6) unal, /* scale factor */ 453 2 N bit (6) unal; /* length */ 454 455 dcl 1 b_desc aligned based (p), /* bit descriptor */ 456 2 y bit (18) unal, /* address field */ 457 2 c bit (2) unal, /* 9 bit offset */ 458 2 b bit (4) unal, /* bit offset */ 459 2 N bit (12) unal; /* length */ 460 461 dcl 1 a_desc aligned based (p), /* alpha-numeric descriptor */ 462 2 y bit (18) unal, /* address field */ 463 2 CN bit (3) unal, /* character offset */ 464 2 TA bit (2) unal, 465 2 pad bit (1) unal, /* always zero */ 466 2 N bit (12) unal; /* length */ 467 468 dcl table_n_S (0:3) char (2) int static init ("fl", "ls", "ts", "ns"); 469 dcl table_a_TA (0:3) char (1) int static init ("9", "6", "4", "?"); 470 471 ind_desc = idesc (irand); 472 if ind_desc then do; 473 call ind_descriptor; 474 return; 475 end; 476 477 substr (line, 13, 2) = " "; 478 substr (line, 15, 6) = substr (cstring, 2, 5); 479 substr (line, 21, 3) = substr (cstring, 7, 2); 480 substr (line, 24, 4) = substr (cstring, 9, 4); 481 substr (line, 28, 1) = ht; 482 483 ext_base = ebase (irand); 484 has_ic = ic (irand); 485 486 type = desc_type; 487 if op_code = "btd" & irand = 1 then type = 0; 488 else if op_code = "dtb" | op_code = "mvne" then if irand > 1 then type = 0; 489 490 if type = 0 then do; /* alpha-nummeric descriptor */ 491 desc_word = "desc" || table_a_TA (fixed (a_desc.TA, 2)) || "a"; 492 if a_desc.TA = "00"b then fract_offset = fixed (substr (a_desc.CN, 1, 2), 2); 493 else fract_offset = fixed (a_desc.CN, 3); 494 len = fixed (a_desc.N, 12); 495 end; 496 497 else if type = 1 then do; /* bit descriptor */ 498 desc_word = "descb"; 499 len = fixed (b_desc.N, 12); 500 fract_offset = fixed (b_desc.c, 2) * 9 + fixed (b_desc.b, 4); 501 end; 502 503 else do; /* numeric descriptor */ 504 if n_desc.TN then do; 505 desc_word = "desc4"; 506 fract_offset = fixed (n_desc.CN,3); 507 end; 508 else do; 509 desc_word = "desc9"; 510 fract_offset = fixed (substr (n_desc.CN, 1, 2), 2); 511 end; 512 desc_word = desc_word || table_n_S (fixed (n_desc.S, 2)); 513 len = fixed (n_desc.N, 6); 514 515 if n_desc.S then do; /* for S = 00 there is no scale factor */ 516 scale = fixed (n_desc.SF, 6); 517 if scale > 32 then scale = scale - 64; 518 end; 519 end; 520 521 /* desc_word address(fract_offset),tag,length,scale */ 522 523 k = length (desc_word); 524 substr (line, 29, k) = desc_word; 525 k = k + 29; 526 call address; 527 528 if fract_offset ^= 0 then do; 529 call ioa_$rsnnl ("(^d)", buff, j, fract_offset); 530 substr (line, k, j) = buff; 531 k = k + j; 532 end; 533 534 if len_reg (irand) then do; /* print register which contains length */ 535 tag = eis_modifier (fixed (substr (p -> descriptor.length, 9, 4), 4)); 536 call set_tag; 537 end; 538 539 else do; /* print length as given */ 540 substr (line, k, 1) = ","; 541 k = k + 1; 542 call bin_to_oct (len); 543 end; 544 545 if type = 2 then if n_desc.S then do; /* scale factor for numeric only */ 546 substr (line, k, 1) = ","; 547 k = k+1; 548 call bin_to_oct (scale); 549 end; 550 551 return; 552 553 end eis_descriptor; 554 555 /* */ 556 557 ind_descriptor: proc; 558 559 dcl 1 i_desc aligned based (p), /* indirect descriptor */ 560 2 y bit (18) unal, /* address field */ 561 2 pad bit (11) unal, /* always zero */ 562 2 extbase bit (1) unal, /* PR mod */ 563 2 pad1 bit (2) unal, /* always zero */ 564 2 tag bit (4) unal; /* reg mod */ 565 566 567 substr (line, 13, 2) = " "; 568 substr (line, 15, 6) = substr (cstring, 2, 5); 569 substr (line, 21, 5) = substr (cstring, 7, 4); 570 substr (line, 26, 2) = substr (cstring, 11, 2); 571 substr (line, 28, 1) = ht; 572 573 ext_base = i_desc.extbase; 574 has_ic = (i_desc.tag = "0100"b); 575 desc_word = "arg"; 576 577 k = length (desc_word); 578 substr (line, 29, k) = desc_word; 579 k = k + 29; 580 call address; 581 582 if i_desc.tag then do; 583 substr (line, k, 3) = "," || eis_modifier (fixed (i_desc.tag, 4)); 584 k = k + 3; 585 end; 586 return; 587 end ind_descriptor; 588 589 /* */ 590 591 /* This procedure disassembles the address portion. It adds: tab [prN|] offset 592* It also sets the first octal digit so a blank will separate the register from the rest of the address field. 593* 594* cstring The octal representation of the word. 595* 596* ext_base ON if the address uses a register. 597**/ 598 599 address: proc; 600 601 substr (line, k, 1) = ht; 602 k = k + 1; 603 604 if ext_base then do; 605 substr (line, k, 4) = base (fixed (p -> instruction.base, 3)); 606 offset = fixed (p -> instruction.offset, 15); 607 if offset > 16384 then offset = offset - 32768; 608 k = k+4; 609 substr (line, 13, 1) = cstring; 610 end; 611 612 else do; 613 offset = fixed (p -> half.left, 18); 614 if offset > 131072 then if tag ^= "du " & tag ^= "dl " then offset = offset - 262144; /* 2's comp */ 615 substr (line, 14, 1) = cstring; 616 end; 617 618 619 call bin_to_oct (offset); 620 621 end address; 622 623 624 /* This procedure sets the tag in the instruction line. */ 625 626 set_tag: proc; 627 628 if tag ^= " " then do; 629 substr (line, k, 4) = "," || tag; 630 k = k + 2; 631 if substr (line, k, 1) ^= " " then k = k + 1; 632 if substr (line, k, 1) ^= " " then k = k + 1; 633 end; 634 635 return; 636 end set_tag; 637 638 binoct: proc (bits) returns (char (12) aligned); 639 dcl bits bit (*) aligned parameter; 640 dcl c12 char (12) aligned; 641 642 call ioa_$rsnnl ("^12.3b", c12, (0), bits); 643 return (c12); 644 end binoct; 645 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 02/19/86 1047.2 print_text_.pl1 >spec>install>1019>print_text_.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. CN 0(18) based bit(3) level 2 in structure "a_desc" packed unaligned dcl 461 in procedure "eis_descriptor" ref 492 493 CN 0(18) based bit(3) level 2 in structure "n_desc" packed unaligned dcl 447 in procedure "eis_descriptor" ref 506 510 N 0(24) based bit(12) level 2 in structure "b_desc" packed unaligned dcl 455 in procedure "eis_descriptor" ref 499 N 0(24) based bit(12) level 2 in structure "a_desc" packed unaligned dcl 461 in procedure "eis_descriptor" ref 494 N 0(30) based bit(6) level 2 in structure "n_desc" packed unaligned dcl 447 in procedure "eis_descriptor" ref 513 S 0(22) based bit(2) level 2 packed unaligned dcl 447 ref 512 515 545 SF 0(24) based bit(6) level 2 packed unaligned dcl 447 ref 516 TA 0(21) based bit(2) level 2 packed unaligned dcl 461 ref 491 492 TN 0(21) based bit(1) level 2 packed unaligned dcl 447 ref 504 a_desc based structure level 1 dcl 461 addr builtin function dcl 63 ref 215 addrel builtin function dcl 63 ref 202 215 271 arg_number parameter fixed bin(17,0) dcl 31 ref 29 133 arg_offset parameter fixed bin(18,0) dcl 31 ref 281 285 arg_string parameter varying char dcl 31 set ref 256* 281 291 b 0(20) based bit(4) level 2 packed unaligned dcl 455 ref 500 b_desc based structure level 1 dcl 455 base 000223 constant char(4) initial array dcl 77 in procedure "print_text_" ref 605 base based bit(3) level 2 in structure "instruction" packed unaligned dcl 92 in procedure "print_text_" ref 212 605 bits parameter bit dcl 639 set ref 638 642* bool_word 000004 constant varying char(6) initial array dcl 121 ref 416 418 buff 000265 automatic varying char(12) dcl 42 set ref 178* 179 304* 305 529* 530 c 0(18) based bit(2) level 2 packed unaligned dcl 455 ref 500 c12 000406 automatic char(12) dcl 640 set ref 642* 643 comment 000102 automatic varying char(50) dcl 40 set ref 144* 207* 208* 208 240* 240 244 245 246 cstring 000157 automatic char(12) unaligned dcl 42 set ref 147* 166 167 168 177 328 329 330 331 402 478 479 480 568 569 570 609 615 decimal 000155 automatic bit(1) unaligned dcl 42 set ref 225 316* desc_op 000104 constant varying char(8) initial array dcl 115 ref 317 desc_type 000101 automatic fixed bin(17,0) dcl 39 set ref 318* 486 desc_word 000312 automatic varying char(8) dcl 113 set ref 161 267* 317* 396 408 491* 498* 505* 509* 512* 512 523 524 575* 577 578 descriptor based structure level 1 dcl 125 digit 000233 constant char(1) initial array dcl 73 ref 409 422 423 double 000147 automatic bit(1) unaligned dcl 42 set ref 159* 189* 208 dtype 1(18) 000020 external static fixed bin(2,0) array level 2 packed unaligned dcl 66 ref 316 317 318 ebase 000276 automatic bit(1) array dcl 112 set ref 224* 341* 349 483 eis 000150 automatic bit(1) unaligned dcl 42 set ref 139* 149 161 260 264* 313* eis_desc 000151 automatic bit(1) unaligned dcl 42 set ref 161* 162 240 eis_modifier 000064 constant char(3) initial array dcl 117 ref 381 535 583 ext_base 0(29) based bit(1) level 2 in structure "instruction" packed unaligned dcl 92 in procedure "print_text_" ref 171 ext_base 000153 automatic bit(1) unaligned dcl 42 in procedure "print_text_" set ref 171* 212 483* 573* 604 ext_base 000275 automatic bit(1) level 2 in structure "mod_factor" packed unaligned dcl 104 in procedure "print_text_" set ref 341 extbase 0(29) based bit(1) level 2 packed unaligned dcl 559 ref 573 find_operator_name_ 000016 constant entry external dcl 61 ref 232 fixed builtin function dcl 63 ref 152 175 175 176 188 216 250 250 295 381 409 415 422 423 491 492 493 494 499 500 500 506 510 512 513 516 535 583 605 606 613 fract_offset 000144 automatic fixed bin(18,0) dcl 42 set ref 492* 493* 500* 506* 510* 528 529* half based structure level 1 dcl 100 has_ic 000154 automatic bit(1) unaligned dcl 42 set ref 159* 190* 200 484* 574* ht constant char(1) initial dcl 42 ref 168 333 335 481 571 601 htht 003212 constant char(2) initial dcl 42 ref 203 234 i_desc based structure level 1 dcl 559 ic 000307 automatic bit(1) array dcl 112 set ref 226* 380* 384* 484 idesc 000304 automatic bit(1) array dcl 112 set ref 343* 365 471 ind_desc 000156 automatic bit(1) unaligned dcl 42 set ref 161 471* 472 indirect_descriptor 0(02) 000275 automatic bit(1) level 2 packed unaligned dcl 104 set ref 343 inhibit 0(28) based bit(1) level 2 packed unaligned dcl 92 ref 240 instruction based structure level 1 dcl 92 ioa_$ioa_stream 000012 constant entry external dcl 59 ref 250 ioa_$rsnnl 000014 constant entry external dcl 60 ref 175 178 304 529 642 irand 000141 automatic fixed bin(17,0) dcl 42 set ref 140* 201 202 262* 262 263 265* 267 319* 471 483 484 487 488 534 j 000135 automatic fixed bin(17,0) dcl 42 set ref 175* 178* 179 180 223* 224 225 226* 245* 246 247 253* 256 339* 340 341 342 343 349 355 365 380 384* 415* 416 418 529* 530 531 k 000136 automatic fixed bin(17,0) dcl 42 set ref 169* 179 180* 180 203 204* 204 234 235* 235 246 247* 247 250 250 253 254* 256 305 306* 306 337* 345 346* 346 350 351* 351 357 358* 358 360 361* 361 367 368* 368 370 371* 371 377 378* 378 381 382* 382 386 387* 387 392 393* 393 398 400 401* 401 402 403* 403 404 405* 405 407* 407 409 410* 410 413 414* 414 418 419* 419 422 423 424* 424 426 427* 427 431 432* 432 434* 434 523* 524 525* 525 530 531* 531 540 541* 541 546 547* 547 577* 578 579* 579 583 584* 584 601 602* 602 605 608* 608 629 630* 630 631 631* 631 632 632* 632 left based bit(18) level 2 packed unaligned dcl 100 ref 176 613 len 000354 automatic fixed bin(18,0) dcl 444 set ref 494* 499* 513* 542* len_reg 000301 automatic bit(1) array dcl 112 set ref 225* 342* 355 534 length builtin function dcl 63 in procedure "print_text_" ref 245 416 523 577 length 0(24) based bit(12) level 2 in structure "descriptor" packed unaligned dcl 125 in procedure "print_text_" ref 535 length_in_reg 0(01) 000275 automatic bit(1) level 2 packed unaligned dcl 104 set ref 342 line 000165 automatic char(256) unaligned dcl 42 set ref 138* 146* 165* 166* 167* 168* 177* 179* 203* 234* 246* 250 250 256 256 305* 328* 329* 330* 331* 333* 334* 335* 345* 350* 357* 360* 367* 370* 377* 381* 386* 392* 398* 400* 402* 404* 409* 413* 418* 422* 423* 426* 431* 477* 478* 479* 480* 481* 524* 530* 540* 546* 567* 568* 569* 570* 571* 578* 583* 601* 605* 609* 615* 629* 631 632 m 000137 automatic fixed bin(17,0) dcl 42 in procedure "print_text_" set ref 416* 417 418 419 m 000326 automatic fixed bin(18,0) dcl 302 in procedure "bin_to_oct" set ref 304* 305 306 mf 000120 constant fixed bin(6,0) initial array dcl 110 ref 340 mod_factor 000275 automatic structure level 1 dcl 104 set ref 340* modifier 000123 constant char(3) initial array dcl 80 ref 188 n_desc based structure level 1 dcl 447 ndesc 000143 automatic fixed bin(17,0) dcl 42 set ref 223 267 315* 339 396 need_comma 000152 automatic bit(1) unaligned dcl 42 set ref 347* 352* 356 362* 366 372* 376 no_to_print 000134 automatic fixed bin(17,0) dcl 42 set ref 142* nrands 000142 automatic fixed bin(17,0) dcl 42 set ref 263 314* num_desc 1(21) 000020 external static fixed bin(5,0) array level 2 packed unaligned dcl 66 ref 184 315 num_words 1(27) 000020 external static fixed bin(8,0) array level 2 packed unaligned dcl 66 ref 156 217 314 number parameter fixed bin(18,0) dcl 302 in procedure "bin_to_oct" set ref 300 304* number 000100 automatic fixed bin(17,0) dcl 38 in procedure "print_text_" set ref 133* 142 286* 293* offset 0(03) based bit(15) level 2 in structure "instruction" packed unaligned dcl 92 in procedure "print_text_" ref 606 offset 000145 automatic fixed bin(18,0) dcl 42 in procedure "print_text_" set ref 176* 178* 201 202 215 606* 607 607* 607 613* 614 614* 614 619* op_code 000162 automatic char(5) unaligned dcl 42 in procedure "print_text_" set ref 153* 168 173 173 173 189 189 189 206 214 267* 334 398 412 487 488 488 op_code 0(18) based bit(10) level 2 in structure "instruction" packed unaligned dcl 92 in procedure "print_text_" ref 152 216 op_index 000140 automatic fixed bin(17,0) dcl 42 set ref 149* 152* 153 156 184 216* 217 314 315 316 317 318 op_mnemonic_$op_mnemonic 000020 external static structure array level 1 dcl 66 op_name 000120 automatic char(32) dcl 41 set ref 232* 233 234 opcode 000020 external static char(6) array level 2 packed unaligned dcl 66 ref 153 output_switch parameter char dcl 31 set ref 29 250* p 000130 automatic pointer dcl 42 set ref 136* 147 152 171 175 175 176 184 188 188 190 201 202 212 232* 240 250 250 271* 271 284* 294* 295 340 391 409 415 422 423 430 491 492 492 493 494 499 500 500 504 506 510 512 513 515 516 535 545 573 574 582 583 605 606 613 pl1_operators_$operator_table 000010 external static fixed bin(17,0) dcl 42 set ref 215 print_instr 000272 automatic bit(1) unaligned dcl 56 set ref 134* 250 287* 296* pt 000132 automatic pointer dcl 42 set ref 201* 202* 203 203 207 208 215* 216 ptr builtin function dcl 63 ref 201 real_offset 000274 automatic fixed bin(18,0) dcl 58 set ref 201 255* 285* 295* real_offset_entry 000273 automatic bit(1) unaligned dcl 57 set ref 135* 201 288* 297* rel builtin function dcl 63 ref 203 203 250 250 295 repeat_inst 000271 automatic bit(1) unaligned dcl 55 set ref 159* 174* 240 scale 000146 automatic fixed bin(18,0) dcl 42 set ref 516* 517 517* 517 548* string builtin function dcl 63 set ref 340* substr builtin function dcl 63 set ref 138* 146* 165* 166* 166 167* 167 168* 168 176 177* 179* 184 189 189 189 203* 206 234* 246* 250 250 256 256 305* 328* 328 329* 329 330* 330 331* 331 333* 334* 335* 340 345* 350* 357* 360* 367* 370* 377* 381* 386* 391 392* 398 398* 400* 402* 402 404* 409* 409 413* 415 418* 422* 422 423* 423 426* 430 431* 477* 478* 478 479* 479 480* 480 481* 492 510 524* 530* 535 540* 546* 567* 568* 568 569* 569 570* 570 571* 578* 583* 601* 605* 609* 615* 629* 631 632 t_pt parameter pointer dcl 31 ref 29 136 281 284 291 294 table_a_TA 000000 constant char(1) initial array unaligned dcl 469 ref 491 table_n_S 000002 constant char(2) initial array unaligned dcl 468 ref 512 tag 0(03) 000275 automatic bit(4) level 2 in structure "mod_factor" packed unaligned dcl 104 in procedure "print_text_" set ref 375 380 381 tag 0(30) based bit(6) level 2 in structure "instruction" packed unaligned dcl 92 in procedure "print_text_" ref 175 175 184 188 188 190 tag 000164 automatic char(3) unaligned dcl 42 in procedure "print_text_" set ref 145* 175* 184* 188* 231 535* 614 614 628 629 tag 0(32) based bit(4) level 2 in structure "i_desc" packed unaligned dcl 559 in procedure "ind_descriptor" ref 574 582 583 type 000355 automatic fixed bin(17,0) dcl 445 set ref 486* 487* 488* 490 497 545 word based bit(36) array dcl 90 set ref 147* 207* 208* 340 391 409 415 422 423 430 NAMES DECLARED BY EXPLICIT CONTEXT. address 002751 constant entry internal dcl 599 ref 192 526 580 begin 000410 constant label dcl 138 ref 289 298 bin_to_oct 001543 constant entry internal dcl 300 ref 255 542 548 619 binoct 003071 constant entry internal dcl 638 ref 147 184 203 207 208 eis_descriptor 002273 constant entry internal dcl 442 ref 162 eis_instruction 001651 constant entry internal dcl 324 ref 156 ind_descriptor 002656 constant entry internal dcl 557 ref 473 init_eis 001605 constant entry internal dcl 311 ref 221 326 print_text_ 000364 constant entry external dcl 29 print_text_$format 001514 constant entry external dcl 291 print_text_$real_offset 001461 constant entry external dcl 281 set_tag 003030 constant entry internal dcl 626 ref 195 536 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3352 3374 3220 3362 Length 3570 3220 22 157 132 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME print_text_ 382 external procedure is an external procedure. bin_to_oct internal procedure shares stack frame of external procedure print_text_. init_eis internal procedure shares stack frame of external procedure print_text_. eis_instruction internal procedure shares stack frame of external procedure print_text_. eis_descriptor internal procedure shares stack frame of external procedure print_text_. ind_descriptor internal procedure shares stack frame of external procedure print_text_. address internal procedure shares stack frame of external procedure print_text_. set_tag internal procedure shares stack frame of external procedure print_text_. binoct internal procedure shares stack frame of external procedure print_text_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME print_text_ 000100 number print_text_ 000101 desc_type print_text_ 000102 comment print_text_ 000120 op_name print_text_ 000130 p print_text_ 000132 pt print_text_ 000134 no_to_print print_text_ 000135 j print_text_ 000136 k print_text_ 000137 m print_text_ 000140 op_index print_text_ 000141 irand print_text_ 000142 nrands print_text_ 000143 ndesc print_text_ 000144 fract_offset print_text_ 000145 offset print_text_ 000146 scale print_text_ 000147 double print_text_ 000150 eis print_text_ 000151 eis_desc print_text_ 000152 need_comma print_text_ 000153 ext_base print_text_ 000154 has_ic print_text_ 000155 decimal print_text_ 000156 ind_desc print_text_ 000157 cstring print_text_ 000162 op_code print_text_ 000164 tag print_text_ 000165 line print_text_ 000265 buff print_text_ 000271 repeat_inst print_text_ 000272 print_instr print_text_ 000273 real_offset_entry print_text_ 000274 real_offset print_text_ 000275 mod_factor print_text_ 000276 ebase print_text_ 000301 len_reg print_text_ 000304 idesc print_text_ 000307 ic print_text_ 000312 desc_word print_text_ 000326 m bin_to_oct 000354 len eis_descriptor 000355 type eis_descriptor 000406 c12 binoct THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as r_ne_as alloc_cs cat_realloc_cs call_ext_out_desc return shorten_stack ext_entry_desc THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. find_operator_name_ ioa_$ioa_stream ioa_$rsnnl THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. op_mnemonic_$op_mnemonic pl1_operators_$operator_table LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 29 000360 133 000377 134 000402 135 000404 136 000405 138 000410 139 000413 140 000414 142 000415 144 000425 145 000426 146 000430 147 000432 149 000453 152 000457 153 000463 156 000472 159 000506 161 000511 162 000521 165 000524 166 000526 167 000535 168 000543 169 000560 171 000562 173 000566 174 000575 175 000577 176 000630 177 000633 178 000636 179 000665 180 000673 181 000675 184 000676 188 000717 189 000726 190 000750 192 000754 195 000755 200 000756 201 000760 202 000771 203 000776 204 001017 206 001022 207 001026 208 001056 209 001131 210 001132 212 001133 214 001140 215 001143 216 001151 217 001155 221 001164 223 001166 224 001175 225 001177 226 001202 227 001203 231 001205 232 001215 233 001244 234 001250 235 001257 240 001261 244 001302 245 001307 246 001311 247 001316 250 001317 252 001367 253 001370 254 001373 255 001375 256 001377 257 001424 260 001426 262 001430 263 001431 264 001434 265 001435 266 001436 267 001437 271 001447 272 001452 274 001454 281 001455 284 001474 285 001500 286 001502 287 001504 288 001505 289 001507 291 001510 293 001527 294 001531 295 001535 296 001540 297 001541 298 001542 300 001543 304 001545 305 001574 306 001602 308 001604 311 001605 313 001606 314 001610 315 001622 316 001626 317 001634 318 001645 319 001647 321 001650 324 001651 326 001652 328 001653 329 001657 330 001666 331 001674 333 001677 334 001701 335 001704 337 001706 339 001710 340 001717 341 001725 342 001731 343 001735 345 001741 346 001745 347 001746 349 001747 350 001751 351 001755 352 001757 355 001761 356 001763 357 001765 358 001771 360 001772 361 001776 362 002000 365 002002 366 002004 367 002006 368 002012 370 002013 371 002017 372 002021 375 002023 376 002030 377 002032 378 002036 380 002037 381 002043 382 002052 383 002054 384 002055 386 002056 387 002062 388 002064 391 002066 392 002071 393 002075 396 002077 398 002107 400 002120 401 002124 402 002126 403 002132 404 002134 405 002140 406 002141 407 002142 408 002145 409 002152 410 002172 412 002174 413 002177 414 002203 415 002205 416 002211 417 002215 418 002216 419 002225 420 002226 422 002227 423 002237 424 002246 426 002250 427 002254 429 002255 430 002256 431 002261 432 002265 433 002267 434 002270 436 002272 442 002273 471 002274 472 002277 473 002300 474 002301 477 002302 478 002304 479 002313 480 002321 481 002325 483 002327 484 002331 486 002333 487 002335 488 002350 490 002370 491 002372 492 002416 493 002425 494 002431 495 002434 497 002435 498 002437 499 002444 500 002447 501 002461 504 002462 505 002465 506 002472 507 002476 509 002477 510 002504 512 002510 513 002531 515 002534 516 002536 517 002542 523 002546 524 002550 525 002554 526 002556 528 002557 529 002561 530 002610 531 002616 534 002620 535 002623 536 002627 537 002630 540 002631 541 002635 542 002636 545 002640 546 002646 547 002652 548 002653 551 002655 557 002656 567 002657 568 002661 569 002670 570 002676 571 002701 573 002703 574 002707 575 002714 577 002720 578 002722 579 002726 580 002730 582 002731 583 002735 584 002746 586 002750 599 002751 601 002752 602 002756 604 002757 605 002761 606 002770 607 002774 608 003000 609 003002 610 003004 613 003005 614 003010 615 003022 619 003025 621 003027 626 003030 628 003031 629 003041 630 003052 631 003054 632 003062 635 003070 638 003071 642 003102 643 003134 ----------------------------------------------------------- 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