COMPILATION LISTING OF SEGMENT db_fnp_break_ Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/15/82 1614.1 mst Mon 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_BREAK_ - Implements the breakpoint options of debug_fnp */ 12 /* Written September 1977 by Larry Johnson */ 13 14 db_fnp_break_: proc; 15 16 /* Parameters */ 17 18 dcl arg_corep ptr; 19 dcl arg_fnp fixed bin; 20 dcl arg_cmd_infop ptr; 21 dcl arg_expr_infop ptr; 22 23 /* Automatic */ 24 25 dcl corep ptr; 26 dcl fnp fixed bin; 27 dcl code fixed bin (35); 28 dcl i fixed bin; 29 dcl something_printed bit (1); 30 dcl edited_addr char (32) var; 31 dcl mem_buf (32) bit (18) unal; 32 dcl ntibs fixed bin; 33 dcl state fixed bin; 34 dcl break_reset bit (1); 35 dcl crbrk_val fixed bin; 36 dcl break_address fixed bin; 37 dcl line_given bit (1); 38 dcl tty_name char (8); 39 dcl stop_trace bit (1); 40 dcl start_trace bit (1); 41 dcl address_given bit (1); 42 dcl reset_sw bit (1); 43 dcl 1 temp_expr_info like expr_info aligned automatic; 44 45 dcl 1 fnp_break_info aligned, /* Info structure for setting breaks */ 46 2 channel char (6), 47 2 address fixed bin, 48 2 action fixed bin, 49 2 flags, 50 3 trace bit (1) unal, 51 3 pad bit (35) unal; 52 53 dcl SET fixed bin int static options (constant) init (1); /* Values for fnp_break_info.action */ 54 dcl RESET fixed bin int static options (constant) init (2); 55 dcl START fixed bin int static options (constant) init (3); 56 57 dcl break_error (7) char (32) var int static options (constant) init ( /* Error codes read from fnp */ 58 "Bad address.", 59 "Bad line number.", 60 "No entry in break table.", 61 "Not stopped at breakpoint.", 62 "No room in break table.", 63 "No opblock at address.", 64 "Invalid request."); 65 66 /* Alocated copy of break table */ 67 68 dcl brk_tab_start fixed bin; 69 dcl brk_tab_size fixed bin; 70 dcl brk_tabp ptr init (null); 71 72 dcl 1 brk_tab aligned based (brk_tabp), 73 2 entry (brk_tab_size) unal, 74 3 address fixed bin (17) unal, 75 3 line fixed bin (17) unal, 76 3 opblock bit (18) unal, 77 3 flags bit (18) unal; 78 79 dcl tib_tablep ptr init (null); /* Pointer to temp copy of tib table */ 80 dcl 1 tib_table aligned based (tib_tablep), 81 2 entries (ntibs) unal, 82 3 address fixed bin (17) unal, /* Address ot tib */ 83 3 q fixed bin (17) unal; /* Address of q */ 84 85 dcl brk_listp ptr init (null); /* Pointer to list of tibs at breaks */ 86 dcl brk_list_cnt fixed bin; /* Number of such tibs */ 87 dcl 1 brk_list aligned based (brk_listp), 88 2 entries (ntibs) unal, 89 3 line fixed bin (17) unal, 90 3 t_cur fixed bin (17) unal; 91 92 /* Internal static */ 93 94 dcl symbols_looked_up bit (1) int static init ("0"b); /* Set once all following symbols are set */ 95 dcl crbrk fixed bin int static; 96 dcl crttb fixed bin int static; 97 dcl crtte fixed bin int static; 98 dcl t_flg3 fixed bin int static; 99 dcl t_cur fixed bin int static; 100 dcl t_line fixed bin int static; 101 dcl bkptop bit (18) int static; 102 dcl tfbkpt bit (18) int static; 103 dcl free_areap ptr int static; 104 dcl call_type fixed bin int static init (0); /* Says which type of ring0 call to use */ 105 106 dcl free_area area based (free_areap); 107 dcl name char (13) int static options (constant) init ("db_fnp_break_"); 108 109 /* External */ 110 111 dcl db_fnp_sym_util_$get_value entry (char (*)) returns (fixed bin); 112 dcl db_fnp_util_$edit_module_addr_force entry (ptr, fixed bin, fixed bin, char (*) var, fixed bin (35)); 113 dcl db_fnp_util_$edit_module_addr_paren entry (ptr, fixed bin, fixed bin, char (*) var, fixed bin (35)); 114 dcl db_fnp_util_$cv_chan_name entry (ptr, fixed bin, char (*), char (*), fixed bin, fixed bin (35)); 115 dcl db_fnp_util_$cv_line_no entry (ptr, fixed bin, fixed bin, char (*), fixed bin (35)); 116 dcl db_fnp_util_$get_chan_addrs entry (ptr, fixed bin, char (*), ptr, fixed bin (35)); 117 dcl db_fnp_opblock_util_$get_name entry (bit (18), char (*)); 118 dcl db_fnp_memory_$fetch entry (ptr, fixed bin, fixed bin, fixed bin, ptr, fixed bin (35)); 119 dcl db_fnp_reader_$get_operand entry (ptr); 120 dcl db_fnp_eval_ entry (ptr, fixed bin, char (*), ptr, char (*), fixed bin, fixed bin (35)); 121 dcl db_fnp_opblock_util_$lookup entry (char (*), bit (18), fixed bin (35)); 122 dcl hphcs_$tty_order entry (fixed bin, char (*), ptr, fixed bin, fixed bin (35)); 123 dcl hphcs_$tty_control entry (char (*), char (*), ptr, fixed bin (35)); 124 dcl sub_err_ entry options (variable); 125 dcl com_err_ entry options (variable); 126 dcl get_system_free_area_ entry returns (ptr); 127 dcl ioa_ entry options (variable); 128 dcl ioa_$nnl entry options (variable); 129 dcl ioa_$rsnnl entry options (variable); 130 dcl iox_$put_chars entry (ptr, ptr, fixed bin (21), fixed bin (35)); 131 dcl timer_manager_$sleep entry (fixed bin (71), bit (2)); 132 dcl get_fnp_name_ entry (fixed bin) returns (char (32)); 133 134 dcl iox_$user_output ext ptr; 135 136 dcl (cleanup, linkage_error) condition; 137 138 dcl (addr, bin, divide, length, max, null, string) builtin; 139 140 /* Entry to set a breakpoint */ 141 142 set: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 143 144 call setup; 145 on cleanup call clean_up; 146 147 if corep ^= null then do; 148 call ioa_ ("Only valid on a running FNP."); 149 go to error_return; 150 end; 151 152 call get_operand; /* Address */ 153 if cmd_info.endline then do; 154 call ioa_ ("No address"); 155 go to error_return; 156 end; 157 158 call db_fnp_eval_ (corep, fnp, operand, expr_infop, "", break_address, code); 159 if code ^= 0 then go to error_return; 160 161 line_given = "0"b; 162 stop_trace = "0"b; 163 call get_operand; /* Scan command line */ 164 do while (^cmd_info.endline); 165 if operand = "-stop_trace" then stop_trace = "1"b; 166 else if ^line_given then do; 167 call db_fnp_util_$cv_chan_name (corep, fnp, operand, tty_name, i, code); /* See if good line number */ 168 if code ^= 0 then do; 169 call com_err_ (code, name, "^a", operand); 170 go to error_return; 171 end; 172 line_given = "1"b; 173 end; 174 else do; /* Bad arg */ 175 call ioa_ ("Invalid operand: ^a", operand); 176 go to error_return; 177 end; 178 call get_operand; 179 end; 180 181 fnp_break_info.address = break_address; 182 fnp_break_info.action = SET; 183 if line_given then fnp_break_info.channel = tty_name; 184 else fnp_break_info.channel = ""; 185 string (fnp_break_info.flags) = "0"b; 186 fnp_break_info.trace = stop_trace; 187 188 call make_order_call; 189 call check_break_error; 190 if code ^= 0 then do; 191 call ioa_ ("Break not set: ^a", break_error (code)); 192 go to error_return; 193 end; 194 195 call clean_up; 196 return; 197 198 /* Entry to reset breaks */ 199 200 reset: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 201 202 call setup; 203 on cleanup call clean_up; 204 205 if corep ^= null then do; 206 call ioa_ ("Only valid on a running FNP."); 207 go to error_return; 208 end; 209 210 call get_operand; /* Read address */ 211 if cmd_info.endline then do; 212 call ioa_ ("No address specified"); 213 go to error_return; 214 end; 215 216 if operand = "-all" | operand = "-a" then do; /* Reset all breaks */ 217 call get_break_table; /* First need lines at breaks */ 218 break_reset = "0"b; 219 do i = 1 to brk_tab_size; /* Loop thru all breaks */ 220 if brk_tab.address (i) ^= 0 then do; /* Found non-empty entry */ 221 break_reset = "1"b; 222 call reset_one_break ((brk_tab.address (i))); 223 end; 224 end; 225 if ^break_reset then call ioa_ ("No breaks found."); 226 end; 227 228 else do; /* Reset one break */ 229 call db_fnp_eval_ (corep, fnp, operand, expr_infop, "", i, code); 230 if code = 0 then call reset_one_break (i); 231 end; 232 233 call clean_up; 234 return; 235 236 /* Entry to restart a stopped channel */ 237 238 start: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 239 240 call setup; 241 on cleanup call clean_up; 242 243 if corep ^= null then do; 244 call ioa_ ("Only valid on a running FNP."); 245 go to error_return; 246 end; 247 248 call get_operand; 249 if cmd_info.endline then do; 250 call ioa_ ("No line given."); 251 go to error_return; 252 end; 253 254 if operand = "-all" | operand = "-a" then do; /* Start all lines */ 255 call find_stopped_channels; 256 if brk_list_cnt = 0 then do; /* None */ 257 call ioa_ ("No lines stopped at breaks."); 258 go to start_break_end; 259 end; 260 do i = 1 to brk_list_cnt; /* Start each line */ 261 call db_fnp_util_$cv_line_no (corep, fnp, (brk_list.line (i)), tty_name, code); 262 if code ^= 0 then do; 263 call com_err_ (code, name, "Unable to convert ^o to tty name.", brk_list.line (i)); 264 cmd_info.flush = "1"b; /* Treat as error, but continue */ 265 go to start_next; 266 end; 267 fnp_break_info.channel = tty_name; 268 fnp_break_info.address = 0; 269 fnp_break_info.action = START; 270 string (fnp_break_info.flags) = "0"b; 271 call make_order_call; 272 call check_break_error; 273 if code ^= 0 then do; 274 call ioa_ ("^a not restarted. ^a", tty_name, break_error (code)); 275 cmd_info.flush = "1"b; /* Treat as error */ 276 end; 277 else call ioa_ ("^a restarted.", tty_name); 278 start_next: 279 end; 280 end; 281 282 else do; /* Start one line */ 283 call db_fnp_util_$cv_chan_name (corep, fnp, operand, tty_name, i, code); 284 if code ^= 0 then do; 285 call com_err_ (code, name, "^a", operand); 286 go to error_return; 287 end; 288 address_given = "0"b; 289 reset_sw = "0"b; 290 start_trace = "0"b; 291 call get_operand; 292 do while (^cmd_info.endline); /* Scan command */ 293 if operand = "-reset" then reset_sw = "1"b; 294 else if operand = "-start_trace" then start_trace = "1"b; 295 else if ^address_given then do; 296 call db_fnp_eval_ (corep, fnp, operand, expr_infop, "", break_address, code); 297 if code ^= 0 then go to error_return; 298 address_given = "1"b; 299 end; 300 else do; 301 call ioa_ ("Invalid operand: ^a", operand); 302 go to error_return; 303 end; 304 call get_operand; 305 end; 306 307 if reset_sw then do; 308 temp_expr_info = expr_info; /* Setup dummy structure */ 309 temp_expr_info.tib_known = "0"b; 310 call db_fnp_util_$get_chan_addrs (corep, fnp, tty_name, addr (temp_expr_info), code); 311 if code ^= 0 then do; 312 no_reset_tib: call com_err_ (code, name, "Cant get tib address for ^a", tty_name); 313 go to error_return; 314 end; 315 if ^temp_expr_info.tib_known then go to no_reset_tib; 316 call fetch_words (temp_expr_info.tib_addr + t_cur, 1, addr (mem_buf)); 317 call reset_one_break (bin (mem_buf (1))); 318 end; 319 320 fnp_break_info.channel = tty_name; 321 fnp_break_info.action = START; 322 if address_given then fnp_break_info.address = break_address; 323 else fnp_break_info.address = 0; 324 string (fnp_break_info.flags) = "0"b; 325 fnp_break_info.trace = start_trace; 326 call make_order_call; 327 call check_break_error; 328 if code ^= 0 then do; 329 call ioa_ ("^a not restarted. ^a", tty_name, break_error (code)); 330 go to error_return; 331 end; 332 else call ioa_ ("^a restarted", tty_name); 333 end; 334 start_break_end: 335 call clean_up; 336 return; 337 338 /* Entry to list breakpoints */ 339 340 list: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 341 342 call setup; 343 on cleanup call clean_up; 344 345 call get_break_table; /* Find break table in fnp */ 346 call find_stopped_channels; 347 something_printed = "0"b; 348 do i = 1 to brk_tab_size; 349 if brk_tab.address (i) ^= 0 then 350 call print_one_break ((brk_tab.address (i)), brk_tab.opblock (i), (brk_tab.line (i))); 351 end; 352 do i = 1 to brk_list_cnt; /* Also print lines stopped at non-std breaks */ 353 if brk_list.line (i) ^= -1 then 354 call print_one_break ((brk_list.t_cur (i)), "0"b, -1); 355 end; 356 if ^something_printed then call ioa_ ("No breaks set"); 357 call clean_up; 358 return; 359 360 /* Procedure to print one break point. */ 361 362 print_one_break: proc (a, o, l); 363 364 dcl a fixed bin; /* Address */ 365 dcl o bit (18); /* Origional opblcok */ 366 dcl l fixed bin; /* Line number */ 367 368 dcl i fixed bin; 369 dcl optemp char (6); 370 dcl 1 b unal, /* The bbasic print line */ 371 2 address char (10), 372 2 opblock char (8), 373 2 line char (6); 374 375 if ^something_printed then call ioa_ ("ADDRESS OPBLOCK LINE LINES STOPPED"); 376 something_printed = "1"b; 377 378 call db_fnp_util_$edit_module_addr_force (corep, fnp, a, edited_addr, code); 379 if code ^= 0 then call ioa_$rsnnl ("^o", b.address, (0), a); 380 else b.address = edited_addr; 381 382 if o = "0"b then b.opblock = ""; 383 else do; 384 call db_fnp_opblock_util_$get_name (o, optemp); 385 if optemp = "" then call ioa_$rsnnl ("^.3b", b.opblock, (0), o); 386 else b.opblock = optemp; 387 end; 388 389 if l = -1 then b.line = ""; 390 else do; 391 call db_fnp_util_$cv_line_no (corep, fnp, l, tty_name, code); 392 if code = 0 then b.line = tty_name; 393 else call ioa_$rsnnl ("^o", b.line, (0), l); 394 end; 395 call iox_$put_chars (iox_$user_output, addr (b), length (string (b)), code); 396 397 do i = 1 to brk_list_cnt; /* Print lines stopped at this break */ 398 if (brk_list.t_cur (i) = a) & (brk_list.line (i) ^= -1) then do; 399 call db_fnp_util_$cv_line_no (corep, fnp, (brk_list.line (i)), tty_name, code); 400 if code ^= 0 then call ioa_$nnl (" ^o", brk_list.line (i)); 401 else call ioa_$nnl (" ^a", tty_name); 402 brk_list.line (i) = -1; /* Dont print again */ 403 end; 404 end; 405 call ioa_ (""); /* Finish the line */ 406 return; 407 408 end print_one_break; 409 410 /* Initialization procedure */ 411 412 setup: proc; 413 414 dcl fb fixed bin (17) unal; 415 416 corep = arg_corep; 417 fnp = arg_fnp; 418 expr_infop = arg_expr_infop; 419 cmd_infop = arg_cmd_infop; 420 421 if ^symbols_looked_up then do; /* Once per process */ 422 crbrk = db_fnp_sym_util_$get_value (".crbrk"); 423 crttb = db_fnp_sym_util_$get_value (".crttb"); 424 crtte = db_fnp_sym_util_$get_value (".crtte"); 425 t_flg3 = db_fnp_sym_util_$get_value ("t.flg3"); 426 t_cur = db_fnp_sym_util_$get_value ("t.cur"); 427 t_line = db_fnp_sym_util_$get_value ("t.line"); 428 fb = db_fnp_sym_util_$get_value ("tfbkpt"); 429 tfbkpt = unspec (fb); 430 call db_fnp_opblock_util_$lookup ("bkptop", bkptop, code); 431 if code ^= 0 then 432 call sub_err_ (code, name, "s", null, (0), "Unable to get code for ""bkptop"" opblock."); 433 free_areap = get_system_free_area_ (); 434 symbols_looked_up = "1"b; 435 end; 436 437 call get_crbrk_val; 438 439 return; 440 441 end setup; 442 443 /* Procedure to fetch the break table */ 444 445 get_break_table: proc; 446 447 448 if brk_tabp = null then do; /* Havent inited yet */ 449 call fetch_words (crbrk_val, 2, addr (mem_buf)); /* Get address and length */ 450 brk_tab_start = bin (mem_buf (1)); 451 brk_tab_size = bin (mem_buf (2)); 452 allocate brk_tab in (free_area); 453 end; 454 call fetch_words (brk_tab_start, 4 * brk_tab_size, brk_tabp); 455 return; 456 457 end get_break_table; 458 459 /* Get list of all channels stopped at break points */ 460 461 find_stopped_channels: proc; 462 463 dcl i fixed bin; 464 dcl nw fixed bin; 465 466 call fetch_words (crttb, 1, addr (mem_buf)); /* Get start of tib table */ 467 i = bin (mem_buf (1)); 468 call fetch_words (crtte, 1, addr (mem_buf)); /* And end */ 469 ntibs = divide (bin (mem_buf (1), 17) - i, 2, 17, 0); 470 allocate tib_table in (free_area); 471 allocate brk_list in (free_area); 472 call fetch_words (i, 2*ntibs, tib_tablep); /* Read the tib table */ 473 nw = max (t_flg3, t_cur, t_line) + 1; /* Number of words to read to get all these fields */ 474 brk_list_cnt = 0; /* Number of lines at breaks */ 475 do i = 1 to ntibs; /* For each tib */ 476 call fetch_words ((tib_table.address (i)), nw, addr (mem_buf)); /* Read stat of tib */ 477 if mem_buf (t_flg3 + 1) & tfbkpt then do; /* If line at break */ 478 brk_list_cnt = brk_list_cnt + 1; 479 brk_list.line (brk_list_cnt) = bin (mem_buf (t_line+1)); 480 brk_list.t_cur (brk_list_cnt) = bin (mem_buf (t_cur+1)); 481 end; 482 end; 483 free tib_table; 484 return; 485 486 end find_stopped_channels; 487 488 /* Reset a single breakpoint */ 489 490 reset_one_break: proc (a); 491 492 dcl a fixed bin; /* The address of the break */ 493 dcl edited_addr char (16) var; 494 495 call db_fnp_util_$edit_module_addr_paren (corep, fnp, a, edited_addr, code); /* Edit address for messages */ 496 if code ^= 0 then edited_addr = "?"; 497 call fetch_words (a, 1, addr (mem_buf)); /* Get opblock at location now */ 498 if mem_buf (1) ^= bkptop then do; 499 call ioa_ ("No break at ^a", edited_addr); 500 cmd_info.flush = "1"b; /* Treat as error, but continue */ 501 return; 502 end; 503 504 fnp_break_info.action = RESET; 505 fnp_break_info.address = a; 506 fnp_break_info.channel = ""; 507 string (fnp_break_info.flags) = "0"b; 508 call make_order_call; 509 510 call check_break_error; /* Check for any error */ 511 if code = 0 then call ioa_ ("Break at ^a reset.", edited_addr); 512 else do; 513 call ioa_ ("Break at ^a not reset. ^a", edited_addr, break_error (code)); 514 cmd_info.flush = "1"b; 515 end; 516 return; 517 518 end reset_one_break; 519 520 /* Precedure to read memory */ 521 522 fetch_words: proc (a, n, p); 523 524 dcl a fixed bin; /* Address */ 525 dcl n fixed bin; /* Word count */ 526 dcl p ptr; /* Where to put them */ 527 528 call db_fnp_memory_$fetch (corep, fnp, a, n, p, code); 529 if code ^= 0 then do; 530 call com_err_ (code, name, "Unable to read location ^o.", a); 531 go to error_return; 532 end; 533 return; 534 535 end fetch_words; 536 537 get_operand: proc; 538 539 call db_fnp_reader_$get_operand (cmd_infop); 540 if cmd_info.error then go to error_return; 541 return; 542 543 end get_operand; 544 545 /* The hphcs interface_ */ 546 547 make_order_call: proc; 548 549 dcl fnp_name char (1); 550 551 fnp_name = get_fnp_name_ (fnp); 552 553 retry_order_call: 554 if call_type = 0 then do; /* Haven't established which call to use */ 555 on linkage_error go to call_1_failed; 556 call hphcs_$tty_order (fnp, "fnp_break", addr (fnp_break_info), state, code); /* Try old call */ 557 revert linkage_error; /* It worked */ 558 call_type = 1; 559 go to check_order_code; 560 call_1_failed: on linkage_error go to call_2_failed; 561 call hphcs_$tty_control (fnp_name, "fnp_break", addr (fnp_break_info), code); /* Try new call */ 562 revert linkage_error; /* It worked */ 563 call_type = 2; 564 go to check_order_code; 565 call_2_failed: revert linkage_error; /* Neither worked, must mean no access */ 566 call sub_err_ (0, name, "h", null, (0), "No access to hphcs_ gate; unable to make fnp_break order call."); 567 go to retry_order_call; 568 end; 569 else if call_type = 1 then call hphcs_$tty_order (fnp, "fnp_break", addr (fnp_break_info), state, code); 570 else call hphcs_$tty_control (fnp_name, "fnp_break", addr (fnp_break_info), code); 571 check_order_code: 572 if code ^= 0 then do; 573 call com_err_ (code, name); 574 go to error_return; 575 end; 576 return; 577 578 end make_order_call; 579 580 /* Get value of .crbrk, which points to data in breakpoint_man */ 581 582 get_crbrk_val: proc; 583 584 call fetch_words (crbrk, 1, addr (mem_buf)); /* Get addr of brk tab ptr */ 585 crbrk_val = bin (mem_buf (1)); 586 if crbrk_val = 0 then do; 587 call ioa_ ("No break table"); 588 go to error_return; 589 end; 590 return; 591 592 end get_crbrk_val; 593 594 /* Get break error code, reason for failure of previous request */ 595 596 check_break_error: proc; 597 598 /* The following sleep call is a temporary kludge to avoid a potential 599* problem which cannot be solved in MR6.0 because of lack of time. 600* If the FNP should crash while a 'dump_fnp' order call is in progress, the 601* Initializer will end up looping in ring 0 trying to lock the 602* fnp_dump_segment in order to take a dump. The segment is, however, 603* already locked to the process tperforming the 'fnp_dump' order 604* and the Initializer will loop forever. Breakpoint operations are 605* especially prone to this trap because each operation is immediatly 606* followed by a 'dump_fnp' order to check the status of the operation. 607* Therefore a start or set_break command which causes the FNP to crash will 608* very likely cause this problem. The sleep call is an attempt 609* to reduce the likely-hood of this happening by waiting after a breakpoint 610* operation before checking the results. The theory is that if the 611* FNP is going to crash as a result of the breakpoint operation, it will do 612* so quickly, and the Initializer will be able to start the dump operation 613* before we attemp the dump_fnp order. This is obviously a stopgap measure to 614* be deleted as soon as posssible. */ 615 616 call timer_manager_$sleep (250000, "10"b); 617 618 call fetch_words (crbrk_val + 2, 1, addr (mem_buf)); 619 code = bin (mem_buf (1)); 620 return; 621 622 end check_break_error; 623 624 error_return: 625 cmd_info.flush = "1"b; 626 call clean_up; 627 return; 628 629 /* Cleanup handler */ 630 631 clean_up: proc; 632 633 if brk_tabp ^= null then free brk_tab; 634 if tib_tablep ^= null then free tib_table; 635 if brk_listp ^= null then free brk_list; 636 return; 637 638 end clean_up; 639 1 1 /* Begin include file ..... debug_fnp_data.incl.pl1 */ 1 2 1 3 /* Describes various structures used by the debug_fnp command */ 1 4 1 5 /* Written February 1977 by Larry Johnson */ 1 6 1 7 /* Structures describing a symbol table used by the debug_fnp command, 1 8* to find values for common FNP symbols. */ 1 9 1 10 dcl db_fnp_symbols_$db_fnp_symbols_ ext; 1 11 1 12 dcl symbol_tablep ptr; 1 13 1 14 dcl 1 symbol_table aligned based (symbol_tablep), 1 15 2 cnt fixed bin, /* Number of entries */ 1 16 2 maxcnt fixed bin, /* Max count */ 1 17 2 entry (symbol_table.cnt) unal, 1 18 3 one_symbol like sym unal; 1 19 1 20 dcl symp ptr; /* Pointer to one symbol */ 1 21 1 22 dcl 1 sym unal based (symp), 1 23 2 name char (6), 1 24 2 value fixed bin (17), 1 25 2 len fixed bin (17), /* Number of words */ 1 26 2 reloc fixed bin (17), 1 27 2 type fixed bin (17), 1 28 2 flag_mem char (6), /* If non blank, name of word in which this is a flag */ 1 29 2 explain bit (18), /* Offset to explanation for symbol */ 1 30 2 pad bit (18); 1 31 1 32 dcl exptextp ptr; 1 33 1 34 dcl 1 exptext aligned based (exptextp), /* Symbol explanation entry */ 1 35 2 len fixed bin (8) unal, 1 36 2 data char (exptext.len) unal; 1 37 1 38 /* Values for sym.reloc, which is relocation required to find the symbol */ 1 39 1 40 dcl (reloc_abs init (0), /* Value is absolute */ 1 41 reloc_tib init (1), /* Value is relative to current tib addr */ 1 42 reloc_hwcm init (2), /* Value is relative to current hwcm */ 1 43 reloc_sfcm init (3), /* Value is relative to software comm region */ 1 44 reloc_meters init (4)) /* Value is relative to tib meters */ 1 45 int static options (constant); 1 46 1 47 /* Values for sym.type, which is the mode to be used in displaying symbol */ 1 48 1 49 dcl (type_oct init (0), /* Octal, default for most symbols */ 1 50 type_char init (1), /* Ascii characters */ 1 51 type_addr init (2), /* Address to be converted to mod|offset */ 1 52 type_clock init (3), /* Multics clock value */ 1 53 type_inst init (4), /* Machine instruction */ 1 54 type_op init (5), /* Interpreter opblock format */ 1 55 type_dec init (6), /* Decimal */ 1 56 type_bit init (7), /* In bits */ 1 57 type_ebcdic init (8)) /* 8-bit ebcdic characters */ 1 58 int static options (constant); 1 59 1 60 dcl long_type_names (0:8) char (12) int static options (constant) init ( 1 61 "octal", "character", "address", "clock", "instruction", "opblock", "decimal", "bit", "ebcdic"); 1 62 dcl short_type_names (0:8) char (4) int static options (constant) init ( 1 63 "oct", "ch", "addr", "ck", "inst", "op", "dec", "bit", "ebc"); 1 64 1 65 1 66 /* Structure of suplmental data used in evaluating expressions */ 1 67 1 68 dcl expr_infop ptr; 1 69 1 70 dcl 1 expr_info aligned based (expr_infop), 1 71 2 flags, 1 72 3 star_known bit (1) unal, /* Value of "*" is known */ 1 73 3 tib_known bit (1) unal, /* TIB addresses may be used */ 1 74 3 hwcm_known bit (1) unal, /* HWCM address may be used */ 1 75 3 sfcm_known bit (1) unal, /* SFCM address may be used */ 1 76 3 pad bit (32) unal, 1 77 2 star_addr fixed bin, /* Value of "*" */ 1 78 2 tib_addr fixed bin, /* Address of TIB */ 1 79 2 hwcm_addr fixed bin, /* Address of HWCM */ 1 80 2 sfcm_addr fixed bin, /* Address of SFCM */ 1 81 2 type fixed bin, /* Expression type (mode for printing) */ 1 82 2 len fixed bin, /* Implied length of expression */ 1 83 2 user_tablep ptr; /* Pointer to a user symbol table */ 1 84 1 85 1 86 /* Structure of opcode table of machine instructions */ 1 87 1 88 dcl db_fnp_opcodes_$ ext; 1 89 1 90 dcl optablep ptr; 1 91 1 92 dcl 1 optable aligned based (optablep), 1 93 2 cnt fixed bin, 1 94 2 entry (optable.cnt) unal, 1 95 3 one_op like op; 1 96 1 97 dcl opp ptr; 1 98 1 99 dcl 1 op unal based (opp), 1 100 2 name char (6), /* The mneumonic */ 1 101 2 code bit (12), /* The opcode */ 1 102 2 mask bit (12), /* Mask that says where the opcode is */ 1 103 2 type fixed bin (11), /* Type of display required */ 1 104 2 pad bit (18); 1 105 1 106 /* Values for op.type are: 1 107* 0 - storage reference 1 108* 1 - non-storage reference (immediate), 1 109* 2 - non-storage reference (iacxn only), 1 110* 3 - non-storage reference (shifts), 1 111* 4 - non-storage reference (no operands) */ 1 112 1 113 1 114 /* Stuctures used while parsing commands into operands */ 1 115 1 116 dcl cmd_infop ptr; 1 117 1 118 dcl 1 cmd_info aligned based (cmd_infop), 1 119 2 inbuf char (256), /* For reading lines */ 1 120 2 opbuf char (256), /* Used for operand in undoubling quotes */ 1 121 2 commandp ptr, /* Address of unparsed part of command */ 1 122 2 commandl fixed bin, /* Length of unparsed part */ 1 123 2 operandp ptr, /* Address of current operand */ 1 124 2 operandl fixed bin, /* And its length */ 1 125 2 error bit (1), /* Set if error parsing operand */ 1 126 2 endline bit (1), /* Set if no more operands on line */ 1 127 2 opstring bit (1), /* Set if operand was unquoted string */ 1 128 2 flush bit (1), /* If set, rest of input line will be ignored */ 1 129 2 envp ptr; /* Pointer to the debug_fnp environment structure */ 1 130 1 131 dcl command char (cmd_info.commandl) based (cmd_info.commandp); 1 132 dcl operand char (cmd_info.operandl) based (cmd_info.operandp); 1 133 1 134 /* The following structure describes the current debug_fnp environment. */ 1 135 /* It specifies whether we are working on a dump, fnp, core image, etc. */ 1 136 1 137 dcl envp ptr; 1 138 1 139 dcl 1 env aligned based (envp), 1 140 2 corep ptr, /* Ptr to current dump or core-image. Null means live FNP */ 1 141 2 fnp fixed bin, /* Current fnp number */ 1 142 2 dump_dir char (168) unal, /* Directory where dumps are found */ 1 143 2 dir char (168) unal, /* Directory for current dump or core image */ 1 144 2 ename char (32) unal, /* Ename for current dump or core image */ 1 145 2 tty_name char (32), /* Name of current channel */ 1 146 2 segp ptr, /* Pointer to base of current segment */ 1 147 2 flags unal, 1 148 3 fnps_configured bit (8), /* Says which FNP's appear in config deck */ 1 149 3 fnp_sw bit (1), /* 1 if currently working on fnp */ 1 150 3 image_sw bit (1), /* 1 if currently working on a core-image */ 1 151 3 dump_sw bit (1), /* 1 if current working on a dump */ 1 152 3 fdump_sw bit (1), /* 1 if current dump is a fdump */ 1 153 3 pad bit (24), 1 154 2 dump_time fixed bin (71); /* Clock time dump occured */ 1 155 1 156 /* Structure of data defining table of interpreter opblock names */ 1 157 1 158 dcl db_fnp_opblocks_$ ext; 1 159 1 160 dcl opblock_tablep ptr; 1 161 1 162 dcl 1 opblock_table aligned based (opblock_tablep), 1 163 2 cnt fixed bin, 1 164 2 name (0:opblock_table.cnt) char (6) unal; 1 165 1 166 /* End include file ..... debug_fnp_data.incl.pl1 */ 640 641 642 end db_fnp_break_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/15/82 1501.3 db_fnp_break_.pl1 >dumps>old>recomp>db_fnp_break_.pl1 640 1 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. RESET constant fixed bin(17,0) initial dcl 54 ref 504 SET constant fixed bin(17,0) initial dcl 53 ref 182 START constant fixed bin(17,0) initial dcl 55 ref 269 321 a parameter fixed bin(17,0) dcl 364 in procedure "print_one_break" set ref 362 378* 379* 398 a parameter fixed bin(17,0) dcl 492 in procedure "reset_one_break" set ref 490 495* 497* 505 a parameter fixed bin(17,0) dcl 524 in procedure "fetch_words" set ref 522 528* 530* action 3 000166 automatic fixed bin(17,0) level 2 dcl 45 set ref 182* 269* 321* 504* addr builtin function dcl 138 ref 310 310 316 316 395 395 449 449 466 466 468 468 476 476 497 497 556 556 561 561 569 569 570 570 584 584 618 618 address based fixed bin(17,0) array level 3 in structure "tib_table" packed unaligned dcl 80 in procedure "db_fnp_break_" ref 476 address 000236 automatic char(10) level 2 in structure "b" packed unaligned dcl 370 in procedure "print_one_break" set ref 379* 380* address based fixed bin(17,0) array level 3 in structure "brk_tab" packed unaligned dcl 72 in procedure "db_fnp_break_" ref 220 222 349 349 address 2 000166 automatic fixed bin(17,0) level 2 in structure "fnp_break_info" dcl 45 in procedure "db_fnp_break_" set ref 181* 268* 322* 323* 505* address_given 000152 automatic bit(1) unaligned dcl 41 set ref 288* 295 298* 322 arg_cmd_infop parameter pointer dcl 20 ref 142 200 238 340 419 arg_corep parameter pointer dcl 18 ref 142 200 238 340 416 arg_expr_infop parameter pointer dcl 21 ref 142 200 238 340 418 arg_fnp parameter fixed bin(17,0) dcl 19 ref 142 200 238 340 417 b 000236 automatic structure level 1 packed unaligned dcl 370 set ref 395 395 395 395 bin builtin function dcl 138 ref 317 317 450 451 467 469 479 480 585 619 bkptop 000017 internal static bit(18) unaligned dcl 101 set ref 430* 498 break_address 000143 automatic fixed bin(17,0) dcl 36 set ref 158* 181 296* 322 break_error 000004 constant varying char(32) initial array dcl 57 set ref 191* 274* 329* 513* break_reset 000141 automatic bit(1) unaligned dcl 34 set ref 218* 221* 225 brk_list based structure level 1 dcl 87 set ref 471 635 brk_list_cnt 000204 automatic fixed bin(17,0) dcl 86 set ref 256 260 352 397 474* 478* 478 479 480 brk_listp 000202 automatic pointer initial dcl 85 set ref 85* 261 263 353 353 398 398 399 400 402 471* 479 480 635 635 brk_tab based structure level 1 dcl 72 set ref 452 633 brk_tab_size 000174 automatic fixed bin(17,0) dcl 69 set ref 219 348 451* 452 454 633 brk_tab_start 000173 automatic fixed bin(17,0) dcl 68 set ref 450* 454* brk_tabp 000176 automatic pointer initial dcl 70 set ref 70* 220 222 349 349 349 349 448 452* 454* 633 633 call_type 000024 internal static fixed bin(17,0) initial dcl 104 set ref 553 558* 563* 569 channel 000166 automatic char(6) level 2 dcl 45 set ref 183* 184* 267* 320* 506* cleanup 000206 stack reference condition dcl 136 ref 145 203 241 343 cmd_info based structure level 1 dcl 1-118 cmd_infop 000216 automatic pointer dcl 1-116 set ref 153 158 158 158 164 165 165 167 167 167 169 169 169 175 175 175 211 216 216 216 216 229 229 229 249 254 254 254 254 264 275 283 283 283 285 285 285 292 293 293 294 294 296 296 296 301 301 301 419* 500 514 539* 540 624 code 000103 automatic fixed bin(35,0) dcl 27 set ref 158* 159 167* 168 169* 190 191 229* 230 261* 262 263* 273 274 283* 284 285* 296* 297 310* 311 312* 328 329 378* 379 391* 392 395* 399* 400 430* 431 431* 495* 496 511 513 528* 529 530* 556* 561* 569* 570* 571 573* 619* com_err_ 000062 constant entry external dcl 125 ref 169 263 285 312 530 573 corep 000100 automatic pointer dcl 25 set ref 147 158* 167* 205 229* 243 261* 283* 296* 310* 378* 391* 399* 416* 495* 528* crbrk 000011 internal static fixed bin(17,0) dcl 95 set ref 422* 584* crbrk_val 000142 automatic fixed bin(17,0) dcl 35 set ref 449* 585* 586 618 crttb 000012 internal static fixed bin(17,0) dcl 96 set ref 423* 466* crtte 000013 internal static fixed bin(17,0) dcl 97 set ref 424* 468* db_fnp_eval_ 000050 constant entry external dcl 120 ref 158 229 296 db_fnp_memory_$fetch 000044 constant entry external dcl 118 ref 528 db_fnp_opblock_util_$get_name 000042 constant entry external dcl 117 ref 384 db_fnp_opblock_util_$lookup 000052 constant entry external dcl 121 ref 430 db_fnp_reader_$get_operand 000046 constant entry external dcl 119 ref 539 db_fnp_sym_util_$get_value 000026 constant entry external dcl 111 ref 422 423 424 425 426 427 428 db_fnp_util_$cv_chan_name 000034 constant entry external dcl 114 ref 167 283 db_fnp_util_$cv_line_no 000036 constant entry external dcl 115 ref 261 391 399 db_fnp_util_$edit_module_addr_force 000030 constant entry external dcl 112 ref 378 db_fnp_util_$edit_module_addr_paren 000032 constant entry external dcl 113 ref 495 db_fnp_util_$get_chan_addrs 000040 constant entry external dcl 116 ref 310 divide builtin function dcl 138 ref 469 edited_addr 000304 automatic varying char(16) dcl 493 in procedure "reset_one_break" set ref 495* 496* 499* 511* 513* edited_addr 000106 automatic varying char(32) dcl 30 in procedure "db_fnp_break_" set ref 378* 380 endline 210 based bit(1) level 2 dcl 1-118 ref 153 164 211 249 292 entries based structure array level 2 in structure "tib_table" packed unaligned dcl 80 in procedure "db_fnp_break_" entries based structure array level 2 in structure "brk_list" packed unaligned dcl 87 in procedure "db_fnp_break_" entry based structure array level 2 packed unaligned dcl 72 error 207 based bit(1) level 2 dcl 1-118 ref 540 expr_info based structure level 1 dcl 1-70 ref 308 expr_infop 000214 automatic pointer dcl 1-68 set ref 158* 229* 296* 308 418* fb 000254 automatic fixed bin(17,0) unaligned dcl 414 set ref 428* 429 flags 000154 automatic structure level 2 in structure "temp_expr_info" dcl 43 in procedure "db_fnp_break_" flags 4 000166 automatic structure level 2 in structure "fnp_break_info" dcl 45 in procedure "db_fnp_break_" set ref 185* 270* 324* 507* flush 212 based bit(1) level 2 dcl 1-118 set ref 264* 275* 500* 514* 624* fnp 000102 automatic fixed bin(17,0) dcl 26 set ref 158* 167* 229* 261* 283* 296* 310* 378* 391* 399* 417* 495* 528* 551* 556* 569* fnp_break_info 000166 automatic structure level 1 dcl 45 set ref 556 556 561 561 569 569 570 570 fnp_name 000100 automatic char(1) unaligned dcl 549 set ref 551* 561* 570* free_area based area(1024) dcl 106 ref 452 470 471 free_areap 000022 internal static pointer dcl 103 set ref 433* 452 470 471 get_fnp_name_ 000100 constant entry external dcl 132 ref 551 get_system_free_area_ 000064 constant entry external dcl 126 ref 433 hphcs_$tty_control 000056 constant entry external dcl 123 ref 561 570 hphcs_$tty_order 000054 constant entry external dcl 122 ref 556 569 i 000272 automatic fixed bin(17,0) dcl 463 in procedure "find_stopped_channels" set ref 467* 469 472* 475* 476* i 000104 automatic fixed bin(17,0) dcl 28 in procedure "db_fnp_break_" set ref 167* 219* 220 222* 229* 230* 260* 261 263* 283* 348* 349 349 349 349* 352* 353 353* i 000232 automatic fixed bin(17,0) dcl 368 in procedure "print_one_break" set ref 397* 398 398 399 400 402* ioa_ 000066 constant entry external dcl 127 ref 148 154 175 191 206 212 225 244 250 257 274 277 301 329 332 356 375 405 499 511 513 587 ioa_$nnl 000070 constant entry external dcl 128 ref 400 401 ioa_$rsnnl 000072 constant entry external dcl 129 ref 379 385 393 iox_$put_chars 000074 constant entry external dcl 130 ref 395 iox_$user_output 000102 external static pointer dcl 134 set ref 395* l parameter fixed bin(17,0) dcl 366 set ref 362 389 391* 393* length builtin function dcl 138 ref 395 395 line 0(18) based fixed bin(17,0) array level 3 in structure "brk_tab" packed unaligned dcl 72 in procedure "db_fnp_break_" ref 349 line 4(18) 000236 automatic char(6) level 2 in structure "b" packed unaligned dcl 370 in procedure "print_one_break" set ref 389* 392* 393* line based fixed bin(17,0) array level 3 in structure "brk_list" packed unaligned dcl 87 in procedure "db_fnp_break_" set ref 261 263* 353 398 399 400* 402* 479* line_given 000144 automatic bit(1) unaligned dcl 37 set ref 161* 166 172* 183 linkage_error 000000 stack reference condition dcl 136 ref 555 557 560 562 565 max builtin function dcl 138 ref 473 mem_buf 000117 automatic bit(18) array unaligned dcl 31 set ref 316 316 317 317 449 449 450 451 466 466 467 468 468 469 476 476 477 479 480 497 497 498 584 584 585 618 618 619 n parameter fixed bin(17,0) dcl 525 set ref 522 528* name 000000 constant char(13) initial unaligned dcl 107 set ref 169* 263* 285* 312* 431* 530* 566* 573* ntibs 000137 automatic fixed bin(17,0) dcl 32 set ref 469* 470 471 472 475 483 634 635 null builtin function dcl 138 ref 70 79 85 147 205 243 431 431 448 566 566 633 634 635 nw 000273 automatic fixed bin(17,0) dcl 464 set ref 473* 476* o parameter bit(18) unaligned dcl 365 set ref 362 382 384* 385* op based structure level 1 packed unaligned dcl 1-99 opblock 1 based bit(18) array level 3 in structure "brk_tab" packed unaligned dcl 72 in procedure "db_fnp_break_" set ref 349* opblock 2(18) 000236 automatic char(8) level 2 in structure "b" packed unaligned dcl 370 in procedure "print_one_break" set ref 382* 385* 386* operand based char unaligned dcl 1-132 set ref 158* 165 167* 169* 175* 216 216 229* 254 254 283* 285* 293 294 296* 301* operandl 206 based fixed bin(17,0) level 2 dcl 1-118 ref 158 158 165 167 167 169 169 175 175 216 216 229 229 254 254 283 283 285 285 293 294 296 296 301 301 operandp 204 based pointer level 2 dcl 1-118 ref 158 165 167 169 175 216 216 229 254 254 283 285 293 294 296 301 optemp 000234 automatic char(6) unaligned dcl 369 set ref 384* 385 386 p parameter pointer dcl 526 set ref 522 528* reset_sw 000153 automatic bit(1) unaligned dcl 42 set ref 289* 293* 307 something_printed 000105 automatic bit(1) unaligned dcl 29 set ref 347* 356 375 376* start_trace 000151 automatic bit(1) unaligned dcl 40 set ref 290* 294* 325 state 000140 automatic fixed bin(17,0) dcl 33 set ref 556* 569* stop_trace 000150 automatic bit(1) unaligned dcl 39 set ref 162* 165* 186 string builtin function dcl 138 set ref 185* 270* 324* 395 395 507* sub_err_ 000060 constant entry external dcl 124 ref 431 566 sym based structure level 1 packed unaligned dcl 1-22 symbols_looked_up 000010 internal static bit(1) initial unaligned dcl 94 set ref 421 434* t_cur 000015 internal static fixed bin(17,0) dcl 99 in procedure "db_fnp_break_" set ref 316 426* 473 480 t_cur 0(18) based fixed bin(17,0) array level 3 in structure "brk_list" packed unaligned dcl 87 in procedure "db_fnp_break_" set ref 353 398 480* t_flg3 000014 internal static fixed bin(17,0) dcl 98 set ref 425* 473 477 t_line 000016 internal static fixed bin(17,0) dcl 100 set ref 427* 473 479 temp_expr_info 000154 automatic structure level 1 dcl 43 set ref 308* 310 310 tfbkpt 000020 internal static bit(18) unaligned dcl 102 set ref 429* 477 tib_addr 2 000154 automatic fixed bin(17,0) level 2 dcl 43 set ref 316 tib_known 0(01) 000154 automatic bit(1) level 3 packed unaligned dcl 43 set ref 309* 315 tib_table based structure level 1 dcl 80 ref 470 483 634 tib_tablep 000200 automatic pointer initial dcl 79 set ref 79* 470* 472* 476 483 634 634 timer_manager_$sleep 000076 constant entry external dcl 131 ref 616 trace 4 000166 automatic bit(1) level 3 packed unaligned dcl 45 set ref 186* 325* tty_name 000146 automatic char(8) unaligned dcl 38 set ref 167* 183 261* 267 274* 277* 283* 310* 312* 320 329* 332* 391* 392 399* 401* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. command based char unaligned dcl 1-131 db_fnp_opblocks_$ external static fixed bin(17,0) dcl 1-158 db_fnp_opcodes_$ external static fixed bin(17,0) dcl 1-88 db_fnp_symbols_$db_fnp_symbols_ external static fixed bin(17,0) dcl 1-10 env based structure level 1 dcl 1-139 envp automatic pointer dcl 1-137 exptext based structure level 1 dcl 1-34 exptextp automatic pointer dcl 1-32 long_type_names internal static char(12) initial array unaligned dcl 1-60 opblock_table based structure level 1 dcl 1-162 opblock_tablep automatic pointer dcl 1-160 opp automatic pointer dcl 1-97 optable based structure level 1 dcl 1-92 optablep automatic pointer dcl 1-90 reloc_abs internal static fixed bin(17,0) initial dcl 1-40 reloc_hwcm internal static fixed bin(17,0) initial dcl 1-40 reloc_meters internal static fixed bin(17,0) initial dcl 1-40 reloc_sfcm internal static fixed bin(17,0) initial dcl 1-40 reloc_tib internal static fixed bin(17,0) initial dcl 1-40 short_type_names internal static char(4) initial array unaligned dcl 1-62 symbol_table based structure level 1 dcl 1-14 symbol_tablep automatic pointer dcl 1-12 symp automatic pointer dcl 1-20 type_addr internal static fixed bin(17,0) initial dcl 1-49 type_bit internal static fixed bin(17,0) initial dcl 1-49 type_char internal static fixed bin(17,0) initial dcl 1-49 type_clock internal static fixed bin(17,0) initial dcl 1-49 type_dec internal static fixed bin(17,0) initial dcl 1-49 type_ebcdic internal static fixed bin(17,0) initial dcl 1-49 type_inst internal static fixed bin(17,0) initial dcl 1-49 type_oct internal static fixed bin(17,0) initial dcl 1-49 type_op internal static fixed bin(17,0) initial dcl 1-49 NAMES DECLARED BY EXPLICIT CONTEXT. call_1_failed 004335 constant label dcl 560 ref 555 call_2_failed 004415 constant label dcl 565 set ref 560 check_break_error 004650 constant entry internal dcl 596 ref 189 272 327 510 check_order_code 004560 constant label dcl 571 ref 559 564 clean_up 004704 constant entry internal dcl 631 ref 145 195 203 233 241 334 343 357 626 db_fnp_break_ 000443 constant entry external dcl 14 error_return 002460 constant label dcl 624 ref 149 155 159 170 176 192 207 213 245 251 286 297 302 313 330 531 540 574 588 fetch_words 004130 constant entry internal dcl 522 ref 316 449 454 466 468 472 476 497 584 618 find_stopped_channels 003532 constant entry internal dcl 461 ref 255 346 get_break_table 003474 constant entry internal dcl 445 ref 217 345 get_crbrk_val 004604 constant entry internal dcl 582 ref 437 get_operand 004211 constant entry internal dcl 537 ref 152 163 178 210 248 291 304 list 002310 constant entry external dcl 340 make_order_call 004226 constant entry internal dcl 547 ref 188 271 326 508 no_reset_tib 002127 constant label dcl 312 ref 315 print_one_break 002470 constant entry internal dcl 362 ref 349 353 reset 001054 constant entry external dcl 200 reset_one_break 003720 constant entry internal dcl 490 ref 222 230 317 retry_order_call 004247 constant label dcl 553 ref 567 set 000457 constant entry external dcl 142 setup 003170 constant entry internal dcl 412 ref 144 202 240 342 start 001307 constant entry external dcl 238 start_break_end 002301 constant label dcl 334 ref 258 start_next 001632 constant label dcl 278 ref 265 NAME DECLARED BY CONTEXT OR IMPLICATION. unspec builtin function ref 429 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 5466 5572 5054 5476 Length 6110 5054 104 301 412 16 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME db_fnp_break_ 510 external procedure is an external procedure. on unit on line 145 64 on unit on unit on line 203 64 on unit on unit on line 241 64 on unit on unit on line 343 64 on unit print_one_break internal procedure shares stack frame of external procedure db_fnp_break_. setup internal procedure shares stack frame of external procedure db_fnp_break_. get_break_table internal procedure shares stack frame of external procedure db_fnp_break_. find_stopped_channels internal procedure shares stack frame of external procedure db_fnp_break_. reset_one_break internal procedure shares stack frame of external procedure db_fnp_break_. fetch_words internal procedure shares stack frame of external procedure db_fnp_break_. get_operand internal procedure shares stack frame of external procedure db_fnp_break_. make_order_call 140 internal procedure enables or reverts conditions. on unit on line 555 64 on unit on unit on line 560 64 on unit get_crbrk_val internal procedure shares stack frame of external procedure db_fnp_break_. check_break_error internal procedure shares stack frame of external procedure db_fnp_break_. clean_up 64 internal procedure is called by several nonquick procedures. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 symbols_looked_up db_fnp_break_ 000011 crbrk db_fnp_break_ 000012 crttb db_fnp_break_ 000013 crtte db_fnp_break_ 000014 t_flg3 db_fnp_break_ 000015 t_cur db_fnp_break_ 000016 t_line db_fnp_break_ 000017 bkptop db_fnp_break_ 000020 tfbkpt db_fnp_break_ 000022 free_areap db_fnp_break_ 000024 call_type db_fnp_break_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME db_fnp_break_ 000100 corep db_fnp_break_ 000102 fnp db_fnp_break_ 000103 code db_fnp_break_ 000104 i db_fnp_break_ 000105 something_printed db_fnp_break_ 000106 edited_addr db_fnp_break_ 000117 mem_buf db_fnp_break_ 000137 ntibs db_fnp_break_ 000140 state db_fnp_break_ 000141 break_reset db_fnp_break_ 000142 crbrk_val db_fnp_break_ 000143 break_address db_fnp_break_ 000144 line_given db_fnp_break_ 000146 tty_name db_fnp_break_ 000150 stop_trace db_fnp_break_ 000151 start_trace db_fnp_break_ 000152 address_given db_fnp_break_ 000153 reset_sw db_fnp_break_ 000154 temp_expr_info db_fnp_break_ 000166 fnp_break_info db_fnp_break_ 000173 brk_tab_start db_fnp_break_ 000174 brk_tab_size db_fnp_break_ 000176 brk_tabp db_fnp_break_ 000200 tib_tablep db_fnp_break_ 000202 brk_listp db_fnp_break_ 000204 brk_list_cnt db_fnp_break_ 000214 expr_infop db_fnp_break_ 000216 cmd_infop db_fnp_break_ 000232 i print_one_break 000234 optemp print_one_break 000236 b print_one_break 000254 fb setup 000272 i find_stopped_channels 000273 nw find_stopped_channels 000304 edited_addr reset_one_break make_order_call 000100 fnp_name make_order_call THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out call_int_this call_int_other return tra_ext enable ext_entry int_entry alloc_based free_based THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ db_fnp_eval_ db_fnp_memory_$fetch db_fnp_opblock_util_$get_name db_fnp_opblock_util_$lookup db_fnp_reader_$get_operand db_fnp_sym_util_$get_value db_fnp_util_$cv_chan_name db_fnp_util_$cv_line_no db_fnp_util_$edit_module_addr_force db_fnp_util_$edit_module_addr_paren db_fnp_util_$get_chan_addrs get_fnp_name_ get_system_free_area_ hphcs_$tty_control hphcs_$tty_order ioa_ ioa_$nnl ioa_$rsnnl iox_$put_chars sub_err_ timer_manager_$sleep THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. iox_$user_output LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 70 000434 79 000436 85 000437 14 000442 142 000451 144 000465 145 000466 147 000510 148 000514 149 000530 152 000531 153 000532 154 000535 155 000553 158 000554 159 000616 161 000620 162 000621 163 000622 164 000623 165 000626 166 000637 167 000641 168 000700 169 000702 170 000735 172 000736 173 000740 175 000741 176 000767 178 000770 179 000771 181 000772 182 000774 183 000776 184 001004 185 001006 186 001007 188 001013 189 001017 190 001020 191 001022 192 001044 195 001045 196 001051 200 001052 202 001062 203 001063 205 001105 206 001111 207 001125 210 001126 211 001127 212 001132 213 001151 216 001152 217 001164 218 001165 219 001166 220 001175 221 001203 222 001205 224 001210 225 001212 226 001231 229 001232 230 001274 233 001300 234 001304 238 001305 240 001315 241 001316 243 001340 244 001344 245 001360 248 001361 249 001362 250 001365 251 001402 254 001403 255 001415 256 001416 257 001420 258 001434 260 001435 261 001443 262 001477 263 001501 264 001535 265 001540 267 001541 268 001544 269 001545 270 001547 271 001550 272 001554 273 001555 274 001557 275 001605 276 001610 277 001611 278 001632 280 001634 283 001635 284 001674 285 001676 286 001731 288 001732 289 001733 290 001734 291 001735 292 001736 293 001741 294 001752 295 001761 296 001763 297 002025 298 002027 299 002031 301 002032 302 002060 304 002061 305 002062 307 002063 308 002065 309 002071 310 002073 311 002125 312 002127 313 002157 315 002160 316 002163 317 002175 320 002202 321 002205 322 002207 323 002214 324 002215 325 002216 326 002222 327 002226 328 002227 329 002231 330 002257 332 002260 334 002301 336 002305 340 002306 342 002316 343 002317 345 002341 346 002342 347 002343 348 002344 349 002353 351 002401 352 002403 353 002412 355 002432 356 002434 357 002453 358 002457 624 002460 626 002463 627 002467 362 002470 375 002472 376 002510 378 002512 379 002543 380 002577 382 002603 384 002615 385 002632 386 002676 389 002701 391 002711 392 002741 393 002750 395 003003 397 003024 398 003033 399 003051 400 003102 401 003130 402 003147 404 003154 405 003156 406 003167 412 003170 416 003171 417 003175 418 003177 419 003202 421 003205 422 003210 423 003226 424 003245 425 003264 426 003303 427 003322 428 003341 429 003363 430 003367 431 003411 433 003460 434 003467 437 003472 439 003473 445 003474 448 003475 449 003501 450 003507 451 003512 452 003515 454 003524 455 003531 461 003532 466 003533 467 003552 468 003555 469 003574 470 003601 471 003607 472 003615 473 003622 474 003634 475 003635 476 003644 477 003654 478 003665 479 003666 480 003702 482 003713 483 003715 484 003717 490 003720 495 003722 496 003753 497 003761 498 004000 499 004010 500 004030 501 004033 504 004034 505 004036 506 004041 507 004043 508 004044 510 004050 511 004051 513 004077 514 004124 516 004127 522 004130 528 004132 529 004154 530 004156 531 004207 533 004210 537 004211 539 004212 540 004221 541 004224 547 004225 551 004233 553 004247 555 004252 556 004271 557 004330 558 004331 559 004334 560 004335 561 004354 562 004410 563 004411 564 004414 565 004415 566 004416 567 004463 569 004464 570 004525 571 004560 573 004563 574 004600 576 004603 582 004604 584 004605 585 004624 586 004627 587 004631 588 004646 590 004647 596 004650 616 004651 618 004666 619 004677 620 004702 631 004703 633 004711 634 004722 635 004731 636 004740 ----------------------------------------------------------- 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