COMPILATION LISTING OF SEGMENT db_fnp_env_ Compiled by: Multics PL/I Compiler, Release 28d, of October 4, 1983 Compiled at: Honeywell Multics Op. - System M Compiled on: 06/01/84 1535.2 mst Fri 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 /* DB_FNP_ENV_ - Contains entries used by debug_fnp to maintain its environment. 12* The selecting of dumps, core images, and live FNP's, and the switching between them is all done here */ 13 14 /* Created September 1978 by Larry Johnson, mostly from other modules, to centralize all this code */ 15 /* Modified July 1979 by Larry Johnson to handle empty dumps better, and to add -login_channel to line command */ 16 /* Modified August 1979 by Larry Johnson to automatically select the channel causing a dump */ 17 /* Modified 83-12-23 BIM for new config cards */ 18 19 db_fnp_env_: proc; 20 21 /* Arguments */ 22 23 dcl arg_corep ptr; /* Address of the dump */ 24 dcl arg_fnp fixed bin; 25 dcl arg_cmd_infop ptr; 26 dcl arg_expr_infop ptr; 27 dcl arg_envp ptr; 28 29 /* Automatic */ 30 31 dcl code fixed bin (35); 32 dcl i fixed bin; 33 dcl dir char (168); 34 dcl ename char (32); 35 dcl dnx fixed bin; 36 dcl segp ptr; 37 dcl p ptr; 38 dcl fnp fixed bin; 39 dcl tag char (1); 40 dcl areap ptr; 41 dcl tty_name char (32); 42 dcl empty_dump bit (1); 43 dcl continue_scan_label local label; 44 dcl version char (4) aligned; 45 dcl (bind_time, boot_time, up_time) fixed bin (71); 46 dcl time_string char (24); 47 dcl mem_word (1) bit (18) unal; 48 dcl print_channel_name bit (1); 49 dcl ptwp ptr; 50 51 dcl (entry_cnt1, entry_cnt2) fixed bin; 52 dcl (namep1, namep2) ptr init (null); 53 dcl (entryp1, entryp2) ptr init (null); 54 55 /* Based */ 56 57 dcl system_area area based (areap); 58 dcl 1 entries1 (entry_cnt1) aligned based (entryp1), /* Data from hcs_$star_ */ 59 2 type bit (2) unal, 60 2 nnames fixed bin (15) unal, 61 2 nindex fixed bin (17) unal; 62 dcl names1 (1) char (32) aligned based (namep1); 63 dcl 1 entries2 (entry_cnt2) aligned based (entryp2), /* Data from hcs_$star_ */ 64 2 type bit (2) unal, 65 2 nnames fixed bin (15) unal, 66 2 nindex fixed bin (17) unal; 67 dcl names2 (1) char (32) aligned based (namep2); 68 69 dcl dnp ptr; 70 dcl 1 dn aligned based (dnp), 71 2 sort_key unal, 72 3 year char (2), 73 3 month char (2), 74 3 day char (2), 75 3 hour char (2), 76 3 min char (2), 77 3 fnp char (1), 78 2 ename char (32), /* Real entry name */ 79 2 fdump bit (1); /* Set if this is from fdump */ 80 81 dcl dntabp ptr init (null); 82 dcl dntab_size fixed bin; 83 dcl 1 dntab aligned based (dntabp), 84 2 dne (dntab_size) like dn; 85 86 87 dcl listp ptr init (null); 88 dcl list_size fixed bin; 89 dcl 1 list aligned based (listp), /* List of pointers for sort_items_ */ 90 2 cnt fixed bin, 91 2 dnp (list_size refer (list.cnt)) ptr unal; 92 93 dcl one_k_words (1024) bit (36) aligned based; /* For looking at emptyness of dumps */ 94 95 dcl 1 fdump aligned based, /* Format of fdump segment */ 96 2 fnp_dump (8), 97 3 memory (0:32767) bit (18) unal; 98 99 dcl 1 ptw unal based (ptwp), /* Format of FNP page table entry */ 100 2 base_address fixed bin (10) uns, 101 2 read_only bit (1), 102 2 secure bit (1), 103 2 active bit (1), 104 2 count fixed bin (5) uns; 105 106 /* Constants */ 107 108 dcl name char (11) int static options (constant) init ("db_fnp_env_"); 109 dcl fnp_dump_starname char (32) int static options (constant) init ("fnp.?.??????.????"); 110 dcl fdump_starname char (32) int static options (constant) init ("??????.????.*.*.355"); 111 112 /* Static */ 113 114 dcl crver fixed bin int static; 115 dcl crldt fixed bin int static; 116 dcl crbdt fixed bin int static; 117 dcl crreg fixed bin int static; 118 dcl crpte fixed bin int static; 119 dcl t_line fixed bin int static; 120 dcl constants_setup bit (1) int static init ("0"b); 121 122 /* External stuff */ 123 124 dcl absolute_pathname_ entry (char (*), char (*), fixed bin (35)); 125 dcl check_star_name_$entry entry (char (*), fixed bin (35)); 126 dcl com_err_ entry options (variable); 127 dcl config_$find_2 entry (character (4) aligned, character (4) aligned, pointer); 128 dcl cv_oct_check_ entry (char (*), fixed bin (35)) returns (fixed bin (35)); 129 dcl date_time_ entry (fixed bin (71), char (*)); 130 dcl db_fnp_disp_cmd_$forget entry; 131 dcl db_fnp_memory_$fetch entry (ptr, fixed bin, fixed bin, fixed bin, ptr, fixed bin (35)); 132 dcl db_fnp_reader_$get_operand entry (ptr); 133 dcl db_fnp_sym_util_$get_value entry (char (*)) returns (fixed bin); 134 dcl db_fnp_util_$cv_chan_name entry (ptr, fixed bin, char (*), char (*), fixed bin, fixed bin (35)); 135 dcl db_fnp_util_$get_chan_addrs entry (ptr, fixed bin, char (*), ptr, fixed bin (35)); 136 dcl encode_clock_value_ entry (fixed bin, fixed bin, fixed bin, fixed bin, fixed bin, fixed bin, fixed bin (71), 137 fixed bin, char (3), fixed bin (71), fixed bin (35)); 138 dcl expand_pathname_ entry (char (*), char (*), char (*), fixed bin (35)); 139 dcl get_system_free_area_ entry returns (ptr); 140 dcl get_wdir_ entry () returns (char (168)); 141 dcl hcs_$initiate entry (char (*), char (*), char (*), fixed bin (1), fixed bin (2), ptr, fixed bin (35)); 142 dcl hcs_$star_ entry (char (*), char (*), fixed bin (2), ptr, fixed bin, ptr, ptr, fixed bin (35)); 143 dcl hcs_$terminate_noname entry (ptr, fixed bin (35)); 144 dcl ioa_ entry options (variable); 145 dcl ioa_$rsnnl entry options (variable); 146 dcl match_star_name_ entry (char (*), char (*), fixed bin (35)); 147 dcl parse_tty_name_ entry (char (*), fixed bin, bit (1), fixed bin, fixed bin); 148 dcl sort_items_$char entry (ptr, fixed bin (24)); 149 dcl user_info_$terminal_data entry (char (*), char (*), char (*), fixed bin, char (*)); 150 dcl parse_fnp_name_ entry (char (*), fixed bin); 151 dcl get_fnp_name_ entry (fixed bin) returns (char (32)); 152 153 154 dcl error_table_$bad_arg ext fixed bin (35); 155 dcl error_table_$nomatch ext fixed bin (35); 156 157 dcl (cleanup, conversion) condition; 158 159 dcl (addr, addrel, bin, clock, divide, hbound, length, max, null, string, substr, unspec) builtin; 160 161 /* Entry to setup the default environment, FNP a, when the command begins. */ 162 163 init: entry (arg_envp); 164 165 envp = arg_envp; 166 167 env.corep = null (); 168 env.dump_dir = ">dumps"; 169 env.dir, env.ename = ""; 170 env.segp = null (); 171 string (env.flags) = "0"b; 172 env.tty_name = ""; 173 env.fnp = -1; 174 env.dump_time = 0; 175 call setup_constants; 176 177 call db_fnp_disp_cmd_$forget; 178 179 call find_configured_fnps; /* Check config deck for FNP's */ 180 call find_first_configured_fnp ("1"b); 181 if fnp > 0 then do; 182 env.fnp = fnp; 183 env.fnp_sw = "1"b; 184 end; 185 186 return; 187 188 /* Entry used by cleanup handler by main command */ 189 190 term: entry (arg_envp); 191 192 envp = arg_envp; 193 194 if env.segp ^= null () then do; 195 call hcs_$terminate_noname (env.segp, (0)); 196 env.segp = null (); 197 end; 198 return; 199 200 /* Command to select a specific FNP */ 201 202 fnp_cmd: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 203 204 call setup; 205 206 call get_opt_tag; 207 if tag = "" then do; /* Use first configured fnp */ 208 call find_first_configured_fnp ("0"b); 209 if fnp < 0 then go to error_return; 210 end; 211 212 if ^substr (env.fnps_configured, fnp, 1) then do; 213 call ioa_ ("FNP ^a is not configured.", tag); 214 go to error_return; 215 end; 216 217 call forget; 218 env.fnp = fnp; 219 env.fnp_sw = "1"b; 220 return; 221 222 /* Command to select a core image */ 223 224 image_cmd: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 225 226 call setup; 227 228 on cleanup call clean_up; 229 call get_seg; 230 231 call forget; 232 env.fnp = -1; 233 env.segp = segp; 234 env.dir = dir; 235 env.ename = ename; 236 env.corep = addrel (segp, 1); /* Core image has length word */ 237 env.image_sw = "1"b; 238 return; 239 240 241 /* Command to select a specific dump by name */ 242 243 dump_cmd: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 244 245 call setup; 246 247 on cleanup call clean_up; 248 call get_seg; /* Check arg */ 249 250 call forget; 251 env.fnp = -1; /* Don't know FNP */ 252 env.segp = segp; 253 env.dir = dir; 254 env.ename = ename; 255 env.corep = segp; 256 env.dump_sw = "1"b; 257 258 /* Check format of the dump name. If it one we recognize, we can infer 259* which FNP the dump is for, or select a valid dump from an FDUMP */ 260 261 call match_star_name_ (env.ename, fnp_dump_starname, code); 262 if code = 0 then do; /* Standard FNP dump */ 263 call parse_fnp_name_ (substr (env.ename, 5, 1), fnp); 264 if fnp < 0 then fnp = 0; 265 if fnp ^= 0 then env.fnp = fnp; /* Got good fnp */ 266 if unspec (env.segp -> one_k_words) = "0"b then 267 call ioa_ ("^a^[>^]^a appears empty.", env.dir, (env.dir ^= ">"), env.ename); 268 call setup_crashed_line; 269 call ioa_ ("^[Using line ^a^;^sNo TIB available^]", (env.tty_name ^= ""), env.tty_name); 270 return; 271 end; 272 273 call match_star_name_ (env.ename, fdump_starname, code); /* Check for standard fdump format */ 274 if code = 0 then do; 275 do fnp = 1 to hbound (env.segp -> fdump.fnp_dump, 1); /* Look for non-empty section */ 276 p = addr (env.segp -> fdump.fnp_dump (fnp)); 277 if unspec (p -> one_k_words) ^= "0"b then do; /* Found good data */ 278 use_some_dump: env.fdump_sw = "1"b; 279 env.corep = p; 280 env.fnp = fnp; 281 call setup_crashed_line; 282 call ioa_ ("^[Using line ^a^;^sNo TIB available.^]", (env.tty_name ^= ""), env.tty_name); 283 return; 284 end; 285 end; 286 call ioa_ ("^a^[>^]^a appears empty.", env.dir, (env.dir ^= ">"), env.ename); 287 fnp = 1; /* Use first fnp */ 288 p = addr (env.segp -> fdump.fnp_dump (fnp)); 289 go to use_some_dump; 290 end; 291 292 call ioa_ ("^a is non-standard dump name. FNP not known.", env.ename); 293 return; 294 295 /* Entry to set or print the default dump directory */ 296 297 dump_dir: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 298 299 call setup; 300 301 call get_operand; 302 if cmd_info.endline then do; 303 call ioa_ ("Dump directory is ^a", env.dump_dir); 304 return; 305 end; 306 307 if operand = "-wd" | operand = "-working_dir" then dir = get_wdir_ (); 308 else do; 309 call absolute_pathname_ (operand, dir, code); 310 if code ^= 0 then do; 311 call com_err_ (code, "", "^a", operand); 312 go to error_return; 313 end; 314 end; 315 316 env.dump_dir = dir; 317 return; 318 319 /* Entry to print a list of available dumps */ 320 321 dumps: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 322 323 call setup; 324 325 on cleanup call clean_up; 326 327 call list_dumps; 328 do i = list_size to 1 by -1; 329 dnp = list.dnp (i); 330 call ioa_ ("^a", dn.ename); 331 end; 332 333 call clean_up; 334 335 return; 336 337 /* Entry to find the most recent dump */ 338 339 last_dump: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 340 341 call setup; 342 continue_scan_label = prev_dump_continue; 343 344 on cleanup call clean_up; 345 call get_opt_tag; 346 347 call list_dumps; 348 349 do i = list_size to 1 by -1; 350 dnp = list.dnp (i); 351 if tag = "" then go to return_dump_info; /* Any fnp ok */ 352 if dn.fdump then go to return_dump_info; /* Has all fnp's */ 353 if dn.fnp = tag then go to return_dump_info; 354 end; 355 call ioa_ ("No dumps for FNP ^a", tag); 356 go to error_return; 357 358 return_dump_info: 359 call forget; 360 empty_dump = "0"b; 361 ename = dn.ename; 362 call hcs_$initiate (env.dump_dir, ename, "", 0, 0, segp, code); 363 if segp = null then do; /* Can't access dump */ 364 call com_err_ (code, name, "^a^[>^]^a", env.dump_dir, (env.dump_dir ^= ">"), ename); 365 if list_size = 1 then go to error_return; 366 env.ename = ename; 367 go to continue_scan_label; 368 end; 369 370 if ^dn.fdump then do; /* Simple dump is easy */ 371 if unspec (segp -> one_k_words) = "0"b then do; 372 call ioa_ ("^a^[>^]^a appears empty.", env.dump_dir, (env.dump_dir ^= ">"), ename); 373 empty_dump = "1"b; 374 end; 375 env.dir = env.dump_dir; 376 env.ename = ename; 377 env.segp = segp; 378 env.corep = segp; 379 env.dump_sw = "1"b; 380 call parse_fnp_name_ (dn.fnp, env.fnp); 381 call set_dump_time; 382 call setup_crashed_line; 383 if empty_dump then if list_size > 1 then go to continue_scan_label; 384 call ioa_ ("Using ^a, ^[line ^a^;^sNo TIB available.^]", env.ename, (env.tty_name ^= ""), env.tty_name); 385 call clean_up; 386 return; 387 end; 388 389 if tag ^= "" then do; /* See if request fnp in this dump */ 390 call parse_fnp_name_ (tag, i); 391 p = addr (segp -> fdump.fnp_dump (i)); 392 if unspec (p -> one_k_words) = "0"b then do; 393 call ioa_ ("No data for FNP ^a in ^a", tag, ename); 394 empty_dump = "1"b; 395 end; 396 go to use_fdump; 397 end; 398 399 do i = 1 to hbound (segp -> fdump.fnp_dump, 1); /* Look at pieces of fdumps */ 400 p = addr (segp -> fdump.fnp_dump (i)); 401 if unspec (p -> one_k_words) ^= "0"b then /* Found good component */ 402 go to use_fdump; 403 end; 404 405 i = 1; 406 p = addr (segp -> fdump.fnp_dump (1)); 407 call ioa_ ("^a^[>^]^a appears empty.", env.dump_dir, (env.dump_dir ^= ">"), ename); 408 empty_dump = "1"b; 409 410 use_fdump: 411 env.ename = ename; 412 env.dir = env.dump_dir; 413 env.segp = segp; 414 env.corep = p; 415 env.fnp = i; 416 env.dump_sw, env.fdump_sw = "1"b; 417 call set_dump_time; 418 call setup_crashed_line; 419 if empty_dump then if list_size > 1 then go to continue_scan_label; 420 call ioa_ ("Using ^a (fnp ^a), ^[line ^a^;^sNo TIB available.^]", env.ename, get_fnp_name_ (env.fnp), (env.tty_name ^= ""), env.tty_name); 421 call clean_up; 422 return; 423 424 /* Find the next earliest dump */ 425 426 prev_dump: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 427 428 call setup; 429 430 if ^env.dump_sw then do; 431 call ioa_ ("Not currently using a dump."); 432 go to error_return; 433 end; 434 435 continue_scan_label = prev_dump_continue; 436 on cleanup call clean_up; 437 call get_opt_tag; 438 439 call list_dumps; 440 prev_dump_continue: 441 call find_current; 442 do i = dnx - 1 to 1 by -1; 443 dnp = list.dnp (i); 444 if tag = "" then go to return_dump_info; 445 if dn.fdump then go to return_dump_info; 446 if dn.fnp = tag then go to return_dump_info; 447 end; 448 449 if tag ^= "" then call ioa_ ("No more dumps for FNP ^a", tag); 450 else call ioa_ ("^a is the oldest dump.", env.ename); 451 go to error_return; 452 453 /* Get the next lastest dump */ 454 455 next_dump: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 456 457 call setup; 458 459 if ^env.dump_sw then do; 460 call ioa_ ("Not currently using a dump."); 461 go to error_return; 462 end; 463 464 continue_scan_label = next_dump_continue; 465 466 on cleanup call clean_up; 467 call get_opt_tag; 468 469 call list_dumps; 470 next_dump_continue: 471 call find_current; 472 do i = dnx + 1 to list_size; 473 dnp = list.dnp (i); 474 if tag = "" then go to return_dump_info; 475 if dn.fdump then go to return_dump_info; 476 if tag = dn.fnp then go to return_dump_info; 477 end; 478 479 if tag ^= "" then call ioa_ ("No more dumps for FNP ^a", tag); 480 else call ioa_ ("^a is the most recent dump", env.ename); 481 go to error_return; 482 483 /* Select a differnt fnp from a multi-fnp segment */ 484 485 select_fdump_fnp: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 486 487 call setup; 488 489 if ^env.dump_sw then do; 490 call ioa_ ("Only valid on dumps."); 491 go to error_return; 492 end; 493 494 call get_tag; 495 p = addr (env.segp -> fdump.fnp_dump (fnp)); 496 if unspec (p -> one_k_words) = "0"b then /* No data */ 497 call ioa_ ("No data for FNP ^a in ^a", tag, env.ename); 498 499 if fnp ^= env.fnp then do; /* Something changing */ 500 call forget_fnp; 501 env.fnp = fnp; 502 env.corep = p; 503 end; 504 call setup_crashed_line; 505 if env.tty_name ^= "" then call ioa_ ("^[Using line ^a^;^sNo TIB available.^]", env.tty_name); 506 return; 507 508 /* Procedure to print name of current dump, image, fnp, etc */ 509 510 what: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 511 512 call setup; 513 514 if ^(env.fnp_sw | env.dump_sw | env.image_sw) then do; 515 call ioa_ ("Nothing"); 516 return; 517 end; 518 519 call get_version; 520 521 if env.fnp_sw then call ioa_ ("FNP ^a, version ^a", get_fnp_name_ (env.fnp), version); 522 else if image_sw then call ioa_ ("Core image in ^a^[>^]^a, version ^a", env.dir, (env.dir ^= ">"), env.ename, 523 version); 524 else if env.dump_sw then if ^env.fdump_sw then 525 call ioa_ ("Dump in ^a^[>^]^a, version ^a", env.dir, (env.dir ^= ">"), env.ename, version); 526 else call ioa_ ("Fdump in ^a^[>^]^a (fnp ^a), version ^a", env.dir, (env.dir ^= ">"), env.ename, 527 get_fnp_name_ (env.fnp), version); 528 529 return; 530 531 /* Entry to implement the when command which prints interesting stuff about times */ 532 533 when: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 534 535 call setup; 536 call get_version; 537 call fetch (crldt, 4, addr (bind_time), "0"b); 538 if code ^= 0 then go to error_return; 539 call fetch (crbdt, 4, addr (boot_time), "0"b); 540 if code ^= 0 then go to error_return; 541 call date_time_ (bind_time, time_string); 542 call ioa_ ("MCS version ^a, bound on ^a", version, time_string); 543 if boot_time ^= 0 then do; 544 call date_time_ (boot_time, time_string); 545 call ioa_ ("Booted on ^a", time_string); 546 end; 547 if env.fnp_sw then do; 548 up_time = max (0, clock () - boot_time); 549 call ioa_ ("FNP has been up for ^a", edit_interval (up_time)); 550 end; 551 if env.dump_sw & env.dump_time ^= 0 then do; 552 up_time = max (0, env.dump_time - boot_time); 553 call ioa_ ("FNP up for ^a before crash", edit_interval (up_time)); 554 end; 555 return; 556 557 /* Entry to select a specific fnp channel. It will switch FNP's to get the requested line if necessary */ 558 559 line: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 560 561 call setup; 562 563 if ^(fnp_sw | dump_sw) then do; 564 call ioa_ ("Only valid on running FNP, or a dump."); 565 go to error_return; 566 end; 567 568 call get_operand; 569 if cmd_info.endline then do; /* No operands, print current line */ 570 if env.tty_name = "" then call ioa_ ("No line selected."); 571 else call ioa_ ("Line ^a. ^[TIB at ^o^]", env.tty_name, expr_info.tib_known, expr_info.tib_addr); 572 return; 573 end; 574 575 tty_name = operand; 576 print_channel_name = "0"b; 577 if operand = "-login" | operand = "-login_channel" then do; 578 call user_info_$terminal_data ((""), (""), tty_name, (0), ("")); 579 print_channel_name = "1"b; 580 end; 581 else if operand = "-crash" then do; 582 if ^env.dump_sw then do; 583 call ioa_ ("Not current using a dump."); 584 go to error_return; 585 end; 586 call find_crashed_line ("0"b); 587 if tty_name = "" then go to error_return; 588 print_channel_name = "1"b; 589 end; 590 591 i = cv_oct_check_ (tty_name, code); /* An octal line number is always for this FNP */ 592 if code = 0 then fnp = max (1, env.fnp); /* If we know the FNP, that is */ 593 else call parse_tty_name_ (tty_name, fnp, ("0"b), (0), (0)); /* Check name, ignoring all but fnp result */ 594 if fnp < 0 then do; /* Bad format name */ 595 call ioa_ ("Illegal tty name: ^a", tty_name); 596 go to error_return; 597 end; 598 599 if (env.fnp > 0) & (env.fnp ^= fnp) then do; /* If current FNP known, do some checking */ 600 if env.fnp_sw then do; /* Running live fnp's */ 601 if ^substr (env.fnps_configured, fnp, 1) then do; 602 call ioa_ ("^a is on FNP ^a which is not configured.", tty_name, get_fnp_name_ (fnp)); 603 go to error_return; 604 end; 605 call ioa_ ("Switching to FNP ^a", get_fnp_name_ (fnp)); 606 call forget_fnp; 607 env.fnp = fnp; 608 end; 609 else if env.fdump_sw then do; /* Running fdump */ 610 p = addr (env.segp -> fdump.fnp_dump (fnp)); /* Find piece for new fnp */ 611 if unspec (p -> one_k_words) = "0"b then do; 612 call ioa_ ("^a is on FNP ^a; no data in ^a for FNP ^a", 613 tty_name, get_fnp_name_ (fnp), env.ename, get_fnp_name_ (fnp)); 614 go to error_return; 615 end; 616 call ioa_ ("Switching to FNP ^a", get_fnp_name_ (fnp)); 617 call forget_fnp; 618 env.corep = p; 619 env.fnp = fnp; 620 end; 621 else do; 622 call ioa_ ("^a is on FNP ^a, dump is for FNP ^a", tty_name, get_fnp_name_ (fnp), get_fnp_name_ (env.fnp)); 623 go to error_return; 624 end; 625 end; 626 627 call setup_line_data ("0"b); 628 if env.tty_name = "" then go to error_return; 629 if print_channel_name then call ioa_ ("Using ^a", env.tty_name); 630 return; 631 632 /* Procedure to check an argument for a valid FNP tag */ 633 634 get_tag: proc; 635 636 call get_operand_req ("Tag"); 637 tag_join: 638 call parse_fnp_name_ (operand, fnp); 639 if fnp < 0 then do; 640 call ioa_ ("Invalid FNP tag: ^a", operand); 641 go to error_return; 642 end; 643 tag = operand; 644 return; 645 646 get_opt_tag: entry; 647 648 call get_operand; 649 if cmd_info.endline then do; 650 tag = ""; 651 return; 652 end; 653 go to tag_join; 654 655 end get_tag; 656 657 /* Procedure to check an argument for a pathname */ 658 659 get_seg: proc; 660 661 call get_operand_req ("Pathname"); 662 663 call expand_pathname_ (operand, dir, ename, code); 664 if code ^= 0 then do; 665 call com_err_ (code, "", "^a", operand); 666 go to error_return; 667 end; 668 669 call check_star_name_$entry (ename, code); 670 if code = 1 | code = 2 then do; /* Allow starnames as shorthand */ 671 areap = get_system_free_area_ (); 672 call hcs_$star_ (dir, ename, 3, areap, entry_cnt1, entryp1, namep1, code); 673 if code ^= 0 then do; 674 call com_err_ (code, "", "^a^[>^]^a", dir, (dir ^= ">"), ename); 675 go to error_return; 676 end; 677 if entry_cnt1 > 1 then do; 678 call ioa_ ("^a matches multiple entries in ^a", ename, dir); 679 go to error_return; 680 end; 681 ename = names1 (entries1.nindex (1)); /* Use first name */ 682 free entries1; 683 free names1; 684 entryp1, namep1 = null (); 685 end; 686 687 call hcs_$initiate (dir, ename, "", 0, 0, segp, code); 688 if segp = null then do; 689 call com_err_ (code, "", "^a^[>^]^a", dir, (dir ^= ">"), ename); 690 go to error_return; 691 end; 692 return; 693 694 end get_seg; 695 696 /* Be sure a required operand is present */ 697 698 get_operand_req: proc (s); 699 700 dcl s char (*); 701 702 call get_operand; 703 if ^cmd_info.endline then return; 704 call ioa_ ("^a missing.", s); 705 go to error_return; 706 707 end get_operand_req; 708 709 get_operand: proc; 710 711 call db_fnp_reader_$get_operand (cmd_infop); 712 if cmd_info.error then go to error_return; 713 714 return; 715 716 end get_operand; 717 718 /* Procedure for "forgetting" the current fnp, dump, etc., in preperation for a new one */ 719 720 forget: proc; 721 722 call forget_fnp; 723 env.dump_sw = "0"b; 724 env.fnp_sw = "0"b; 725 env.image_sw = "0"b; 726 env.fdump_sw = "0"b; 727 env.dump_time = 0; 728 if env.segp ^= null () then do; 729 call hcs_$terminate_noname (env.segp, code); 730 env.segp = null (); 731 end; 732 733 env.corep = null (); 734 env.fnp = -1; 735 return; 736 737 end forget; 738 739 /* Forget data associated with the current FNP. This is used with last drastic environment changes, like when 740* changing to a new fnp in an fdump */ 741 742 forget_fnp: proc; 743 744 string (expr_info.flags) = "0"b; 745 env.tty_name = ""; 746 call db_fnp_disp_cmd_$forget; /* Forget next buffer address */ 747 return; 748 749 end forget_fnp; 750 751 /* Procedure to find the current dump in the dump list */ 752 753 find_current: proc; 754 755 do dnx = 1 to list_size; 756 dnp = list.dnp (dnx); 757 if dn.ename = env.ename then return; 758 end; 759 call ioa_ ("Unable to find current dump: ^a", env.ename); 760 go to error_return; 761 762 end find_current; 763 764 /* Procedure to convert a dump time back into a clock value */ 765 766 set_dump_time: proc; 767 768 on conversion go to return_no_time; 769 call encode_clock_value_ (bin (dn.month), bin (dn.day), 1900 + bin (dn.year), bin (dn.hour), 770 bin (dn.min), 0, 0, 0, " ", env.dump_time, code); 771 if code ^= 0 then env.dump_time = 0; 772 return; 773 return_no_time: 774 env.dump_time = 0; 775 return; 776 777 end set_dump_time; 778 779 /* Get the current version */ 780 781 get_version: proc; 782 783 dcl i fixed bin; 784 dcl test_char bit (9); 785 786 call fetch (crver, 2, addr (version), "0"b); 787 if code ^= 0 then version = "?"; 788 do i = 1 to length (version); 789 test_char = unspec (substr (version, i, 1)); 790 if test_char < "040"b3 | test_char > "176"b3 then version = "?"; 791 end; 792 return; 793 794 end get_version; 795 796 /* Procedure to edit a time interval */ 797 798 edit_interval: proc (arg_interval) returns (char (64) var); 799 800 dcl arg_interval fixed bin (71); 801 802 dcl interval fixed bin (71); 803 dcl (hours, minutes) fixed bin; 804 dcl work_string char (64) var; 805 806 interval = arg_interval + 30000000; 807 hours = divide (interval, 3600000000, 17, 0); 808 interval = interval - 3600000000 * hours; 809 minutes = divide (interval, 60000000, 17, 0); 810 call ioa_$rsnnl ("^[^d hour^[s^]^;^2s^]^[^[, ^]^d min^[s^]^;^3s^]^[seconds^]", work_string, (0), 811 (hours ^= 0), hours, (hours ^= 1), 812 (minutes ^= 0), (hours ^= 0), minutes, (minutes ^= 1), 813 ((hours = 0) & (minutes = 0))); 814 return (work_string); 815 816 end edit_interval; 817 818 /* Procedure to get a list of dumps */ 819 820 list_dumps: proc; 821 822 dcl i fixed bin; 823 824 areap = get_system_free_area_ (); 825 call hcs_$star_ (env.dump_dir, fnp_dump_starname, 3, areap, entry_cnt1, entryp1, namep1, code); 826 /* List normal fnp dumps */ 827 if (code ^= 0) & (code ^= error_table_$nomatch) then go to list_dumps_error; 828 call hcs_$star_ (env.dump_dir, fdump_starname, 3, areap, entry_cnt2, entryp2, namep2, code); 829 /* List fdumps */ 830 if (code ^= 0) & (code ^= error_table_$nomatch) then go to list_dumps_error; 831 832 if (entry_cnt1 + entry_cnt2) = 0 then do; /* None of either kind */ 833 call ioa_ ("No dumps in ^a", env.dump_dir); 834 go to error_return; 835 end; 836 837 dntab_size = entry_cnt1 + entry_cnt2; /* Number of dumps is regular count + fdumps */ 838 allocate dntab in (system_area); 839 dnx = 0; 840 do i = 1 to entry_cnt1; /* Make entries for regular dumps */ 841 dnx = dnx+1; 842 dnp = addr (dntab.dne (dnx)); 843 dn.ename = names1 (entries1.nindex (i)); 844 dn.year = substr (dn.ename, 11, 2); 845 dn.month = substr (dn.ename, 7, 2); 846 dn.day = substr (dn.ename, 9, 2); 847 dn.hour = substr (dn.ename, 14, 2); 848 dn.min = substr (dn.ename, 16, 2); 849 dn.fnp = substr (dn.ename, 5, 1); 850 dn.fdump = "0"b; 851 end; 852 853 do i = 1 to entry_cnt2; /* Scan each fdump */ 854 dnx = dnx+1; 855 dnp = addr (dntab.dne (dnx)); 856 dn.ename = names2 (entries2.nindex (i)); 857 dn.year = substr (dn.ename, 5, 2); 858 dn.month = substr (dn.ename, 1, 2); 859 dn.day = substr (dn.ename, 3, 2); 860 dn.hour = substr (dn.ename, 8, 2); 861 dn.min = substr (dn.ename, 10, 2); 862 dn.fnp = ""; 863 dn.fdump = "1"b; 864 end; 865 866 list_size = dnx; /* Total dumps */ 867 allocate list in (system_area); 868 do i = 1 to list_size; 869 list.dnp (i) = addr (dntab.dne (i)); 870 end; 871 call sort_items_$char (listp, length (string (dn.sort_key))); 872 return; 873 874 list_dumps_error: 875 call com_err_ (code, name, "^a", env.dump_dir); 876 go to error_return; 877 878 end list_dumps; 879 880 error_return: 881 cmd_info.flush = "1"b; 882 call clean_up; 883 return; 884 885 /* Pick up initial arguments */ 886 887 setup: proc; 888 889 cmd_infop = arg_cmd_infop; 890 expr_infop = arg_expr_infop; 891 envp = cmd_info.envp; 892 return; 893 894 end setup; 895 896 setup_constants: proc; 897 898 if constants_setup then return; 899 crver = db_fnp_sym_util_$get_value (".crver"); 900 crldt = db_fnp_sym_util_$get_value (".crldt"); 901 crbdt = db_fnp_sym_util_$get_value (".crbdt"); 902 crreg = db_fnp_sym_util_$get_value (".crreg"); 903 crpte = db_fnp_sym_util_$get_value (".crpte"); 904 t_line = db_fnp_sym_util_$get_value ("t.line"); 905 constants_setup = "1"b; 906 return; 907 908 end setup_constants; 909 910 /* Procedure to scan the config deck for fnp cards */ 911 912 find_configured_fnps: proc; 913 1 1 /* BEGIN INCLUDE FILE ... config_prph_fnp_card.incl.pl1 BIM 1983 */ 1 2 /* format: style3 */ 1 3 1 4 dcl prph_fnp_cardp ptr; /* Pointer to a PRPH fnpx card. */ 1 5 1 6 dcl 1 prph_fnp_card based (prph_fnp_cardp) aligned, 1 7 /* PRPH fnpx card declaration */ 1 8 2 word char (4), /* "prph" */ 1 9 2 name char (4), /* "fnpX" */ 1 10 2 iom fixed bin (3), /* IOM number */ 1 11 2 chan fixed bin (8), /* channel number */ 1 12 2 state char (4) aligned, /* ON/OFF */ 1 13 2 pad (10) bit (36) aligned, 1 14 2 type_word aligned, 1 15 3 field_type (14) bit (2) unaligned, /* type of each field; see config_deck.incl.pl1 */ 1 16 3 pad1 bit (4) unaligned, 1 17 3 n_fields fixed bin (4) unsigned unaligned; 1 18 /* number of fields used on card */ 1 19 1 20 /* END INCLUDE FILE ... config_prph_fnp_card.incl.pl1 */ 914 915 declare fnpx fixed bin; 916 917 env.fnps_configured = "0"b; 918 919 do fnpx = 1 to 8; 920 prph_fnp_cardp = null (); 921 call config_$find_2 ("prph", "fnp" || get_fnp_name_ (fnpx), prph_fnp_cardp); 922 if prph_fnp_cardp ^= null () 923 then substr (env.fnps_configured, fnpx, 1) = "1"b; 924 end; 925 return; 926 927 end find_configured_fnps; 928 929 /* Procedure to select the first configured FNP */ 930 931 find_first_configured_fnp: proc (quiet_sw); 932 933 dcl quiet_sw bit (1); 934 935 dcl (i, j) fixed bin; 936 937 fnp = -1; 938 j = 0; 939 do i = 1 to length (env.fnps_configured); 940 if substr (env.fnps_configured, i, 1) then do; 941 if fnp = -1 then fnp = i; 942 j = j + 1; 943 end; 944 end; 945 if j = 0 then do; 946 call ioa_ ("No FNP's configured."); 947 return; 948 end; 949 tag = get_fnp_name_ (fnp); 950 if j > 1 then if ^quiet_sw | (fnp ^= 1) then 951 call ioa_ ("Using FNP ^a", tag); 952 return; 953 954 end find_first_configured_fnp; 955 956 /* Called for a dump to find the line casuing the crash */ 957 958 setup_crashed_line: proc; 959 960 call find_crashed_line ("1"b); 961 if tty_name ^= "" then call setup_line_data ("1"b); 962 return; 963 964 end setup_crashed_line; 965 966 find_crashed_line: proc (quiet_sw); 967 968 dcl quiet_sw bit (1); 969 dcl (i, base) fixed bin; 970 971 tty_name = ""; 972 call fetch (crreg, 1, addr (mem_word), quiet_sw); /* Get address of saved registers */ 973 if code ^= 0 then return; 974 i = bin (mem_word (1)); 975 call fetch (i, 1, addr (mem_word), "1"b); /* Read contents of ic */ 976 if code ^= 0 then do; 977 if ^quiet_sw then call ioa_ ("Address of saved registers invalid (.crreg = ^o)", i); 978 return; 979 end; 980 if mem_word (1) = "0"b then do; 981 if ^quiet_sw then call ioa_ ("No fault occured."); 982 return; 983 end; 984 call fetch (i + 4, 1, addr (mem_word), quiet_sw); /* Read value of x1 */ 985 if code ^= 0 then return; 986 if mem_word (1) & "700001"b3 then do; /* Known bad bits for a tib address */ 987 bad_x1: if ^quiet_sw then call ioa_ ("x1 does not point at a tib"); 988 return; 989 end; 990 i = bin (mem_word (1)); 991 call fetch (crpte, 1, addr (mem_word), quiet_sw); /* See if paging being used */ 992 if code ^= 0 then return; 993 if mem_word (1) ^= "0"b then do; /* There is page table */ 994 call fetch (bin (mem_word (1)), 1, addr (mem_word), quiet_sw); /* Get it */ 995 if code ^= 0 then return; 996 ptwp = addr (mem_word (1)); 997 if ptw.active then do; 998 base = 32768 - 256 * (ptw.count + 1); /* Start of window */ 999 if i >= base then /* X1 points into window */ 1000 i = (i - base) + 256 * ptw.base_address; 1001 end; 1002 end; 1003 call fetch (i + t_line, 1, addr (mem_word), quiet_sw); 1004 if code ^= 0 then go to bad_x1; 1005 if (mem_word (1) = "0"b) | (mem_word (1) & "776000"b3) then go to bad_x1; 1006 call ioa_$rsnnl ("^o", tty_name, (0), bin (mem_word (1))); 1007 return; 1008 1009 end find_crashed_line; 1010 1011 setup_line_data: proc (quiet_sw); 1012 1013 dcl quiet_sw bit (1); 1014 1015 env.tty_name = ""; /* Forget current name */ 1016 string (expr_info.flags) = "0"b; 1017 call db_fnp_util_$get_chan_addrs (env.corep, env.fnp, tty_name, expr_infop, code); 1018 if code = error_table_$bad_arg then do; 1019 if ^quiet_sw then call ioa_ ("^a not configured.", tty_name); 1020 return; 1021 end; 1022 else if code ^= 0 then do; 1023 if ^quiet_sw then call com_err_ (code, "", "Getting data on ^a", tty_name); 1024 return; 1025 end; 1026 1027 call db_fnp_util_$cv_chan_name (env.corep, env.fnp, tty_name, ename, (0), code); /* Get canonical tty name */ 1028 if code = 0 then env.tty_name = ename; 1029 else env.tty_name = tty_name; 1030 return; 1031 1032 end setup_line_data; 1033 1034 fetch: proc (a, l, p, q); 1035 1036 dcl a fixed bin; /* Address to read */ 1037 dcl l fixed bin; /* Length to read */ 1038 dcl p ptr; /* Where to put it */ 1039 dcl q bit (1); /* Quiet switch */ 1040 1041 call db_fnp_memory_$fetch (env.corep, env.fnp, a, l, p, code); 1042 if code ^= 0 then 1043 if ^q then 1044 if l = 1 then call com_err_ (code, name, "Unable to read fnp location ^o.", a); 1045 else call com_err_ (code, name, "Unable to read fnp locations ^o thru ^o", a, a + l - 1); 1046 1047 return; 1048 1049 end fetch; 1050 1051 /* Cleanup handler */ 1052 1053 clean_up: proc; 1054 1055 if listp ^= null then free list; 1056 if dntabp ^= null then free dntab; 1057 if namep1 ^= null then free names1; 1058 if namep2 ^= null then free names2; 1059 if entryp1 ^= null then free entries1; 1060 if entryp2 ^= null then free entries2; 1061 return; 1062 1063 end clean_up; 1064 1065 1066 1067 2 1 /* Begin include file ..... debug_fnp_data.incl.pl1 */ 2 2 2 3 /* Describes various structures used by the debug_fnp command */ 2 4 2 5 /* Written February 1977 by Larry Johnson */ 2 6 2 7 /* Structures describing a symbol table used by the debug_fnp command, 2 8* to find values for common FNP symbols. */ 2 9 2 10 dcl db_fnp_symbols_$db_fnp_symbols_ ext; 2 11 2 12 dcl symbol_tablep ptr; 2 13 2 14 dcl 1 symbol_table aligned based (symbol_tablep), 2 15 2 cnt fixed bin, /* Number of entries */ 2 16 2 maxcnt fixed bin, /* Max count */ 2 17 2 entry (symbol_table.cnt) unal, 2 18 3 one_symbol like sym unal; 2 19 2 20 dcl symp ptr; /* Pointer to one symbol */ 2 21 2 22 dcl 1 sym unal based (symp), 2 23 2 name char (6), 2 24 2 value fixed bin (17), 2 25 2 len fixed bin (17), /* Number of words */ 2 26 2 reloc fixed bin (17), 2 27 2 type fixed bin (17), 2 28 2 flag_mem char (6), /* If non blank, name of word in which this is a flag */ 2 29 2 explain bit (18), /* Offset to explanation for symbol */ 2 30 2 pad bit (18); 2 31 2 32 dcl exptextp ptr; 2 33 2 34 dcl 1 exptext aligned based (exptextp), /* Symbol explanation entry */ 2 35 2 len fixed bin (8) unal, 2 36 2 data char (exptext.len) unal; 2 37 2 38 /* Values for sym.reloc, which is relocation required to find the symbol */ 2 39 2 40 dcl (reloc_abs init (0), /* Value is absolute */ 2 41 reloc_tib init (1), /* Value is relative to current tib addr */ 2 42 reloc_hwcm init (2), /* Value is relative to current hwcm */ 2 43 reloc_sfcm init (3), /* Value is relative to software comm region */ 2 44 reloc_meters init (4)) /* Value is relative to tib meters */ 2 45 int static options (constant); 2 46 2 47 /* Values for sym.type, which is the mode to be used in displaying symbol */ 2 48 2 49 dcl (type_oct init (0), /* Octal, default for most symbols */ 2 50 type_char init (1), /* Ascii characters */ 2 51 type_addr init (2), /* Address to be converted to mod|offset */ 2 52 type_clock init (3), /* Multics clock value */ 2 53 type_inst init (4), /* Machine instruction */ 2 54 type_op init (5), /* Interpreter opblock format */ 2 55 type_dec init (6), /* Decimal */ 2 56 type_bit init (7), /* In bits */ 2 57 type_ebcdic init (8)) /* 8-bit ebcdic characters */ 2 58 int static options (constant); 2 59 2 60 dcl long_type_names (0:8) char (12) int static options (constant) init ( 2 61 "octal", "character", "address", "clock", "instruction", "opblock", "decimal", "bit", "ebcdic"); 2 62 dcl short_type_names (0:8) char (4) int static options (constant) init ( 2 63 "oct", "ch", "addr", "ck", "inst", "op", "dec", "bit", "ebc"); 2 64 2 65 2 66 /* Structure of suplmental data used in evaluating expressions */ 2 67 2 68 dcl expr_infop ptr; 2 69 2 70 dcl 1 expr_info aligned based (expr_infop), 2 71 2 flags, 2 72 3 star_known bit (1) unal, /* Value of "*" is known */ 2 73 3 tib_known bit (1) unal, /* TIB addresses may be used */ 2 74 3 hwcm_known bit (1) unal, /* HWCM address may be used */ 2 75 3 sfcm_known bit (1) unal, /* SFCM address may be used */ 2 76 3 pad bit (32) unal, 2 77 2 star_addr fixed bin, /* Value of "*" */ 2 78 2 tib_addr fixed bin, /* Address of TIB */ 2 79 2 hwcm_addr fixed bin, /* Address of HWCM */ 2 80 2 sfcm_addr fixed bin, /* Address of SFCM */ 2 81 2 type fixed bin, /* Expression type (mode for printing) */ 2 82 2 len fixed bin, /* Implied length of expression */ 2 83 2 user_tablep ptr; /* Pointer to a user symbol table */ 2 84 2 85 2 86 /* Structure of opcode table of machine instructions */ 2 87 2 88 dcl db_fnp_opcodes_$ ext; 2 89 2 90 dcl optablep ptr; 2 91 2 92 dcl 1 optable aligned based (optablep), 2 93 2 cnt fixed bin, 2 94 2 entry (optable.cnt) unal, 2 95 3 one_op like op; 2 96 2 97 dcl opp ptr; 2 98 2 99 dcl 1 op unal based (opp), 2 100 2 name char (6), /* The mneumonic */ 2 101 2 code bit (12), /* The opcode */ 2 102 2 mask bit (12), /* Mask that says where the opcode is */ 2 103 2 type fixed bin (11), /* Type of display required */ 2 104 2 pad bit (18); 2 105 2 106 /* Values for op.type are: 2 107* 0 - storage reference 2 108* 1 - non-storage reference (immediate), 2 109* 2 - non-storage reference (iacxn only), 2 110* 3 - non-storage reference (shifts), 2 111* 4 - non-storage reference (no operands) */ 2 112 2 113 2 114 /* Stuctures used while parsing commands into operands */ 2 115 2 116 dcl cmd_infop ptr; 2 117 2 118 dcl 1 cmd_info aligned based (cmd_infop), 2 119 2 inbuf char (256), /* For reading lines */ 2 120 2 opbuf char (256), /* Used for operand in undoubling quotes */ 2 121 2 commandp ptr, /* Address of unparsed part of command */ 2 122 2 commandl fixed bin, /* Length of unparsed part */ 2 123 2 operandp ptr, /* Address of current operand */ 2 124 2 operandl fixed bin, /* And its length */ 2 125 2 error bit (1), /* Set if error parsing operand */ 2 126 2 endline bit (1), /* Set if no more operands on line */ 2 127 2 opstring bit (1), /* Set if operand was unquoted string */ 2 128 2 flush bit (1), /* If set, rest of input line will be ignored */ 2 129 2 envp ptr; /* Pointer to the debug_fnp environment structure */ 2 130 2 131 dcl command char (cmd_info.commandl) based (cmd_info.commandp); 2 132 dcl operand char (cmd_info.operandl) based (cmd_info.operandp); 2 133 2 134 /* The following structure describes the current debug_fnp environment. */ 2 135 /* It specifies whether we are working on a dump, fnp, core image, etc. */ 2 136 2 137 dcl envp ptr; 2 138 2 139 dcl 1 env aligned based (envp), 2 140 2 corep ptr, /* Ptr to current dump or core-image. Null means live FNP */ 2 141 2 fnp fixed bin, /* Current fnp number */ 2 142 2 dump_dir char (168) unal, /* Directory where dumps are found */ 2 143 2 dir char (168) unal, /* Directory for current dump or core image */ 2 144 2 ename char (32) unal, /* Ename for current dump or core image */ 2 145 2 tty_name char (32), /* Name of current channel */ 2 146 2 segp ptr, /* Pointer to base of current segment */ 2 147 2 flags unal, 2 148 3 fnps_configured bit (8), /* Says which FNP's appear in config deck */ 2 149 3 fnp_sw bit (1), /* 1 if currently working on fnp */ 2 150 3 image_sw bit (1), /* 1 if currently working on a core-image */ 2 151 3 dump_sw bit (1), /* 1 if current working on a dump */ 2 152 3 fdump_sw bit (1), /* 1 if current dump is a fdump */ 2 153 3 pad bit (24), 2 154 2 dump_time fixed bin (71); /* Clock time dump occured */ 2 155 2 156 /* Structure of data defining table of interpreter opblock names */ 2 157 2 158 dcl db_fnp_opblocks_$ ext; 2 159 2 160 dcl opblock_tablep ptr; 2 161 2 162 dcl 1 opblock_table aligned based (opblock_tablep), 2 163 2 cnt fixed bin, 2 164 2 name (0:opblock_table.cnt) char (6) unal; 2 165 2 166 /* End include file ..... debug_fnp_data.incl.pl1 */ 1068 1069 1070 end db_fnp_env_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 06/01/84 1427.8 db_fnp_env_.pl1 >special_ldd>temp>bce>06/01/84>db_fnp_env_.pl1 914 1 06/01/84 1103.1 config_prph_fnp_card.incl.pl1 >special_ldd>temp>bce>06/01/84>config_prph_fnp_card.incl.pl1 1068 2 06/19/81 2115.0 debug_fnp_data.incl.pl1 >ldd>include>debug_fnp_data.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. a parameter fixed bin(17,0) dcl 1036 set ref 1034 1041* 1042* 1045* 1045 absolute_pathname_ 000020 constant entry external dcl 124 ref 309 active 0(12) based bit(1) level 2 packed unaligned dcl 99 ref 997 addr builtin function dcl 159 ref 276 288 391 400 406 495 537 537 539 539 610 786 786 842 855 869 972 972 975 975 984 984 991 991 994 994 996 1003 1003 addrel builtin function dcl 159 ref 236 areap 000174 automatic pointer dcl 40 set ref 671* 672* 824* 825* 828* 838 867 arg_cmd_infop parameter pointer dcl 25 ref 202 224 243 297 321 339 426 455 485 510 533 559 889 arg_corep parameter pointer dcl 23 ref 202 224 243 297 321 339 426 455 485 510 533 559 arg_envp parameter pointer dcl 27 ref 163 165 190 192 arg_expr_infop parameter pointer dcl 26 ref 202 224 243 297 321 339 426 455 485 510 533 559 890 arg_fnp parameter fixed bin(17,0) dcl 24 ref 202 224 243 297 321 339 426 455 485 510 533 559 arg_interval parameter fixed bin(71,0) dcl 800 ref 798 806 base 000505 automatic fixed bin(17,0) dcl 969 set ref 998* 999 999 base_address based fixed bin(10,0) level 2 packed unsigned unaligned dcl 99 ref 999 bin builtin function dcl 159 ref 769 769 769 769 769 769 769 769 769 974 990 994 994 1006 1006 bind_time 000216 automatic fixed bin(71,0) dcl 45 set ref 537 537 541* boot_time 000220 automatic fixed bin(71,0) dcl 45 set ref 539 539 543 544* 548 552 check_star_name_$entry 000022 constant entry external dcl 125 ref 669 cleanup 000262 stack reference condition dcl 157 ref 228 247 325 344 436 466 clock builtin function dcl 159 ref 548 cmd_info based structure level 1 dcl 2-118 cmd_infop 000272 automatic pointer dcl 2-116 set ref 302 307 307 307 307 309 309 309 311 311 311 569 575 575 577 577 577 577 581 581 637 637 637 640 640 640 643 643 649 663 663 663 665 665 665 703 711* 712 880 889* 891 cnt based fixed bin(17,0) level 2 dcl 89 set ref 867* 1055 code 000100 automatic fixed bin(35,0) dcl 31 set ref 261* 262 273* 274 309* 310 311* 362* 364* 538 540 591* 592 663* 664 665* 669* 670 670 672* 673 674* 687* 689* 729* 769* 771 787 825* 827 827 828* 830 830 874* 973 976 985 992 995 1004 1017* 1018 1022 1023* 1027* 1028 1041* 1042 1042* 1045* com_err_ 000024 constant entry external dcl 126 ref 311 364 665 674 689 874 1023 1042 1045 config_$find_2 000026 constant entry external dcl 127 ref 921 constants_setup 000016 internal static bit(1) initial unaligned dcl 120 set ref 898 905* continue_scan_label 000210 automatic label variable local dcl 43 set ref 342* 367 383 419 435* 464* conversion 000000 stack reference condition dcl 157 ref 768 corep based pointer level 2 dcl 2-139 set ref 167* 236* 255* 279* 378* 414* 502* 618* 733* 1017* 1027* 1041* count 0(13) based fixed bin(5,0) level 2 packed unsigned unaligned dcl 99 ref 998 crbdt 000012 internal static fixed bin(17,0) dcl 116 set ref 539* 901* crldt 000011 internal static fixed bin(17,0) dcl 115 set ref 537* 900* crpte 000014 internal static fixed bin(17,0) dcl 118 set ref 903* 991* crreg 000013 internal static fixed bin(17,0) dcl 117 set ref 902* 972* crver 000010 internal static fixed bin(17,0) dcl 114 set ref 786* 899* cv_oct_check_ 000030 constant entry external dcl 128 ref 591 date_time_ 000032 constant entry external dcl 129 ref 541 544 day 1 based char(2) level 3 packed unaligned dcl 70 set ref 769 769 846* 859* db_fnp_disp_cmd_$forget 000034 constant entry external dcl 130 ref 177 746 db_fnp_memory_$fetch 000036 constant entry external dcl 131 ref 1041 db_fnp_reader_$get_operand 000040 constant entry external dcl 132 ref 711 db_fnp_sym_util_$get_value 000042 constant entry external dcl 133 ref 899 900 901 902 903 904 db_fnp_util_$cv_chan_name 000044 constant entry external dcl 134 ref 1027 db_fnp_util_$get_chan_addrs 000046 constant entry external dcl 135 ref 1017 dir 55 based char(168) level 2 in structure "env" packed unaligned dcl 2-139 in procedure "db_fnp_env_" set ref 169* 234* 253* 266* 266 286* 286 375* 412* 522* 522 524* 524 526* 526 dir 000102 automatic char(168) unaligned dcl 33 in procedure "db_fnp_env_" set ref 234 253 307* 309* 316 663* 672* 674* 674 678* 687* 689* 689 divide builtin function dcl 159 ref 807 809 dn based structure level 1 dcl 70 dne based structure array level 2 dcl 83 set ref 842 855 869 dnp 000250 automatic pointer dcl 69 in procedure "db_fnp_env_" set ref 329* 330 350* 352 353 361 370 380 443* 445 446 473* 475 476 756* 757 769 769 769 769 769 769 769 769 769 842* 843 844 844 845 845 846 846 847 847 848 848 849 849 850 855* 856 857 857 858 858 859 859 860 860 861 861 862 863 871 871 dnp 1 based pointer array level 2 in structure "list" packed unaligned dcl 89 in procedure "db_fnp_env_" set ref 329 350 443 473 756 869* dntab based structure level 1 dcl 83 set ref 838 1056 dntab_size 000254 automatic fixed bin(17,0) dcl 82 set ref 837* 838 1056 dntabp 000252 automatic pointer initial dcl 81 set ref 81* 838* 842 855 869 1056 1056 dnx 000164 automatic fixed bin(17,0) dcl 35 set ref 442 472 755* 756* 839* 841* 841 842 854* 854 855 866 dump_dir 3 based char(168) level 2 packed unaligned dcl 2-139 set ref 168* 303* 316* 362* 364* 364 372* 372 375 407* 407 412 825* 828* 833* 874* dump_sw 152(10) based bit(1) level 3 packed unaligned dcl 2-139 set ref 256* 379* 416* 430 459 489 514 524 551 563 582 723* dump_time 154 based fixed bin(71,0) level 2 dcl 2-139 set ref 174* 551 552 727* 769* 771* 773* empty_dump 000206 automatic bit(1) unaligned dcl 42 set ref 360* 373* 383 394* 408* 419 ename 3 based char(32) level 2 in structure "dn" dcl 70 in procedure "db_fnp_env_" set ref 330* 361 757 843* 844 845 846 847 848 849 856* 857 858 859 860 861 ename 127 based char(32) level 2 in structure "env" packed unaligned dcl 2-139 in procedure "db_fnp_env_" set ref 169* 235* 254* 261* 263 263 266* 273* 286* 292* 366* 376* 384* 410* 420* 450* 480* 496* 522* 524* 526* 612* 757 759* ename 000154 automatic char(32) unaligned dcl 34 in procedure "db_fnp_env_" set ref 235 254 361* 362* 364* 366 372* 376 393* 407* 410 663* 669* 672* 674* 678* 681* 687* 689* 1027* 1028 encode_clock_value_ 000050 constant entry external dcl 136 ref 769 endline 210 based bit(1) level 2 dcl 2-118 ref 302 569 649 703 entries1 based structure array level 1 dcl 58 ref 682 1059 entries2 based structure array level 1 dcl 63 ref 1060 entry_cnt1 000236 automatic fixed bin(17,0) dcl 51 set ref 672* 677 682 825* 832 837 840 1059 entry_cnt2 000237 automatic fixed bin(17,0) dcl 51 set ref 828* 832 837 853 1060 entryp1 000244 automatic pointer initial dcl 53 set ref 53* 672* 681 682 684* 825* 843 1059 1059 entryp2 000246 automatic pointer initial dcl 53 set ref 53* 828* 856 1060 1060 env based structure level 1 dcl 2-139 envp 214 based pointer level 2 in structure "cmd_info" dcl 2-118 in procedure "db_fnp_env_" ref 891 envp 000274 automatic pointer dcl 2-137 in procedure "db_fnp_env_" set ref 165* 167 168 169 169 170 171 172 173 174 182 183 192* 194 195 196 212 218 219 232 233 234 235 236 237 251 252 253 254 255 256 261 263 263 265 266 266 266 266 269 269 273 275 276 278 279 280 282 282 286 286 286 288 292 303 316 362 364 364 366 372 372 375 375 376 377 378 379 380 384 384 384 407 407 410 412 412 413 414 415 416 416 420 420 420 420 420 430 450 459 480 489 495 496 499 501 502 505 505 514 514 514 521 521 521 522 522 522 522 524 524 524 524 524 526 526 526 526 526 547 551 551 552 563 563 570 571 582 592 599 599 600 601 607 609 610 612 618 619 622 622 628 629 723 724 725 726 727 728 729 730 733 734 745 757 759 769 771 773 825 828 833 874 891* 917 922 939 940 1015 1017 1017 1027 1027 1028 1029 1041 1041 error 207 based bit(1) level 2 dcl 2-118 ref 712 error_table_$bad_arg 000106 external static fixed bin(35,0) dcl 154 ref 1018 error_table_$nomatch 000110 external static fixed bin(35,0) dcl 155 ref 827 830 expand_pathname_ 000052 constant entry external dcl 138 ref 663 expr_info based structure level 1 dcl 2-70 expr_infop 000270 automatic pointer dcl 2-68 set ref 571 571 744 890* 1016 1017* fdump 13 based bit(1) level 2 in structure "dn" dcl 70 in procedure "db_fnp_env_" set ref 352 370 445 475 850* 863* fdump based structure level 1 dcl 95 in procedure "db_fnp_env_" fdump_starname 000000 constant char(32) initial unaligned dcl 110 set ref 273* 828* fdump_sw 152(11) based bit(1) level 3 packed unaligned dcl 2-139 set ref 278* 416* 524 609 726* flags based structure level 2 in structure "expr_info" dcl 2-70 in procedure "db_fnp_env_" set ref 744* 1016* flags 152 based structure level 2 in structure "env" packed unaligned dcl 2-139 in procedure "db_fnp_env_" set ref 171* flush 212 based bit(1) level 2 dcl 2-118 set ref 880* fnp 2 based fixed bin(17,0) level 2 in structure "env" dcl 2-139 in procedure "db_fnp_env_" set ref 173* 182* 218* 232* 251* 265* 280* 380* 415* 420* 420* 499 501* 521* 521* 526* 526* 592 599 599 607* 619* 622* 622* 734* 1017* 1027* 1041* fnp 000172 automatic fixed bin(17,0) dcl 38 in procedure "db_fnp_env_" set ref 181 182 209 212 218 263* 264 264* 265 265 275* 276 280* 287* 288 495 499 501 592* 593* 594 599 601 602* 602* 605* 605* 607 610 612* 612* 612* 612* 616* 616* 619 622* 622* 637* 639 937* 941 941* 949* 950 fnp 2(18) based char(1) level 3 in structure "dn" packed unaligned dcl 70 in procedure "db_fnp_env_" set ref 353 380* 446 476 849* 862* fnp_dump based structure array level 2 dcl 95 set ref 275 276 288 391 399 400 406 495 610 fnp_dump_starname 000010 constant char(32) initial unaligned dcl 109 set ref 261* 825* fnp_sw 152(08) based bit(1) level 3 packed unaligned dcl 2-139 set ref 183* 219* 514 521 547 563 600 724* fnps_configured 152 based bit(8) level 3 packed unaligned dcl 2-139 set ref 212 601 917* 922* 939 940 fnpx 000456 automatic fixed bin(17,0) dcl 915 set ref 919* 921* 922* get_fnp_name_ 000104 constant entry external dcl 151 ref 420 420 521 521 526 526 602 602 605 605 612 612 612 612 616 616 622 622 622 622 921 949 get_system_free_area_ 000054 constant entry external dcl 139 ref 671 824 get_wdir_ 000056 constant entry external dcl 140 ref 307 hbound builtin function dcl 159 ref 275 399 hcs_$initiate 000060 constant entry external dcl 141 ref 362 687 hcs_$star_ 000062 constant entry external dcl 142 ref 672 825 828 hcs_$terminate_noname 000064 constant entry external dcl 143 ref 195 729 hour 1(18) based char(2) level 3 packed unaligned dcl 70 set ref 769 769 847* 860* hours 000374 automatic fixed bin(17,0) dcl 803 set ref 807* 808 810 810* 810 810 810 i 000362 automatic fixed bin(17,0) dcl 783 in procedure "get_version" set ref 788* 789* i 000426 automatic fixed bin(17,0) dcl 822 in procedure "list_dumps" set ref 840* 843* 853* 856* 868* 869 869* i 000504 automatic fixed bin(17,0) dcl 969 in procedure "find_crashed_line" set ref 974* 975* 977* 984 990* 999 999* 999 1003 i 000466 automatic fixed bin(17,0) dcl 935 in procedure "find_first_configured_fnp" set ref 939* 940 941* i 000101 automatic fixed bin(17,0) dcl 32 in procedure "db_fnp_env_" set ref 328* 329* 349* 350* 390* 391 399* 400* 405* 415 442* 443* 472* 473* 591* image_sw 152(09) based bit(1) level 3 packed unaligned dcl 2-139 set ref 237* 514 522 725* interval 000372 automatic fixed bin(71,0) dcl 802 set ref 806* 807 808* 808 809 ioa_ 000066 constant entry external dcl 144 ref 213 266 269 282 286 292 303 330 355 372 384 393 407 420 431 449 450 460 479 480 490 496 505 515 521 522 524 526 542 545 549 553 564 570 571 583 595 602 605 612 616 622 629 640 678 704 759 833 946 950 977 981 987 1019 ioa_$rsnnl 000070 constant entry external dcl 145 ref 810 1006 j 000467 automatic fixed bin(17,0) dcl 935 set ref 938* 942* 942 945 950 l parameter fixed bin(17,0) dcl 1037 set ref 1034 1041* 1042 1045 length builtin function dcl 159 ref 788 871 871 939 list based structure level 1 dcl 89 set ref 867 1055 list_size 000260 automatic fixed bin(17,0) dcl 88 set ref 328 349 365 383 419 472 755 866* 867 867 868 listp 000256 automatic pointer initial dcl 87 set ref 87* 329 350 443 473 756 867* 869 871* 1055 1055 match_star_name_ 000072 constant entry external dcl 146 ref 261 273 max builtin function dcl 159 ref 548 552 592 mem_word 000232 automatic bit(18) array unaligned dcl 47 set ref 972 972 974 975 975 980 984 984 986 990 991 991 993 994 994 994 994 996 1003 1003 1005 1005 1006 1006 min 2 based char(2) level 3 packed unaligned dcl 70 set ref 769 769 848* 861* minutes 000375 automatic fixed bin(17,0) dcl 803 set ref 809* 810 810* 810 810 month 0(18) based char(2) level 3 packed unaligned dcl 70 set ref 769 769 845* 858* name 000020 constant char(11) initial unaligned dcl 108 set ref 364* 874* 1042* 1045* namep1 000240 automatic pointer initial dcl 52 set ref 52* 672* 681 683 684* 825* 843 1057 1057 namep2 000242 automatic pointer initial dcl 52 set ref 52* 828* 856 1058 1058 names1 based char(32) array dcl 62 ref 681 683 843 1057 names2 based char(32) array dcl 67 ref 856 1058 nindex 0(18) based fixed bin(17,0) array level 2 in structure "entries2" packed unaligned dcl 63 in procedure "db_fnp_env_" ref 856 nindex 0(18) based fixed bin(17,0) array level 2 in structure "entries1" packed unaligned dcl 58 in procedure "db_fnp_env_" ref 681 843 null builtin function dcl 159 ref 52 52 53 53 81 87 167 170 194 196 363 684 688 728 730 733 920 922 1055 1056 1057 1058 1059 1060 one_k_words based bit(36) array dcl 93 ref 266 277 371 392 401 496 611 op based structure level 1 packed unaligned dcl 2-99 operand based char unaligned dcl 2-132 set ref 307 307 309* 311* 575 577 577 581 637* 640* 643 663* 665* operandl 206 based fixed bin(17,0) level 2 dcl 2-118 ref 307 307 309 309 311 311 575 577 577 581 637 637 640 640 643 663 663 665 665 operandp 204 based pointer level 2 dcl 2-118 ref 307 307 309 311 575 577 577 581 637 640 643 663 665 p parameter pointer dcl 1038 in procedure "fetch" set ref 1034 1041* p 000170 automatic pointer dcl 37 in procedure "db_fnp_env_" set ref 276* 277 279 288* 391* 392 400* 401 406* 414 495* 496 502 610* 611 618 parse_fnp_name_ 000102 constant entry external dcl 150 ref 263 380 390 637 parse_tty_name_ 000074 constant entry external dcl 147 ref 593 print_channel_name 000233 automatic bit(1) unaligned dcl 48 set ref 576* 579* 588* 629 prph_fnp_cardp 000454 automatic pointer dcl 1-4 set ref 920* 921* 922 ptw based structure level 1 packed unaligned dcl 99 ptwp 000234 automatic pointer dcl 49 set ref 996* 997 998 999 q parameter bit(1) unaligned dcl 1039 ref 1034 1042 quiet_sw parameter bit(1) unaligned dcl 933 in procedure "find_first_configured_fnp" ref 931 950 quiet_sw parameter bit(1) unaligned dcl 1013 in procedure "setup_line_data" ref 1011 1019 1023 quiet_sw parameter bit(1) unaligned dcl 968 in procedure "find_crashed_line" set ref 966 972* 977 981 984* 987 991* 994* 1003* s parameter char unaligned dcl 700 set ref 698 704* segp 150 based pointer level 2 in structure "env" dcl 2-139 in procedure "db_fnp_env_" set ref 170* 194 195* 196* 233* 252* 266 275 276 288 377* 413* 495 610 728 729* 730* segp 000166 automatic pointer dcl 36 in procedure "db_fnp_env_" set ref 233 236 252 255 362* 363 371 377 378 391 399 400 406 413 687* 688 sort_items_$char 000076 constant entry external dcl 148 ref 871 sort_key based structure level 2 packed unaligned dcl 70 set ref 871 871 string builtin function dcl 159 set ref 171* 744* 871 871 1016* substr builtin function dcl 159 set ref 212 263 263 601 789 844 845 846 847 848 849 857 858 859 860 861 922* 940 sym based structure level 1 packed unaligned dcl 2-22 system_area based area(1024) dcl 57 ref 838 867 t_line 000015 internal static fixed bin(17,0) dcl 119 set ref 904* 1003 tag 000173 automatic char(1) unaligned dcl 39 set ref 207 213* 351 353 355* 389 390* 393* 444 446 449 449* 474 476 479 479* 496* 643* 650* 949* 950* test_char 000363 automatic bit(9) unaligned dcl 784 set ref 789* 790 790 tib_addr 2 based fixed bin(17,0) level 2 dcl 2-70 set ref 571* tib_known 0(01) based bit(1) level 3 packed unaligned dcl 2-70 set ref 571* time_string 000224 automatic char(24) unaligned dcl 46 set ref 541* 542* 544* 545* tty_name 000176 automatic char(32) unaligned dcl 41 in procedure "db_fnp_env_" set ref 575* 578* 587 591* 593* 595* 602* 612* 622* 961 971* 1006* 1017* 1019* 1023* 1027* 1029 tty_name 137 based char(32) level 2 in structure "env" dcl 2-139 in procedure "db_fnp_env_" set ref 172* 269 269* 282 282* 384 384* 420 420* 505 505* 570 571* 628 629* 745* 1015* 1028* 1029* unspec builtin function dcl 159 ref 266 277 371 392 401 496 611 789 up_time 000222 automatic fixed bin(71,0) dcl 45 set ref 548* 549* 552* 553* user_info_$terminal_data 000100 constant entry external dcl 149 ref 578 version 000214 automatic char(4) dcl 44 set ref 521* 522* 524* 526* 542* 786 786 787* 788 789 790* work_string 000376 automatic varying char(64) dcl 804 set ref 810* 814 year based char(2) level 3 packed unaligned dcl 70 set ref 769 844* 857* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. command based char unaligned dcl 2-131 db_fnp_opblocks_$ external static fixed bin(17,0) dcl 2-158 db_fnp_opcodes_$ external static fixed bin(17,0) dcl 2-88 db_fnp_symbols_$db_fnp_symbols_ external static fixed bin(17,0) dcl 2-10 exptext based structure level 1 dcl 2-34 exptextp automatic pointer dcl 2-32 long_type_names internal static char(12) initial array unaligned dcl 2-60 opblock_table based structure level 1 dcl 2-162 opblock_tablep automatic pointer dcl 2-160 opp automatic pointer dcl 2-97 optable based structure level 1 dcl 2-92 optablep automatic pointer dcl 2-90 prph_fnp_card based structure level 1 dcl 1-6 reloc_abs internal static fixed bin(17,0) initial dcl 2-40 reloc_hwcm internal static fixed bin(17,0) initial dcl 2-40 reloc_meters internal static fixed bin(17,0) initial dcl 2-40 reloc_sfcm internal static fixed bin(17,0) initial dcl 2-40 reloc_tib internal static fixed bin(17,0) initial dcl 2-40 short_type_names internal static char(4) initial array unaligned dcl 2-62 symbol_table based structure level 1 dcl 2-14 symbol_tablep automatic pointer dcl 2-12 symp automatic pointer dcl 2-20 type_addr internal static fixed bin(17,0) initial dcl 2-49 type_bit internal static fixed bin(17,0) initial dcl 2-49 type_char internal static fixed bin(17,0) initial dcl 2-49 type_clock internal static fixed bin(17,0) initial dcl 2-49 type_dec internal static fixed bin(17,0) initial dcl 2-49 type_ebcdic internal static fixed bin(17,0) initial dcl 2-49 type_inst internal static fixed bin(17,0) initial dcl 2-49 type_oct internal static fixed bin(17,0) initial dcl 2-49 type_op internal static fixed bin(17,0) initial dcl 2-49 NAMES DECLARED BY EXPLICIT CONTEXT. bad_x1 010127 constant label dcl 987 ref 1004 1005 clean_up 010722 constant entry internal dcl 1053 ref 228 247 325 333 344 385 421 436 466 882 db_fnp_env_ 000734 constant entry external dcl 19 dump_cmd 001235 constant entry external dcl 243 dump_dir 001667 constant entry external dcl 297 dumps 002037 constant entry external dcl 321 edit_interval 006557 constant entry internal dcl 798 ref 549 553 error_return 005330 constant label dcl 880 ref 209 214 312 356 365 432 451 461 481 491 538 540 565 584 587 596 603 614 623 628 641 666 675 679 690 705 712 760 834 876 fetch 010570 constant entry internal dcl 1034 ref 537 539 786 972 975 984 991 994 1003 find_configured_fnps 007516 constant entry internal dcl 912 ref 179 find_crashed_line 007744 constant entry internal dcl 966 ref 586 960 find_current 006233 constant entry internal dcl 753 ref 440 470 find_first_configured_fnp 007606 constant entry internal dcl 931 ref 180 208 fnp_cmd 001071 constant entry external dcl 202 forget 006155 constant entry internal dcl 720 ref 217 231 250 358 forget_fnp 006217 constant entry internal dcl 742 ref 500 606 617 722 get_operand 006141 constant entry internal dcl 709 ref 301 568 648 702 get_operand_req 006076 constant entry internal dcl 698 ref 636 661 get_opt_tag 005430 constant entry internal dcl 646 ref 206 345 437 467 get_seg 005441 constant entry internal dcl 659 ref 229 248 get_tag 005340 constant entry internal dcl 634 ref 494 get_version 006502 constant entry internal dcl 781 ref 519 536 image_cmd 001157 constant entry external dcl 224 init 000746 constant entry external dcl 163 last_dump 002132 constant entry external dcl 339 line 004414 constant entry external dcl 559 list_dumps 006716 constant entry internal dcl 820 ref 327 347 439 469 list_dumps_error 007310 constant label dcl 874 ref 827 830 next_dump 003273 constant entry external dcl 455 next_dump_continue 003352 constant label dcl 470 ref 464 prev_dump 003073 constant entry external dcl 426 prev_dump_continue 003152 constant label dcl 440 ref 342 435 return_dump_info 002250 constant label dcl 358 ref 351 352 353 444 445 446 474 475 476 return_no_time 006475 constant label dcl 773 ref 768 select_fdump_fnp 003471 constant entry external dcl 485 set_dump_time 006300 constant entry internal dcl 766 ref 381 417 setup 007340 constant entry internal dcl 887 ref 204 226 245 299 323 341 428 457 487 512 535 561 setup_constants 007354 constant entry internal dcl 896 ref 175 setup_crashed_line 007726 constant entry internal dcl 958 ref 268 281 382 418 504 setup_line_data 010364 constant entry internal dcl 1011 ref 627 961 tag_join 005346 constant label dcl 637 ref 653 term 001030 constant entry external dcl 190 use_fdump 002755 constant label dcl 410 ref 396 401 use_some_dump 001525 constant label dcl 278 ref 289 what 003630 constant entry external dcl 510 when 004124 constant entry external dcl 533 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 11666 12000 11072 11676 Length 12416 11072 112 401 574 10 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME db_fnp_env_ 898 external procedure is an external procedure. on unit on line 228 64 on unit on unit on line 247 64 on unit on unit on line 325 64 on unit on unit on line 344 64 on unit on unit on line 436 64 on unit on unit on line 466 64 on unit get_tag internal procedure shares stack frame of external procedure db_fnp_env_. get_seg internal procedure shares stack frame of external procedure db_fnp_env_. get_operand_req internal procedure shares stack frame of external procedure db_fnp_env_. get_operand internal procedure shares stack frame of external procedure db_fnp_env_. forget internal procedure shares stack frame of external procedure db_fnp_env_. forget_fnp internal procedure shares stack frame of external procedure db_fnp_env_. find_current internal procedure shares stack frame of external procedure db_fnp_env_. set_dump_time 248 internal procedure enables or reverts conditions. on unit on line 768 64 on unit get_version internal procedure shares stack frame of external procedure db_fnp_env_. edit_interval internal procedure shares stack frame of external procedure db_fnp_env_. list_dumps internal procedure shares stack frame of external procedure db_fnp_env_. setup internal procedure shares stack frame of external procedure db_fnp_env_. setup_constants internal procedure shares stack frame of external procedure db_fnp_env_. find_configured_fnps internal procedure shares stack frame of external procedure db_fnp_env_. find_first_configured_fnp internal procedure shares stack frame of external procedure db_fnp_env_. setup_crashed_line internal procedure shares stack frame of external procedure db_fnp_env_. find_crashed_line internal procedure shares stack frame of external procedure db_fnp_env_. setup_line_data internal procedure shares stack frame of external procedure db_fnp_env_. fetch internal procedure shares stack frame of external procedure db_fnp_env_. clean_up 64 internal procedure is called by several nonquick procedures. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 crver db_fnp_env_ 000011 crldt db_fnp_env_ 000012 crbdt db_fnp_env_ 000013 crreg db_fnp_env_ 000014 crpte db_fnp_env_ 000015 t_line db_fnp_env_ 000016 constants_setup db_fnp_env_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME db_fnp_env_ 000100 code db_fnp_env_ 000101 i db_fnp_env_ 000102 dir db_fnp_env_ 000154 ename db_fnp_env_ 000164 dnx db_fnp_env_ 000166 segp db_fnp_env_ 000170 p db_fnp_env_ 000172 fnp db_fnp_env_ 000173 tag db_fnp_env_ 000174 areap db_fnp_env_ 000176 tty_name db_fnp_env_ 000206 empty_dump db_fnp_env_ 000210 continue_scan_label db_fnp_env_ 000214 version db_fnp_env_ 000216 bind_time db_fnp_env_ 000220 boot_time db_fnp_env_ 000222 up_time db_fnp_env_ 000224 time_string db_fnp_env_ 000232 mem_word db_fnp_env_ 000233 print_channel_name db_fnp_env_ 000234 ptwp db_fnp_env_ 000236 entry_cnt1 db_fnp_env_ 000237 entry_cnt2 db_fnp_env_ 000240 namep1 db_fnp_env_ 000242 namep2 db_fnp_env_ 000244 entryp1 db_fnp_env_ 000246 entryp2 db_fnp_env_ 000250 dnp db_fnp_env_ 000252 dntabp db_fnp_env_ 000254 dntab_size db_fnp_env_ 000256 listp db_fnp_env_ 000260 list_size db_fnp_env_ 000270 expr_infop db_fnp_env_ 000272 cmd_infop db_fnp_env_ 000274 envp db_fnp_env_ 000362 i get_version 000363 test_char get_version 000372 interval edit_interval 000374 hours edit_interval 000375 minutes edit_interval 000376 work_string edit_interval 000426 i list_dumps 000454 prph_fnp_cardp find_configured_fnps 000456 fnpx find_configured_fnps 000466 i find_first_configured_fnp 000467 j find_first_configured_fnp 000504 i find_crashed_line 000505 base find_crashed_line THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as r_ne_as alloc_cs call_ext_out_desc call_ext_out call_int_this call_int_other return tra_ext enable shorten_stack ext_entry int_entry any_to_any_tr divide_fx3 alloc_based free_based clock THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. absolute_pathname_ check_star_name_$entry com_err_ config_$find_2 cv_oct_check_ date_time_ db_fnp_disp_cmd_$forget db_fnp_memory_$fetch db_fnp_reader_$get_operand db_fnp_sym_util_$get_value db_fnp_util_$cv_chan_name db_fnp_util_$get_chan_addrs encode_clock_value_ expand_pathname_ get_fnp_name_ get_system_free_area_ get_wdir_ hcs_$initiate hcs_$star_ hcs_$terminate_noname ioa_ ioa_$rsnnl match_star_name_ parse_fnp_name_ parse_tty_name_ sort_items_$char user_info_$terminal_data THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_arg error_table_$nomatch LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 52 000722 53 000725 81 000727 87 000730 19 000733 163 000742 165 000754 167 000760 168 000762 169 000765 170 000773 171 000774 172 000775 173 001000 174 001002 175 001004 177 001005 179 001012 180 001013 181 001017 182 001021 183 001023 186 001025 190 001026 192 001036 194 001042 195 001046 196 001060 198 001063 202 001064 204 001077 206 001100 207 001101 208 001111 209 001115 212 001117 213 001125 214 001145 217 001146 218 001147 219 001152 220 001154 224 001155 226 001165 228 001166 229 001210 231 001211 232 001212 233 001215 234 001217 235 001222 236 001225 237 001230 238 001232 243 001233 245 001243 247 001244 248 001266 250 001267 251 001270 252 001273 253 001275 254 001300 255 001303 256 001304 261 001306 262 001326 263 001330 264 001351 265 001354 266 001360 268 001427 269 001430 270 001462 273 001463 274 001504 275 001506 276 001513 277 001520 278 001525 279 001530 280 001532 281 001534 282 001535 283 001567 285 001570 286 001572 287 001633 288 001635 289 001642 292 001643 293 001664 297 001665 299 001675 301 001676 302 001677 303 001702 304 001723 307 001724 309 001746 310 001772 311 001774 312 002027 316 002030 317 002034 321 002035 323 002045 325 002046 327 002070 328 002071 329 002077 330 002101 331 002120 333 002123 335 002127 339 002130 341 002140 342 002141 344 002144 345 002166 347 002167 349 002170 350 002175 351 002177 352 002207 353 002211 354 002221 355 002224 356 002247 358 002250 360 002251 361 002252 362 002256 363 002322 364 002326 365 002376 366 002401 367 002405 370 002406 371 002411 372 002417 373 002460 375 002462 376 002466 377 002471 378 002473 379 002474 380 002476 381 002516 382 002522 383 002523 384 002531 385 002567 386 002573 389 002574 390 002604 391 002621 392 002626 393 002633 394 002662 396 002664 399 002665 400 002673 401 002677 403 002704 405 002706 406 002710 407 002712 408 002753 410 002755 412 002761 413 002764 414 002766 415 002770 416 002772 417 002776 418 003002 419 003003 420 003011 421 003064 422 003070 426 003071 428 003101 430 003102 431 003106 432 003122 435 003123 436 003126 437 003150 439 003151 440 003152 442 003153 443 003161 444 003163 445 003173 446 003175 447 003205 449 003210 450 003244 451 003270 455 003271 457 003301 459 003302 460 003306 461 003322 464 003323 466 003326 467 003350 469 003351 470 003352 472 003353 473 003363 474 003365 475 003375 476 003377 477 003407 479 003411 480 003445 481 003466 485 003467 487 003477 489 003500 490 003504 491 003520 494 003521 495 003522 496 003530 499 003565 500 003571 501 003572 502 003575 504 003577 505 003600 506 003625 510 003626 512 003636 514 003637 515 003643 516 003656 519 003657 521 003660 522 003725 524 003772 526 004042 529 004121 533 004122 535 004132 536 004133 537 004134 538 004157 539 004161 540 004204 541 004206 542 004223 543 004247 544 004251 545 004266 547 004307 548 004313 549 004324 551 004351 552 004357 553 004367 555 004411 559 004412 561 004422 563 004423 564 004427 565 004443 568 004444 569 004445 570 004450 571 004472 572 004530 575 004531 576 004536 577 004537 578 004547 579 004577 580 004601 581 004602 582 004606 583 004612 584 004626 586 004627 587 004633 588 004637 591 004641 592 004663 593 004674 594 004727 595 004731 596 004754 599 004755 600 004762 601 004765 602 004772 603 005027 605 005030 606 005061 607 005062 608 005065 609 005066 610 005071 611 005076 612 005103 614 005160 616 005161 617 005212 618 005213 619 005215 620 005220 622 005221 623 005273 627 005274 628 005300 629 005305 630 005327 880 005330 882 005333 883 005337 634 005340 636 005341 637 005346 639 005367 640 005371 641 005420 643 005421 644 005427 646 005430 648 005431 649 005432 650 005435 651 005437 653 005440 659 005441 661 005442 663 005447 664 005500 665 005502 666 005535 669 005536 670 005553 671 005560 672 005567 673 005634 674 005636 675 005705 677 005706 678 005711 679 005735 681 005736 682 005747 683 005751 684 005753 687 005756 688 006021 689 006025 690 006074 692 006075 698 006076 702 006107 703 006110 704 006114 705 006140 709 006141 711 006142 712 006151 714 006154 720 006155 722 006156 723 006157 724 006162 725 006164 726 006166 727 006170 728 006172 729 006176 730 006207 733 006212 734 006214 735 006216 742 006217 744 006220 745 006221 746 006225 747 006232 753 006233 755 006234 756 006243 757 006245 758 006253 759 006255 760 006276 766 006277 768 006305 769 006324 771 006466 772 006474 773 006475 775 006501 781 006502 786 006503 787 006526 788 006532 789 006537 790 006544 791 006554 792 006556 798 006557 806 006561 807 006564 808 006570 809 006574 810 006600 814 006706 820 006716 824 006717 825 006726 827 006774 828 007001 830 007047 832 007054 833 007057 834 007101 837 007102 838 007105 839 007113 840 007114 841 007123 842 007124 843 007131 844 007144 845 007147 846 007151 847 007153 848 007156 849 007162 850 007165 851 007166 853 007170 854 007177 855 007200 856 007205 857 007220 858 007222 859 007225 860 007230 861 007234 862 007237 863 007241 864 007243 866 007245 867 007247 868 007257 869 007265 870 007272 871 007274 872 007307 874 007310 876 007337 887 007340 889 007341 890 007345 891 007350 892 007353 896 007354 898 007355 899 007361 900 007377 901 007416 902 007435 903 007454 904 007473 905 007512 906 007515 912 007516 917 007517 919 007522 920 007527 921 007531 922 007571 924 007603 925 007605 931 007606 937 007610 938 007612 939 007613 940 007621 941 007626 942 007633 944 007634 945 007636 946 007640 947 007654 949 007655 950 007670 952 007725 958 007726 960 007727 961 007733 962 007743 966 007744 971 007746 972 007751 973 007773 974 007776 975 010001 976 010011 977 010013 978 010041 980 010042 981 010045 982 010072 984 010073 985 010117 986 010122 987 010127 988 010151 990 010152 991 010154 992 010176 993 010201 994 010204 995 010227 996 010232 997 010234 998 010240 999 010253 1003 010270 1004 010315 1005 010317 1006 010330 1007 010363 1011 010364 1015 010366 1016 010372 1017 010373 1018 010423 1019 010427 1020 010454 1022 010455 1023 010457 1024 010517 1027 010520 1028 010554 1029 010563 1030 010567 1034 010570 1041 010572 1042 010615 1045 010661 1047 010720 1053 010721 1055 010727 1056 010740 1057 010751 1058 010760 1059 010767 1060 010776 1061 011005 ----------------------------------------------------------- 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