COMPILATION LISTING OF SEGMENT term_ Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: CGI Compiled on: 2000-04-18_1154.23_Tue_mdt Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1986 * 4* * * 5* *********************************************************** */ 6 7 8 9 /****^ HISTORY COMMENTS: 10* 1) change(86-05-02,Elhard), approve(86-05-02,MCR7391), 11* audit(86-07-18,DGHowe), install(86-11-20,MR12.0-1222): 12* Rewritten to allow termination of multisegment files and to terminate all 13* components of object MSFs in appropriate circumstances. 14* 2) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), 15* audit(86-11-04,GDixon), install(86-11-20,MR12.0-1222): 16* set variable_node seg ptr to null when terminating references. 17* 3) change(86-12-08,Elhard), approve(86-12-08,PBF7391), 18* audit(86-12-09,JRGray), install(86-12-10,MR12.0-1240): 19* Changed to trap segment faults while calculating link array size (by 20* referencing the object segment) and free the linkage and static sections 21* for faulted segments in the address space. 22* END HISTORY COMMENTS */ 23 24 25 /* format: style1,insnl,ifthendo,indthenelse,^indnoniterdo,^inditerdo,indcom,^indthenbegin,^indprocbody,ind2,ll79,initcol0,dclind4,idind24,struclvlind1,comcol41 */ 26 27 term_: 28 proc (a_dname, /** dirname of object (in ) */ 29 a_ename, /** entryname of object (in ) */ 30 a_code); /** error code (out) */ 31 32 /*** ****************************************************************/ 33 /*** */ 34 /*** Name: term_ */ 35 /*** Function: this set of subroutines is used to terminate a */ 36 /*** segment or MSF and clean up the environment by */ 37 /*** unsnapping links that referenced it, freeing */ 38 /*** the linkage and static sections, closing any */ 39 /*** pl1 I/O file state blocks open for it, freeing */ 40 /*** any fortran static VLA's, and setting all of */ 41 /*** the init_info pointers to null for any *system */ 42 /*** that refer to the segments being terminated. */ 43 /*** */ 44 /*** ****************************************************************/ 45 46 /* constants */ 47 48 dcl true bit (1) static options (constant) init ("1"b); 49 dcl false bit (1) static options (constant) init ("0"b); 50 51 /* parameters */ 52 53 dcl a_dname char (*) parameter; 54 dcl a_ename char (*) parameter; 55 dcl a_refname char (*) parameter; 56 dcl a_segp ptr parameter; 57 dcl a_code fixed bin (35) parameter; 58 59 /* procedures */ 60 61 dcl find_command_$clear entry; 62 dcl fortran_storage_manager_$free 63 entry (ptr); 64 dcl get_system_free_area_ entry () returns (ptr); 65 dcl hcs_$fs_get_path_name entry (ptr, char (*), fixed bin, char (*), 66 fixed bin (35)); 67 dcl hcs_$fs_get_seg_ptr entry (char (*), ptr, fixed bin (35)); 68 dcl hcs_$get_uid_seg entry (ptr, bit (36) aligned, fixed bin (35)); 69 dcl hcs_$high_low_seg_count entry (fixed bin (15), fixed bin (15)); 70 dcl hcs_$initiate entry (char (*), char (*), char (*), 71 fixed bin (1), 72 fixed bin (2), ptr, fixed bin (35)); 73 dcl hcs_$initiate_count entry (char (*), char (*), char (*), 74 fixed bin (24), fixed bin (2), ptr, 75 fixed bin (35)); 76 dcl hcs_$status_minf entry (char (*), char (*), fixed bin (1), 77 fixed bin (2), fixed bin (24), fixed bin (35)); 78 dcl hcs_$terminate_name entry (char (*), fixed bin (35)); 79 dcl hcs_$terminate_noname entry (ptr, fixed bin (35)); 80 dcl hcs_$terminate_seg entry (ptr, fixed bin (1), fixed bin (35)); 81 dcl pathname_ entry (char (*), char (*)) returns (char (168)); 82 dcl plio2_$close_in_this_static 83 entry (ptr, ptr, fixed bin (18)); 84 85 /* external */ 86 87 dcl error_table_$segknown external fixed bin (35); 88 dcl error_table_$seg_unknown 89 external fixed bin (35); 90 dcl error_table_$invalidsegno 91 external fixed bin (35); 92 dcl error_table_$dirseg external fixed bin (35); 93 94 dcl plio2_data_fsb_thread_ ptr external init (null); 95 96 /* based */ 97 98 dcl 01 segment (segment_count) aligned based (segsp), 99 02 textp ptr, 100 02 flags aligned, 101 03 separate_static bit (1) unaligned, 102 03 mbz bit (35) unaligned, 103 02 link_segno fixed bin (18) unsigned unaligned, 104 02 link_start fixed bin (18) unsigned unaligned, 105 02 link_end fixed bin (18) unsigned unaligned, 106 02 stat_segno fixed bin (18) unsigned unaligned, 107 02 stat_start fixed bin (18) unsigned unaligned, 108 02 stat_end fixed bin (18) unsigned unaligned; 109 110 /* automatic */ 111 112 dcl segsp ptr automatic; 113 dcl segment_count fixed bin automatic; 114 dcl ec fixed bin (35) automatic; 115 116 /* conditions */ 117 118 dcl cleanup condition; 119 dcl seg_fault_error condition; 120 121 /* builtin */ 122 123 dcl addwordno builtin; 124 dcl baseptr builtin; 125 dcl char builtin; 126 dcl hbound builtin; 127 dcl lbound builtin; 128 dcl ltrim builtin; 129 dcl min builtin; 130 dcl null builtin; 131 dcl segno builtin; 132 dcl setwordno builtin; 133 dcl size builtin; 134 dcl stackbaseptr builtin; 135 dcl string builtin; 136 dcl substr builtin; 137 dcl unspec builtin; 138 dcl wordno builtin; 139 140 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 141 142 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 143 144 145 /*** ****************************************************************/ 146 /*** */ 147 /*** Name: term_ */ 148 /*** Input: dname, ename */ 149 /*** Function: terminates the object specified by dname and */ 150 /*** ename. If the object is a segment, any links to */ 151 /*** it in other linkage sections are unsnapped, */ 152 /*** its linkage and static sections are freed, and */ 153 /*** any *system links which refer to the segment for */ 154 /*** init_info have the init_info pointer set to null. */ 155 /*** If the object is a MSF, this process is repeated */ 156 /*** for each component. */ 157 /*** Output: code */ 158 /*** */ 159 /*** ****************************************************************/ 160 161 segsp = null; 162 163 on cleanup call clean_up (segsp, segment_count); 164 165 call initiate_name (a_dname, a_ename, segsp, segment_count); 166 call find_command_$clear; 167 call unsnap_links (segsp, segment_count); 168 call terminate_segno (segsp, segment_count); 169 170 call exit (0); 171 172 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 173 174 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 175 176 177 single_refname: 178 entry (a_refname, /** name to terminate (in ) */ 179 a_code); /** error code (out) */ 180 181 /*** ****************************************************************/ 182 /*** */ 183 /*** Name: term_$single_refname */ 184 /*** Input: refname */ 185 /*** Function: terminates a single reference name from a segment */ 186 /*** or MSF and unsnaps any links which refer to that */ 187 /*** file. If the name was the last name on the */ 188 /*** object, the object is terminated and the linkage */ 189 /*** section(s) are freed. */ 190 /*** Output: code */ 191 /*** */ 192 /*** ****************************************************************/ 193 194 segsp = null; 195 196 on cleanup call clean_up (segsp, segment_count); 197 198 call find_refname (a_refname, segsp, segment_count); 199 call find_command_$clear; 200 call unsnap_links (segsp, segment_count); 201 call terminate_single_refname (a_refname, segsp, segment_count); 202 203 call exit (0); 204 205 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 206 207 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 208 209 210 refname: 211 entry (a_refname, /** refname of segment (in ) */ 212 a_code); /** error code (out) */ 213 214 /*** ****************************************************************/ 215 /*** */ 216 /*** Name: term_$refname */ 217 /*** Input: refname */ 218 /*** Function: terminates the segment or MSF which has the */ 219 /*** reference name given, and unsnaps all links to */ 220 /*** the it, frees the linkage/static section(s), and */ 221 /*** fixes any *system init_info pointers which refer */ 222 /*** to it. */ 223 /*** Output: code */ 224 /*** */ 225 /*** ****************************************************************/ 226 227 segsp = null; 228 229 on cleanup call clean_up (segsp, segment_count); 230 231 call find_refname (a_refname, segsp, segment_count); 232 call find_command_$clear; 233 call unsnap_links (segsp, segment_count); 234 call terminate_segno (segsp, segment_count); 235 236 call exit (0); 237 238 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 239 240 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 241 242 243 no_clear: 244 entry (a_refname, /** name to terminate (in ) */ 245 a_code); /** error code (out) */ 246 247 /*** ****************************************************************/ 248 /*** */ 249 /*** Name: term_$no_clear */ 250 /*** Input: refname */ 251 /*** Function: This entrypoint is intended for use only by the */ 252 /*** find_command_ subroutine. It terminates a segment */ 253 /*** or MSF without clearing the find_command_ cache */ 254 /*** (by calling find_command_$clear) allowing */ 255 /*** find_command_ to maintain its cache properly. */ 256 /*** It is otherwise identical to term_$single_refname */ 257 /*** Output: code */ 258 /*** */ 259 /*** ****************************************************************/ 260 261 segsp = null; 262 263 on cleanup call clean_up (segsp, segment_count); 264 265 call find_refname (a_refname, segsp, segment_count); 266 call unsnap_links (segsp, segment_count); 267 call terminate_single_refname (a_refname, segsp, segment_count); 268 269 call exit (0); 270 271 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 272 273 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 274 275 276 unsnap: 277 entry (a_segp, /** segment pointer (in ) */ 278 a_code); /** error code (out) */ 279 280 /*** ****************************************************************/ 281 /*** */ 282 /*** Name: term_$unsnap */ 283 /*** Input: segp */ 284 /*** Function: unsnaps links to the segment specified by segp */ 285 /*** and clears the find_command_ cache without */ 286 /*** terminating the segment. */ 287 /*** Output: code */ 288 /*** */ 289 /*** ****************************************************************/ 290 291 segsp = null; 292 293 on cleanup call clean_up (segsp, segment_count); 294 295 call get_segs (a_segp, segsp, segment_count); 296 call find_command_$clear; 297 call unsnap_links (segsp, segment_count); 298 299 call exit (0); 300 301 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 302 303 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 304 305 306 nomakeunknown: 307 entry (a_segp, /** segment pointer (in ) */ 308 a_code); /** error code (out) */ 309 310 /*** ****************************************************************/ 311 /*** */ 312 /*** Name: term_$nomakeunknown */ 313 /*** Input: segp */ 314 /*** Function: unsnaps all links, frees the linkage and static */ 315 /*** section(s), clears the find_command_ cache, and */ 316 /*** fixes any *system init_info references without */ 317 /*** actually terminating the segment(s) given. */ 318 /*** Output: code */ 319 /*** */ 320 /*** ****************************************************************/ 321 322 segsp = null; 323 324 on cleanup call clean_up (segsp, segment_count); 325 326 call get_segs (a_segp, segsp, segment_count); 327 call find_command_$clear; 328 call unsnap_links (segsp, segment_count); 329 call free_linkage (segsp, segment_count); 330 331 call exit (0); 332 333 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 334 335 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 336 337 338 seg_ptr: 339 entry (a_segp, /** segment pointer (in ) */ 340 a_code); /** error code (out) */ 341 342 /*** ****************************************************************/ 343 /*** */ 344 /*** Name: term_$seg_ptr */ 345 /*** Input: segp */ 346 /*** Function: terminates the segment/MSF specified by segp and */ 347 /*** unsnaps any links, frees the linkage/static */ 348 /*** section(s), fixes and *system init_info pointers */ 349 /*** and clears the find_command_ cache. */ 350 /*** Output: code */ 351 /*** */ 352 /*** ****************************************************************/ 353 354 segsp = null; 355 356 on cleanup call clean_up (segsp, segment_count); 357 358 call get_segs (a_segp, segsp, segment_count); 359 call find_command_$clear; 360 call unsnap_links (segsp, segment_count); 361 call terminate_segno (segsp, segment_count); 362 363 call exit (0); 364 365 366 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 367 368 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 369 370 371 no_name: 372 entry (a_segp, /** segment pointer (in ) */ 373 a_code); /** error code (out) */ 374 375 /*** ****************************************************************/ 376 /*** */ 377 /*** Name: term_$no_name */ 378 /*** Input: segp */ 379 /*** Function: terminates the null reference name from the given */ 380 /*** segment and decrements the reference count. */ 381 /*** Output: code */ 382 /*** */ 383 /*** ****************************************************************/ 384 385 segsp = null; 386 call hcs_$terminate_noname (a_segp, ec); 387 388 call exit (ec); 389 390 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 391 392 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 393 394 395 initiate_name: 396 proc (dname, /** dirname of target (in ) */ 397 ename, /** entryname of target (in ) */ 398 segsp, /** segments struc ptr (out) */ 399 seg_ct); /** segment count (out) */ 400 401 /*** ****************************************************************/ 402 /*** */ 403 /*** Name: initiate_name */ 404 /*** Input: dname, ename */ 405 /*** Function: takes an input path given as dirname & entryname */ 406 /*** and checks to insure that the target was known */ 407 /*** and that it is either a segment or an object MSF. */ 408 /*** The segs structure is allocated with pointers to */ 409 /*** each of the segments to be terminated. */ 410 /*** Output: segsp, seg_ct */ 411 /*** */ 412 /*** ****************************************************************/ 413 414 /* parameters */ 415 416 dcl dname char (*) parameter; 417 dcl ename char (*) parameter; 418 dcl segsp ptr parameter; 419 dcl seg_ct fixed bin parameter; 420 421 /* automatic */ 422 423 dcl segp ptr automatic; 424 dcl ec fixed bin (35) automatic; 425 dcl dn char (168) automatic; 426 dcl bc fixed bin (24) automatic; 427 428 /* try to initiate the named segment */ 429 430 call hcs_$initiate (dname, ename, "", 0, 0, segp, ec); 431 432 /* if it is a directory, we have some object MSF checks to perform */ 433 434 if ec = error_table_$dirseg 435 then do; 436 437 /* see if it an MSF */ 438 439 call hcs_$status_minf (dname, ename, 1, 0, bc, ec); 440 if bc > 0 441 then do; 442 443 /* try initiating component 0 */ 444 445 dn = pathname_ (dname, ename); 446 call hcs_$initiate_count (dn, "0", "", bc, 0, segp, ec); 447 448 /* if it is not known, we return a code of */ 449 /* error_table_$seg_unknown */ 450 451 if segp = null 452 then call exit (error_table_$dirseg); 453 else if ec ^= error_table_$segknown 454 then do; 455 456 /* terminate it, since it was unknown to begin with */ 457 458 call hcs_$terminate_noname (segp, 0); 459 call exit (error_table_$seg_unknown); 460 end; 461 end; 462 end; 463 464 /* if the target wasn't a directory, but was unknown as well, then */ 465 /* we make it unknown again and return error_table_$seg_unknown */ 466 467 else if ec ^= error_table_$segknown 468 then do; 469 if segp ^= null 470 then call hcs_$terminate_noname (segp, ec); 471 call exit (error_table_$seg_unknown); 472 end; 473 474 /* if it actually was known and valid, we go and get pointers and */ 475 /* other info for each of the affected segments. */ 476 477 call get_segs (segp, segsp, seg_ct); 478 479 end initiate_name; 480 481 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 482 483 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 484 485 486 find_refname: 487 proc (refname, /** reference name (in ) */ 488 segsp, /** segments struc ptr (out) */ 489 seg_ct); /** segment count (out) */ 490 491 /*** ****************************************************************/ 492 /*** */ 493 /*** Name: find_refname */ 494 /*** Input: refname */ 495 /*** Function: locates a segment by reference name and allocates */ 496 /*** the list of all associated segments (in the case */ 497 /*** of a object MSF). */ 498 /*** Output: segsp, seg_ct */ 499 /*** */ 500 /*** ****************************************************************/ 501 502 /* parameters */ 503 504 dcl refname char (*) parameter; 505 dcl segsp ptr parameter; 506 dcl seg_ct fixed bin parameter; 507 508 /* automatic */ 509 510 dcl ec fixed bin (35) automatic; 511 dcl segp ptr automatic; 512 513 /* get the segment pointer associated with the refname given */ 514 515 call hcs_$fs_get_seg_ptr (refname, segp, ec); 516 if segp = null 517 then call exit (ec); 518 519 /* get the required info about the segment and any associated */ 520 /* segments if the target is a MSF component. */ 521 522 call get_segs (segp, segsp, seg_ct); 523 524 end find_refname; 525 526 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 527 528 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 529 530 531 get_segs: 532 proc (segp, /** segment pointer (in ) */ 533 segsp, /** segments struc ptr (out) */ 534 seg_ct); /** segment count (out) */ 535 536 /*** ****************************************************************/ 537 /*** */ 538 /*** Name: get_segs */ 539 /*** Input: segp */ 540 /*** Function: determines if a given segment is an object MSF */ 541 /*** component and if so, gets pointers to the other */ 542 /*** components in the MSF and returns a structure */ 543 /*** with those component pointers. */ 544 /*** Output: segsp, seg_ct */ 545 /*** */ 546 /*** ****************************************************************/ 547 548 /* parameters */ 549 550 dcl segp ptr parameter; 551 dcl segsp ptr parameter; 552 dcl seg_ct fixed bin parameter; 553 554 /* based */ 555 556 dcl 01 seg (seg_ct) aligned like segment based (segsp); 557 dcl sys_area area based (sys_areap); 558 dcl 01 lh aligned like linkage_header based (lhp); 559 dcl 01 mm aligned like msf_map based (mmp); 560 dcl 01 dh aligned like definition_header based (dhp); 561 562 /* automatic */ 563 564 dcl c fixed bin automatic; 565 dcl compp ptr automatic; 566 dcl dhp ptr automatic; 567 dcl dname char (168) automatic; 568 dcl dnl fixed bin automatic; 569 dcl ename char (32) automatic; 570 dcl i fixed bin automatic; 571 dcl isp ptr automatic; 572 dcl lhp ptr automatic; 573 dcl mmp ptr automatic; 574 dcl seg_tempp ptr automatic; 575 dcl ss bit (1) automatic; 576 dcl sys_areap ptr automatic; 577 578 sys_areap = get_system_free_area_ (); 579 580 /* try to get the linkage/static pointers */ 581 582 call get_lp (segno (segp), lhp, isp, ss); 583 584 if lhp = null 585 then do; 586 587 /* there is no linkage section. just handle the one segment */ 588 589 seg_ct = 1; 590 allocate seg in (sys_area); 591 unspec (seg (1)) = ""b; 592 seg (1).textp = segp; 593 return; 594 end; 595 596 dhp = lh.def_ptr; 597 598 on seg_fault_error 599 begin; 600 601 /* if we take a segment fault while trying to see if this is an */ 602 /* object MSF, we have no way of telling, so we assume it is a */ 603 /* single segment item and continue. */ 604 605 seg_ct = 1; 606 goto SKIP; 607 end; 608 609 /* if the msf_map_relp value is nonzero, validate that it is a */ 610 /* valid msf map. if so take the seg count from there, otherwise */ 611 /* assume 1. */ 612 613 if dh.msf_map_relp ^= 0 614 then do; 615 mmp = addwordno (dhp, dh.msf_map_relp); 616 if mm.version ^= msf_map_version_1 617 then seg_ct = 1; 618 else seg_ct = mm.component_count; 619 end; 620 else seg_ct = 1; 621 622 SKIP: 623 revert seg_fault_error; 624 625 /* only 1 segment, so get the info and return. */ 626 627 if seg_ct = 1 628 then do; 629 630 /* the segment is not an MSF component, just handle the one segment */ 631 632 allocate seg in (sys_area); 633 seg (1).textp = segp; 634 string (seg (1).flags) = ""b; 635 seg (1).flags.separate_static = ss; 636 seg (1).link_segno = segno (lhp); 637 seg (1).link_start = wordno (lhp); 638 seg (1).link_end = wordno (lhp) + lh.stats.block_length; 639 if isp ^= null 640 then do; 641 seg (1).stat_segno = segno (isp); 642 seg (1).stat_start = wordno (isp); 643 seg (1).stat_end = wordno (isp) + lh.stats.static_length; 644 end; 645 return; 646 end; 647 648 /* allocate the segs structure for seg_ct>1. In order for clean_up 649* to work properly, seg.textp(*) must be initialized to null when 650* segsp is set. The code below initializes the seg array before 651* setting segsp. */ 652 653 allocate seg in (sys_area) set (seg_tempp); 654 unspec (seg_tempp -> seg) = ""b; 655 seg_tempp -> seg.textp (*) = null; 656 segsp = seg_tempp; 657 658 /* get the containing directory */ 659 660 call hcs_$fs_get_path_name (segp, dname, dnl, ename, ec); 661 dname = substr (dname, 1, dnl); 662 663 /* get the information for the primary component */ 664 665 seg (1).textp = segp; 666 string (seg (1).flags) = ""b; 667 seg (1).flags.separate_static = ss; 668 seg (1).link_segno = segno (lhp); 669 seg (1).link_start = wordno (lhp); 670 seg (1).link_end = wordno (lhp) + lh.stats.block_length; 671 if isp ^= null 672 then do; 673 seg (1).stat_segno = segno (isp); 674 seg (1).stat_start = wordno (isp); 675 seg (1).stat_end = wordno (isp) + lh.stats.static_length; 676 end; 677 678 i = 1; 679 680 /* pick up the information for the other MSF components */ 681 682 do c = 0 to mm.component_count - 1; 683 if c ^= mm.my_component 684 then do; 685 686 i = i + 1; 687 688 /* initiate each component */ 689 690 call hcs_$initiate (dname, ltrim (char (c)), "", 0, 0, compp, ec); 691 if compp = null 692 then call exit (ec); 693 694 /* get the linkage and static pointers */ 695 696 call get_lp (segno (compp), lhp, isp, ss); 697 if lhp ^= null 698 then do; 699 700 /* if there is a linkage section, copy the info */ 701 702 seg (i).textp = compp; 703 string (seg (i).flags) = ""b; 704 seg (i).flags.separate_static = ss; 705 seg (i).link_segno = segno (lhp); 706 seg (i).link_start = wordno (lhp); 707 seg (i).link_end = wordno (lhp) + lh.stats.block_length; 708 if isp ^= null 709 then do; 710 seg (i).stat_segno = segno (isp); 711 seg (i).stat_start = wordno (isp); 712 seg (i).stat_end = wordno (isp) + lh.stats.static_length; 713 end; 714 end; 715 else do; 716 717 /* if there is no linkage section, zero the values */ 718 719 unspec (seg (i)) = ""b; 720 seg (i).textp = compp; 721 end; 722 end; 723 end; 724 725 end get_segs; 726 727 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 728 729 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 730 731 732 clean_up: 733 proc (segsp, /** segments struc ptr (in ) */ 734 seg_ct); /** segment count (in ) */ 735 736 /*** ****************************************************************/ 737 /*** */ 738 /*** Name: clean_up */ 739 /*** Input: segsp, seg_ct */ 740 /*** Function: frees the segs structure. */ 741 /*** Output: none */ 742 /*** */ 743 /*** ****************************************************************/ 744 745 /* parameters */ 746 747 dcl segsp ptr parameter; 748 dcl seg_ct fixed bin parameter; 749 750 /* based */ 751 752 dcl 01 seg (seg_ct) aligned like segment based (segsp); 753 dcl sys_area area based (sys_areap); 754 755 /* automatic */ 756 757 dcl s fixed bin automatic; 758 dcl sys_areap ptr automatic; 759 760 /* if there is no structure allocated, just return */ 761 762 if segsp = null 763 then return; 764 765 /* terminate segments we initiated that are not already terminated */ 766 767 do s = 2 to seg_ct; 768 if seg (s).textp ^= null 769 then call hcs_$terminate_noname (seg (s).textp, 0); 770 end; 771 772 /* get the area pointer and free the structure */ 773 774 sys_areap = get_system_free_area_ (); 775 free seg in (sys_area); 776 777 end clean_up; 778 779 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 780 781 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 782 783 784 terminate_single_refname: 785 proc (refname, /** refname to kill (in ) */ 786 segsp, /** segments struc ptr (in ) */ 787 seg_ct); /** segment count (in ) */ 788 789 /*** ****************************************************************/ 790 /*** */ 791 /*** Name: terminate_single_refname */ 792 /*** Input: refname, segsp, seg_ct */ 793 /*** Function: terminates the given name. If the name was the */ 794 /*** only name on the segment the segment is also */ 795 /*** terminated. In this case we free the linkage */ 796 /*** sections and terminate any associated segments. */ 797 /*** Output: none */ 798 /*** */ 799 /*** ****************************************************************/ 800 801 /* parameters */ 802 803 dcl refname char (*) parameter; 804 dcl segsp ptr parameter; 805 dcl seg_ct fixed bin parameter; 806 807 /* based */ 808 809 dcl 01 seg (seg_ct) aligned like segment based (segsp); 810 811 /* automatic */ 812 813 dcl actual_code fixed bin (35) automatic; 814 dcl ec fixed bin (35) automatic; 815 dcl s fixed bin automatic; 816 817 /* terminate the name */ 818 819 call hcs_$terminate_name (refname, ec); 820 if ec ^= 0 821 then call exit (ec); 822 823 /* reference the segment to see if it was terminated as well */ 824 825 call hcs_$get_uid_seg (seg (1).textp, (""b), ec); 826 if ec = error_table_$invalidsegno 827 then do; 828 829 /* the segment was terminated, so we free the linkage and */ 830 /* terminate any associated segments. */ 831 832 call free_linkage (segsp, seg_ct); 833 834 actual_code = 0; 835 836 do s = 2 to seg_ct; 837 call hcs_$terminate_seg (seg (s).textp, 0b, ec); 838 if ec ^= 0 839 then actual_code = ec; 840 else seg (s).textp = null; 841 end; 842 843 if actual_code ^= 0 844 then call exit (actual_code); 845 end; 846 847 end terminate_single_refname; 848 849 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 850 851 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 852 853 854 terminate_segno: 855 proc (segsp, /** segments struc ptr (in ) */ 856 seg_ct); /** segment count (in ) */ 857 858 /*** ****************************************************************/ 859 /*** */ 860 /*** Name: terminate_segno */ 861 /*** Input: segsp, seg_ct */ 862 /*** Function: terminates the segments identified by the segs */ 863 /*** structure after freeing their linkage sections */ 864 /*** and fixing any *system init_info references. */ 865 /*** Output: none */ 866 /*** */ 867 /*** ****************************************************************/ 868 869 /* parameters */ 870 871 dcl segsp ptr parameter; 872 dcl seg_ct fixed bin parameter; 873 874 /* based */ 875 876 dcl 01 seg (seg_ct) aligned like segment based (segsp); 877 878 /* automatic */ 879 880 dcl actual_code fixed bin (35) automatic; 881 dcl s fixed bin automatic; 882 dcl ec fixed bin (35) automatic; 883 884 /* free the linkage sections and clean up the environment */ 885 886 call free_linkage (segsp, seg_ct); 887 888 /* actually terminate the segments */ 889 890 actual_code = 0; 891 892 do s = 1 to seg_ct; 893 call hcs_$terminate_seg (seg (s).textp, 0b, ec); 894 if ec ^= 0 895 then actual_code = ec; 896 else seg (s).textp = null; 897 end; 898 899 if actual_code ^= 0 900 then call exit (actual_code); 901 902 end terminate_segno; 903 904 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 905 906 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 907 908 909 unsnap_links: 910 proc (segsp, /** segments struc ptr (in ) */ 911 seg_ct); /** segment count (in ) */ 912 913 /*** ****************************************************************/ 914 /*** */ 915 /*** Name: unsnap_links */ 916 /*** Input: segsp, seg_ct */ 917 /*** Function: scans the linkage sections of each active segment */ 918 /*** for links to any of the segments listed in the */ 919 /*** segs structure and unsnaps them. */ 920 /*** Output: none */ 921 /*** */ 922 /*** ****************************************************************/ 923 924 /* parameters */ 925 926 dcl segsp ptr parameter; 927 dcl seg_ct fixed bin parameter; 928 929 /* based */ 930 931 dcl 01 seg (seg_ct) aligned like segment based (segsp); 932 dcl lk ptr based (lkp); 933 dcl 01 vlh aligned like virgin_linkage_header based (vlhp); 934 dcl 01 lh aligned like linkage_header based (lhp); 935 936 /* automatic */ 937 938 dcl c fixed bin automatic; 939 dcl found bit (1) automatic; 940 dcl hcsc fixed bin (15) automatic; 941 dcl high_seg fixed bin automatic; 942 dcl isp ptr automatic; 943 dcl lhp ptr automatic; 944 dcl lk_end fixed bin automatic; 945 dcl lk_segno fixed bin (18) unsigned automatic; 946 dcl lk_word fixed bin (18) unsigned automatic; 947 dcl lkp ptr automatic; 948 dcl low_seg fixed bin automatic; 949 dcl nsegs fixed bin (15) automatic; 950 dcl offset fixed bin automatic; 951 dcl seg_no fixed bin (18) automatic; 952 dcl trap_errors bit (1) automatic; 953 dcl vlhp ptr automatic; 954 955 trap_errors = false; 956 957 on seg_fault_error 958 begin; 959 960 /* we set up this handler here and enable and disable it using */ 961 /* a flag for better efficiency. */ 962 963 if trap_errors 964 then do; 965 found = true; 966 trap_errors = false; 967 goto UNSNAP; 968 end; 969 else do; 970 call free_faulted_linkage (segsp, seg_ct, seg_no); 971 goto SKIP; 972 end; 973 end; 974 975 call hcs_$high_low_seg_count (nsegs, hcsc); 976 low_seg = hcsc + 1; 977 high_seg = hcsc + nsegs; 978 979 /* for each initiated segment */ 980 981 do seg_no = low_seg to high_seg; 982 983 /* try to get the linkage pointer */ 984 985 call get_lp (seg_no, lhp, isp, ""b); 986 987 /* only check segments which have a linkage section */ 988 989 if lhp ^= null 990 then do; 991 992 /* get the original linkage section pointer */ 993 994 vlhp = lh.original_linkage_ptr; 995 996 /* calculate the size of the link array */ 997 998 if vlh.defs_in_link = "20"b3 999 then lk_end = vlh.def_offset; 1000 else lk_end = vlh.linkage_section_lng; 1001 1002 if vlh.first_ref_relp ^= 0 1003 then lk_end = min (lk_end, vlh.first_ref_relp); 1004 1005 /* scan the link array of the current linkage section */ 1006 1007 do offset = vlh.link_begin by 2 to lk_end - 2; 1008 1009 /* get a pointer to the link */ 1010 1011 lkp = addwordno (lhp, offset); 1012 1013 /* we are only concerned with snapped links */ 1014 1015 if lkp -> its_unsigned.its_mod = ITS_MODIFIER 1016 then do; 1017 found = false; 1018 1019 /* trap seg fault errors when referencing the link and */ 1020 /* unsnap the link if one occurs. */ 1021 1022 trap_errors = true; 1023 1024 lk_segno = segno (lk); 1025 lk_word = wordno (lk); 1026 1027 trap_errors = false; 1028 1029 /* scan the segments for a match */ 1030 1031 do c = 1 to seg_ct while (^found); 1032 1033 /* see if the link refers to the target segment */ 1034 1035 if lk_segno = segno (seg (c).textp) 1036 then found = true; 1037 1038 /* or its linkage section */ 1039 1040 else if lk_segno = seg (c).link_segno & 1041 lk_word >= seg (c).link_start & 1042 lk_word <= seg (c).link_end 1043 then found = true; 1044 1045 /* or its static section */ 1046 1047 else if lk_segno = seg (c).stat_segno & 1048 lk_word >= seg (c).stat_start & 1049 lk_word <= seg (c).stat_end 1050 then found = true; 1051 end; 1052 1053 /* if it refers to one of the given segments, unsnap it */ 1054 1055 UNSNAP: 1056 if found 1057 then unspec (lk) = unspec (addwordno (vlhp, offset) -> lk); 1058 end; 1059 end; 1060 end; 1061 SKIP: 1062 end; 1063 1064 end unsnap_links; 1065 1066 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1067 1068 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1069 1070 1071 free_linkage: 1072 proc (segsp, /** segments struc ptr (in ) */ 1073 seg_ct); /** segment count (in ) */ 1074 1075 /*** ****************************************************************/ 1076 /*** */ 1077 /*** Name: free_linkage */ 1078 /*** Input: segsp, seg_ct */ 1079 /*** Function: closes language I/O files, frees fortran internal */ 1080 /*** static LA's and VLA's, free's the linkage and */ 1081 /*** static sections, and nulls any references to the */ 1082 /*** segments in the init_info pointers of external */ 1083 /*** variable nodes. */ 1084 /*** Output: none */ 1085 /*** */ 1086 /*** ****************************************************************/ 1087 1088 /* parameters */ 1089 1090 dcl segsp ptr parameter; 1091 dcl seg_ct fixed bin parameter; 1092 1093 /* based */ 1094 1095 dcl linkage_section (1:linkl) bit (36) aligned based (linkp); 1096 dcl 01 seg (seg_ct) aligned like segment based (segsp); 1097 dcl static_section (1:statl) bit (36) aligned based (statp); 1098 dcl based_area area based; 1099 1100 /* automatic */ 1101 1102 dcl i fixed bin automatic; 1103 dcl isotp ptr automatic; 1104 dcl linkl fixed bin (18) automatic; 1105 dcl linkp ptr automatic; 1106 dcl lotp ptr automatic; 1107 dcl np ptr automatic; 1108 dcl s fixed bin automatic; 1109 dcl sb ptr automatic; 1110 dcl seg_no fixed bin (18) unsigned automatic; 1111 dcl statl fixed bin (18) automatic; 1112 dcl statp ptr automatic; 1113 dcl sys_infop ptr automatic; 1114 1115 sb = stackbaseptr (); 1116 lotp = sb -> stack_header.lot_ptr; 1117 isotp = sb -> stack_header.isot_ptr; 1118 1119 /* free the linkage section for each segment with linkage */ 1120 1121 do s = 1 to seg_ct; 1122 if seg (s).link_segno ^= 0 1123 then do; 1124 1125 /* get the pointers and lengths of the linkage and static */ 1126 /* sections (if there is a separate static section). */ 1127 1128 seg_no = segno (seg (s).textp); 1129 linkp = baseptr (seg (s).link_segno); 1130 linkp = setwordno (linkp, seg (s).link_start); 1131 linkl = seg (s).link_end - seg (s).link_start + 1; 1132 if seg (s).stat_segno = 0 1133 then do; 1134 statp = null; 1135 statl = 0; 1136 end; 1137 else do; 1138 statp = baseptr (seg (s).stat_segno); 1139 statp = setwordno (linkp, seg (s).stat_start); 1140 statl = seg (s).stat_end - seg (s).stat_start + 1; 1141 end; 1142 1143 /* clean up pl1 I/O stuff from the static section before freeing */ 1144 1145 if plio2_data_fsb_thread_ ^= null 1146 then call plio2_$close_in_this_static (plio2_data_fsb_thread_, 1147 statp, statl); 1148 1149 /* release any static VLAs */ 1150 1151 if linkp -> linkage_header_flags.static_vlas 1152 then call fortran_storage_manager_$free (linkp); 1153 1154 /* free the static section if it is separate */ 1155 1156 if seg (s).flags.separate_static & statp ^= null 1157 then free static_section 1158 in (sb -> stack_header.combined_stat_ptr -> based_area); 1159 1160 /* clear the isot entry */ 1161 1162 unspec (isotp -> isot.isp (seg_no)) = ""b; 1163 1164 /* free the linkage section */ 1165 1166 free linkage_section in (sb -> stack_header.clr_ptr -> based_area); 1167 1168 /* set the lot entry to lot_fault */ 1169 1170 unspec (lotp -> lot.lp (seg_no)) = lot_fault; 1171 end; 1172 end; 1173 1174 sys_infop = sb -> stack_header.sys_link_info_ptr; 1175 1176 if sys_infop ^= null 1177 then do; 1178 1179 /* there are *system links, so search the table looking for */ 1180 /* init_info pointers which refer to the segment(s) being */ 1181 /* terminated, and set the init_info pointers to null. */ 1182 1183 do i = lbound (sys_infop -> variable_table_header.hash_table, 1) 1184 to hbound (sys_infop -> variable_table_header.hash_table, 1); 1185 do np = sys_infop -> variable_table_header.hash_table (i) 1186 repeat (np -> variable_node.forward_thread) while (np ^= null); 1187 1188 /* compare with each text pointer and null the ptr if it matches */ 1189 1190 do s = 1 to seg_ct while (np -> variable_node.init_ptr ^= null); 1191 if segno (np -> variable_node.init_ptr) = segno (seg (s).textp) 1192 then do; 1193 np -> variable_node.init_ptr = null; 1194 np -> variable_node.seg_ptr = null; 1195 end; 1196 end; 1197 end; 1198 end; 1199 end; 1200 1201 end free_linkage; 1202 1203 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1204 1205 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1206 1207 1208 free_faulted_linkage: 1209 proc (segsp, /** segments pointer (in ) */ 1210 seg_ct, /** segment count (in ) */ 1211 seg_no); /** segment number (in ) */ 1212 1213 /*** ****************************************************************/ 1214 /*** */ 1215 /*** Name: free_faulted_linkage */ 1216 /*** Input: segsp, seg_ct, seg_no */ 1217 /*** Function: If a segment fault occurs during the unsnapping */ 1218 /*** of links, one of the following situations exists: */ 1219 /*** - The link we are testing has an indirection */ 1220 /*** tag, and one of the segments in the chain */ 1221 /*** doesnt exist. This is resolved by unsnapping */ 1222 /*** the link. This is done in the handler (in */ 1223 /*** unsnap links). */ 1224 /*** - We have take a segment fault on term_, on the */ 1225 /*** stack, or the linkage area. In any of these */ 1226 /*** cases, we cant do anything anyway (and the */ 1227 /*** process is probably about to die anyway) so */ 1228 /*** we ignore them. */ 1229 /*** - One of the segments in the address space has */ 1230 /*** been deleted or is otherwise inaccessible but */ 1231 /*** its linkage section still exists. This is */ 1232 /*** the case that this procedure handles. We deal */ 1233 /*** with this case by freeing the linkage and */ 1234 /*** static for the now-defunct segment, and */ 1235 /*** clearing the lot and isot values. */ 1236 /*** Output: none */ 1237 /*** */ 1238 /*** ****************************************************************/ 1239 1240 /* parameters */ 1241 1242 dcl segsp ptr parameter; 1243 dcl seg_ct fixed bin parameter; 1244 dcl seg_no fixed bin (18) parameter; 1245 1246 /* based */ 1247 1248 dcl based_area area based; 1249 dcl linkage_section (linkl) bit (36) based (linkp); 1250 dcl 01 segs (seg_ct) aligned like segment based (segsp); 1251 dcl static_section (statl) bit (36) based (statp); 1252 1253 /* automatic */ 1254 1255 dcl i fixed bin automatic; 1256 dcl isotp ptr automatic; 1257 dcl linkl fixed bin (18) automatic; 1258 dcl linkp ptr automatic; 1259 dcl lotp ptr automatic; 1260 dcl sb ptr automatic; 1261 dcl ss bit (1) automatic; 1262 dcl statl fixed bin (18) automatic; 1263 dcl statp ptr automatic; 1264 1265 /* if the segment we faulted on is one of the ones we were going */ 1266 /* to terminate anyway, just skip this, as the linkage will be */ 1267 /* freed shortly. */ 1268 1269 do i = 1 to seg_ct; 1270 if seg_no = segno (segs (i).textp) 1271 then return; 1272 end; 1273 1274 /* find the stack header, lot and isot */ 1275 1276 sb = stackbaseptr (); 1277 1278 lotp = sb -> stack_header.lot_ptr; 1279 isotp = sb -> stack_header.isot_ptr; 1280 1281 /* get the linkage and static pointers and calculate the section lengths */ 1282 1283 call get_lp (seg_no, linkp, statp, ss); 1284 1285 linkl = linkp -> linkage_header.block_length; 1286 statl = linkp -> linkage_header.static_length; 1287 1288 /* clean up pl1 I/O stuff from the static section before freeing */ 1289 1290 if plio2_data_fsb_thread_ ^= null 1291 then call plio2_$close_in_this_static (plio2_data_fsb_thread_, statp, 1292 statl); 1293 1294 /* release any static VLAs */ 1295 1296 if linkp -> linkage_header_flags.static_vlas 1297 then call fortran_storage_manager_$free (linkp); 1298 1299 /* free the static section if we have a separate static section */ 1300 1301 if ss & statp ^= null 1302 then free static_section 1303 in (sb -> stack_header.combined_stat_ptr -> based_area); 1304 1305 /* and clear the isot entry */ 1306 1307 unspec (isotp -> isot.isp (seg_no)) = ""b; 1308 1309 /* now free the linkage section and reset the lot entry to lot_fault */ 1310 1311 free linkage_section in (sb -> stack_header.clr_ptr -> based_area); 1312 1313 unspec (lotp -> lot.lp (seg_no)) = lot_fault; 1314 1315 end free_faulted_linkage; 1316 1317 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1318 1319 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1320 1321 1322 get_lp: 1323 proc (segno, /** segment number (in ) */ 1324 linkp, /** linkage pointer (out) */ 1325 statp, /** static pointer (out) */ 1326 sep_stat); /** seperate static sw (out) */ 1327 1328 /*** ****************************************************************/ 1329 /*** */ 1330 /*** Name: get_lp */ 1331 /*** Input: segno */ 1332 /*** Function: gets the linkage and static pointers for the */ 1333 /*** given segment out of the lot and determines if */ 1334 /*** there is a separate static section. */ 1335 /*** Output: linkp, statp, sep_stat */ 1336 /*** */ 1337 /*** ****************************************************************/ 1338 1339 /* parameters */ 1340 1341 dcl segno fixed bin (18) parameter; 1342 dcl linkp ptr parameter; 1343 dcl statp ptr parameter; 1344 dcl sep_stat bit (1) parameter; 1345 1346 /* automatic */ 1347 1348 dcl isotp ptr automatic; 1349 dcl lotp ptr automatic; 1350 dcl sb ptr automatic; 1351 1352 sb = stackbaseptr (); 1353 lotp = sb -> stack_header.lot_ptr; 1354 isotp = sb -> stack_header.isot_ptr; 1355 1356 linkp = null; 1357 statp = null; 1358 sep_stat = false; 1359 1360 if segno > sb -> stack_header.cur_lot_size 1361 then return; 1362 1363 if unspec (lotp -> lot.lp (segno)) ^= ""b & 1364 unspec (lotp -> lot.lp (segno)) ^= lot_fault 1365 then do; 1366 linkp = lotp -> lot.lp (segno); 1367 if isotp -> isot1 (segno).fault = "11"b 1368 then sep_stat = true; 1369 else if isotp -> isot.isp (segno) = linkp 1370 then statp = addwordno (linkp, size (linkage_header)); 1371 else do; 1372 sep_stat = true; 1373 statp = isotp -> isot.isp (segno); 1374 end; 1375 end; 1376 1377 end get_lp; 1378 1379 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1380 1381 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1382 1383 1384 exit: 1385 proc (ec); /** error code (in ) */ 1386 1387 /*** ****************************************************************/ 1388 /*** */ 1389 /*** Name: exit */ 1390 /*** Input: ec */ 1391 /*** Function: returns from term_ setting the given error code */ 1392 /*** Output: none */ 1393 /*** */ 1394 /*** ****************************************************************/ 1395 1396 /* parameters */ 1397 1398 dcl ec fixed bin (35) parameter; 1399 1400 a_code = ec; 1401 goto EXIT; 1402 1403 end exit; 1404 1405 EXIT: 1406 call clean_up (segsp, segment_count); 1407 return; 1408 1409 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1410 1411 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1412 1413 1 1 /* Begin include file definition_dcls.incl.pl1 BIM 1981 */ 1 2 1 3 1 4 /****^ HISTORY COMMENTS: 1 5* 1) change(86-05-02,Elhard), approve(86-05-02,MCR7391), 1 6* audit(86-07-18,DGHowe), install(86-11-20,MR12.0-1222): 1 7* Modified to add indirect bit to definition flags, add msf_map_relp to the 1 8* definition header, declare the msf_map, and add structures and constants 1 9* for deferred initialization. 1 10* 2) change(86-06-24,DGHowe), approve(86-06-24,MCR7420), 1 11* audit(86-08-05,Schroth), install(86-11-20,MR12.0-1222): 1 12* added the structures for pointer initialization. pointer_init_template. 1 13* changed list_template_entry 1 14* END HISTORY COMMENTS */ 1 15 1 16 1 17 /* Modified: */ 1 18 /* 13 Dec 1982 by Lee A. Newcomb to put definition_header.hash_table_relp */ 1 19 /* after unused half-word instead of before it. */ 1 20 /* 1 March 1983 by M. Weaver to add list template init type */ 1 21 1 22 /* format: style3,idind25 */ 1 23 /* everything for the definition section */ 1 24 1 25 declare ( 1 26 CLASS_TEXT init (0), /* text section definition */ 1 27 CLASS_LINKAGE init (1), /* linkage section definition */ 1 28 CLASS_SYMBOL init (2), /* symbol section definition */ 1 29 CLASS_SEGNAME init (3), /* segment name definition */ 1 30 CLASS_STATIC init (4), /* static section definition */ 1 31 CLASS_SYSTEM init (5), /* valid only in self links, not def class */ 1 32 CLASS_HEAP init (6) /* valid only in self links, not def class */ 1 33 ) fixed bin (3) unsigned internal static options (constant); 1 34 1 35 declare CLASS_NAMES (0:6) character (12) internal static options (constant) 1 36 init ("text", "linkage", "symbol", "segname", "static", "system", "heap"); 1 37 1 38 declare SYMBOLIC_SECTION_NAMES (0:6) character (8) 1 39 init ("*text", "*link", "*symbol", *, "*static", "*system", "*heap") internal static 1 40 options (constant); 1 41 1 42 declare 1 definition_flags unaligned based, 1 43 2 new bit (1), /* should be "1"b */ 1 44 2 ignore bit (1), /* cannot snap link to this */ 1 45 2 entry bit (1), /* can tra here */ 1 46 2 retain bit (1), /* binder respects this */ 1 47 2 argcount bit (1), /* OBSOLETE */ 1 48 2 descriptors bit (1), /* OBSOLETE */ 1 49 2 indirect bit (1), /* target is a pointer to actual target */ 1 50 2 unused bit (8); /* Must be zero */ 1 51 1 52 1 53 1 54 1 55 /* Header of the definition section */ 1 56 1 57 declare def_header_ptr pointer; 1 58 declare 1 definition_header aligned based (def_header_ptr), 1 59 2 def_list_relp fixed bin (18) unsigned unaligned, 1 60 /* first definition, reloc def18 */ 1 61 2 msf_map_relp fixed bin (18) unsigned unaligned, 1 62 /* msf_map if any, or 0 if none. reloc def18 unless none */ 1 63 2 hash_table_relp fixed bin (18) unsigned unaligned, 1 64 /* def hash table, if any, or 0 if none. reloc def18 unless none */ 1 65 2 flags unaligned like definition_flags; 1 66 /* both new and ignore must be "1"b here */ 1 67 1 68 /* A non class=3 definition. See segname_definition below for class=3 */ 1 69 1 70 1 71 declare def_ptr pointer; 1 72 declare 1 definition aligned based (def_ptr), 1 73 2 forward_relp unal fixed bin (18) unsigned, 1 74 /* offset of next def */ 1 75 2 backward_relp unal fixed bin (18) unsigned, 1 76 /* offset of previous def */ 1 77 2 thing_relp unal fixed bin (18) unsigned, 1 78 /* offset in section specified by class of thing this defines */ 1 79 2 flags unaligned like definition_flags, 1 80 2 class unal fixed bin (3) unsigned, 1 81 /* Type of definition */ 1 82 2 name_relp unal fixed bin (18) unsigned, 1 83 /* offset of ACC for symbol */ 1 84 2 segname_relp unal fixed bin (18) unsigned; 1 85 /* offset of segname def to which this belongs */ 1 86 1 87 /* Class=3, segname definition */ 1 88 1 89 declare segname_ptr pointer; 1 90 declare 1 segname_definition aligned based (segname_ptr), 1 91 2 forward_relp unal fixed bin (18) unsigned, 1 92 /* offset of next def */ 1 93 2 backward_relp unal fixed bin (18) unsigned, 1 94 /* offset of previous def */ 1 95 2 next_segname_relp unal fixed bin (18) unsigned, 1 96 /* offset of next segname def */ 1 97 2 flags unaligned like definition_flags, 1 98 2 class unal fixed bin (3) unsigned, 1 99 /* 3 for segname */ 1 100 2 name_relp unal fixed bin (18) unsigned, 1 101 /* offset of ACC for symbol */ 1 102 2 first_relp unal fixed bin (18) unsigned; 1 103 /* see following : */ 1 104 1 105 /* Definition blocks are chained off of segname definitions. 1 106* segname_definition.first_relp is one of three things: 1 107* (1) the def section offset of the first ordinary (class^=3) definition 1 108* belonging to this segname block. In the case where there are more than 1 109* one segname's on a block, all their first_relp will point 1 110* to the same place. 1 111* 1 112* (2) if there are no ordinary definitions associated with this segname, 1 113* then it is the def section offset of the next segname. 1 114* 1 115* (3) if there are no ordinary definitions in the block, and it 1 116* is the last block, then it points to a word containing 0. 1 117* 1 118* Thus the end of a list of synonym segnames can be detected by forward_relp 1 119* pointing to a class=3 definition whose first_relp is not the same as 1 120* the current definitions first_relp. 1 121**/ 1 122 1 123 /* All the definitions are linked through the forward and 1 124* backward thread variables. The end of the chain can is indicated 1 125* by forward pointing to a zero word. */ 1 126 1 127 1 128 declare exp_ptr pointer; 1 129 declare 1 exp_word based (exp_ptr) aligned, /* expression word in link definition */ 1 130 2 type_relp fixed bin (18) unsigned unal, 1 131 /* pointer (rel to defs) of type pair structure */ 1 132 2 expression fixed bin (17) unal; /* constant expression to be added in when snapping link */ 1 133 1 134 declare ( 1 135 LINK_SELF_BASE init (1), /* *section|0+expression,modifier */ 1 136 /* which section determined by segname_relp */ 1 137 LINK_OBSOLETE_2 init (2), /* not used */ 1 138 LINK_REFNAME_BASE init (3), /* refname|0+expression,modifier */ 1 139 LINK_REFNAME_OFFSETNAME init (4), /* refname|offsetname+expression,modifier */ 1 140 LINK_SELF_OFFSETNAME init (5), /* *section|offsetname+expression,modifier */ 1 141 LINK_CREATE_IF_NOT_FOUND init (6), /* OBSOLETE: like LINK_REFNAME_OFFSETNAME except that it will create instead of taking linkage_error */ 1 142 SECTION_TEXT init (0), /* *text */ 1 143 SECTION_LINK init (1), /* *link */ 1 144 SECTION_SYMBOL init (2), /* *symbol */ 1 145 SECTION_UNUSED init (3), /* reserved */ 1 146 SECTION_STATIC init (4), /* *static */ 1 147 SECTION_SYSTEM init (5), /* *system */ 1 148 SECTION_HEAP init (6) /* *heap */ 1 149 ) fixed bin (18) unsigned unaligned internal static options (constant); 1 150 1 151 /* use CLASS_NAMES for section names */ 1 152 1 153 declare LINK_TYPE_NAMES (1:6) 1 154 init ("absolute in section", "unused", "absolute off of refname", 1 155 "symbolic off of refname", "symbolic in section", "symbolic off of refname; create") 1 156 character (32) varying internal static options (constant); 1 157 1 158 1 159 declare type_ptr pointer; 1 160 declare 1 type_pair based (type_ptr) aligned,/* type pair in link definition */ 1 161 2 type fixed bin (18) unsigned unal, 1 162 /* see above */ 1 163 2 trap_relp fixed bin (18) unsigned unal, 1 164 /* pointer (rel to defs) to the trap word */ 1 165 /* unless LINK_SELF_OFFSETNAME off of *system or create link */ 1 166 2 segname_relp fixed bin (18) unsigned unal, 1 167 /* pointer (rel to defs) to ACC reference name for segment referenced, 1 168* /*or section code for SELF links */ 1 169 2 offsetname_relp fixed bin (18) unsigned unal; 1 170 /* for OFFSETNAME links, ACC string of name of location. */ 1 171 /* for others, must be ZERO */ 1 172 1 173 1 174 /* Link Trap Pair */ 1 175 1 176 declare link_trap_ptr pointer; 1 177 declare 1 link_trap_pair aligned based (link_trap_ptr), 1 178 2 call_relp fixed bin (18) unsigned unaligned, 1 179 /* LINK18, link to thing to call */ 1 180 2 info_relp fixed bin (18) unsigned unaligned; 1 181 /* LINK18, link to argument list */ 1 182 1 183 1 184 /* initialization info for *system or *heap link */ 1 185 1 186 1 187 /* NOTE -------------------------------------------------- 1 188* the following structures defining initialization information are also 1 189* defined in fortran_storage.incl.pl1 system_link_init_info.incl.pl1 1 190* and should be kept equivalent 1 191* ------------------------------------------------------- 1 192**/ 1 193 1 194 declare ( 1 195 INIT_NO_INIT init (0), 1 196 INIT_COPY_INFO init (3), 1 197 INIT_DEFINE_AREA init (4), 1 198 INIT_LIST_TEMPLATE init (5), 1 199 INIT_DEFERRED init (6) 1 200 ) fixed bin internal static options (constant); 1 201 1 202 /* for type = 0 or 4 */ 1 203 1 204 declare link_init_ptr pointer; 1 205 declare 1 link_init aligned based (link_init_ptr), 1 206 2 n_words fixed bin (35), /* number to invent */ 1 207 2 type fixed bin; /* see types above */ 1 208 1 209 /* for type=3, there is data to copy */ 1 210 1 211 declare 1 link_init_copy_info aligned based (link_init_ptr), 1 212 2 header aligned like link_init, 1 213 2 initial_data (link_init_n_words refer (link_init_copy_info.header.n_words)) bit (36) aligned; 1 214 1 215 declare link_init_n_words fixed bin; 1 216 1 217 /* for type = 5, there is a list template to copy */ 1 218 1 219 declare 1 link_init_list_template 1 220 aligned based (link_init_ptr), 1 221 2 header aligned like link_init, 1 222 2 pad bit (18) unaligned, 1 223 2 n_words_in_list fixed bin (18) unsigned unaligned, 1 224 2 template (link_init_n_words_in_list refer (link_init_list_template.n_words_in_list)); 1 225 1 226 declare link_init_n_words_in_list 1 227 fixed bin; 1 228 1 229 /* A list template consists of a series of entries with the following 1 230* description, concatenated together. n_bits and datum are bit items, 1 231* to permit a wide range of inputs. 1 232* 1 233* 1. A 'repeat' of '0' signifies skipping of 'n_bits' bits. 1 234* 2. A 'n_bits' of '0' signifies the last item of the list. 1 235* 1 236* COMMON, VLA's, and LA's are presumed to start at the base pointer 1 237* of their particular storage section. */ 1 238 1 239 declare 1 list_template_entry aligned based, 1 240 2 n_bits fixed bin (35) aligned, /* size of datum */ 1 241 2 mbz bit (3) unaligned, /* future expansion */ 1 242 2 init_type fixed bin (3) unsigned unaligned, /* 0 normal init, 1 ptr init, 2 packed ptr init */ 1 243 2 repeat fixed bin (30) unsigned unaligned, 1 244 /* number of times to repeat datum */ 1 245 2 datum bit (link_init_n_bits_in_datum refer (list_template_entry.n_bits)); 1 246 1 247 1 248 /* the pointer_init_template represents the initialization information 1 249* for ITS and packed pointers. Both pointer types require the entire 1 250* 72 bit structure. 1 251**/ 1 252 1 253 dcl 1 pointer_init_template based, 1 254 2 ptr_type fixed bin (18) unsigned unaligned, /* 0 text section, 1 linkage section, 2 static section */ 1 255 2 section_offset fixed bin (18) unsigned unaligned, /* offset to item in specified section */ 1 256 2 word_offset fixed bin (18) unsigned unaligned, /* offset from section item to target in words */ 1 257 2 mbz bit (12) unaligned, 1 258 2 bit_offset fixed bin (6) unsigned unaligned; /* offset from section item|word offset to target in bits */ 1 259 1 260 1 261 declare link_init_n_bits_in_datum 1 262 fixed bin (35); 1 263 1 264 /* for type = 6, the init_info resides in another MSF component */ 1 265 /* target_relp is a linkage section offset to a partial link to */ 1 266 /* the base of the linkage section of the component containing */ 1 267 /* the actual init_info. link_relp is the offset of the actual */ 1 268 /* link within that linkage section. */ 1 269 1 270 declare 1 link_init_deferred aligned based (link_init_ptr), 1 271 2 header aligned like link_init, 1 272 2 target_relp fixed bin (18) unsigned unaligned, 1 273 2 link_relp fixed bin (18) unsigned unaligned; 1 274 1 275 /* Definition section hash table */ 1 276 1 277 declare def_ht_ptr pointer; 1 278 declare 1 definition_ht aligned based (def_ht_ptr), 1 279 2 n_entries fixed bin, 1 280 2 table (def_ht_n_entries refer (definition_ht.n_entries)) aligned, 1 281 3 def_relp fixed bin (18) unsigned unaligned, 1 282 3 unused bit (18) unaligned; 1 283 1 284 declare def_ht_n_entries fixed bin; 1 285 1 286 1 287 /* Component name ht */ 1 288 declare comp_ht_ptr pointer; 1 289 declare 1 component_ht aligned based (comp_ht_ptr), 1 290 2 n_entries fixed bin, 1 291 2 table (comp_ht_n_entries refer (component_ht.n_entries)) aligned, 1 292 3 def_relp fixed bin (18) unsigned unaligned, 1 293 /* hashed segname */ 1 294 3 block_hdr_relp fixed bin (18) unsigned unaligned; 1 295 /* first segname def of block containing def_relp */ 1 296 1 297 declare comp_ht_n_entries fixed bin; 1 298 1 299 /* Duplicate name table */ 1 300 1 301 declare dup_table_ptr pointer; 1 302 declare 1 duplicate_table aligned based (dup_table_ptr), 1 303 2 mbz bit (18) unaligned, /* to tell it from a definition */ 1 304 2 n_names fixed bin (18) unsigned unaligned, 1 305 /* n in table */ 1 306 2 table (dup_table_n_names refer (duplicate_table.n_names)) aligned, 1 307 3 def_relp fixed bin (18) unsigned unaligned, 1 308 3 block_hdr_relp fixed bin (18) unsigned unaligned; 1 309 1 310 declare dup_table_n_names fixed bin; 1 311 1 312 /* The msf_map is found in the definition section of an */ 1 313 /* object MSF component. It is used by the linker to */ 1 314 /* determine whether a segment is a component of an object */ 1 315 /* MSF or a standard single-segment object. */ 1 316 1 317 dcl msf_map_ptr ptr; 1 318 dcl 01 msf_map aligned based (msf_map_ptr), 1 319 02 version char (8), 1 320 02 component_count fixed bin (15) unsigned, 1 321 02 my_component fixed bin (15) unsigned; 1 322 1 323 dcl msf_map_version_1 char (8) static options (constant) 1 324 init ("msfmp1.0"); 1 325 1 326 declare acc_string_ptr pointer; 1 327 declare 1 acc_string aligned based (acc_string_ptr), 1 328 2 count fixed bin (9) unsigned unaligned, 1 329 2 string character (max (3, acc_string_length) refer (acc_string.count)) unaligned, 1 330 2 mbz bit (0) aligned; /* this causes the statement */ 1 331 /* unspec (acc_string) = ""b to zero out */ 1 332 /* the last word, if the string is not of length 0mod4 */ 1 333 1 334 declare acc_string_length fixed bin (21); 1 335 1 336 1 337 /* end include file definitions_dcls.incl.pl1 */ 1414 2 1 /* BEGIN INCLUDE FILE object_link_dcls.incl.pl1 BIM 1981 from linkdcl */ 2 2 2 3 2 4 /****^ HISTORY COMMENTS: 2 5* 1) change(86-05-02,Elhard), approve(86-05-02,MCR7391), 2 6* audit(86-11-18,Schroth), install(86-11-20,MR12.0-1222): 2 7* Modified to add partial_link structure for an object MSF partially snapped 2 8* link. 2 9* 2) change(86-11-13,DGHowe), approve(86-11-13,MCR7391), audit(86-11-13,Zwick), 2 10* install(86-11-20,MR12.0-1222): 2 11* Added a declaration of FAULT_TAG_1, FAULT_TAG_2 and FAULT_TAG_3. 2 12* END HISTORY COMMENTS */ 2 13 2 14 2 15 /* format: style3 */ 2 16 /* everything you ever wanted in a linkage section */ 2 17 2 18 /* 2 19* Last Modified (Date and Reason): 2 20* 15 Nov 1971 by C Garman 2 21* 6/75 by M.Weaver to add virgin_linkage_header declaration 2 22* 6/75 by S.Webber to comment existing structures better 2 23* 9/77 by M. Weaver to add run_depth to link 2 24* 7/81 by B. Margulies for firstref structure, unsigned fixed bins. 2 25* 3/83 by M. Weaver to add flags overlaying def_ptr 2 26**/ 2 27 2 28 declare 1 object_link based aligned, /* link pair in linkage section */ 2 29 2 header_relp fixed bin (17) unal, /* rel pointer to beginning of linkage, always negative */ 2 30 2 ringno fixed bin (3) unsigned unal, /* MBZ */ 2 31 2 mbz bit (6) unal, 2 32 2 run_depth fixed bin (2) unal, /* run unit depth, filled when link is snapped */ 2 33 2 tag bit (6) unal, /* fault tag. 46(8) if not snapped, 43(8) if snapped */ 2 34 2 expression_relp fixed bin (18) unsigned unal, /* pointer (rel to defs) of expression word */ 2 35 2 mbz2 bit (12) unal, 2 36 2 modifier bit (6) unal; /* modifier to be left in snapped link */ 2 37 2 38 declare 1 partial_link based aligned, /* partially snapped link */ 2 39 2 type fixed bin (3) unsigned unal, /* target section of link */ 2 40 2 component fixed bin (15) unsigned unal, /* target component index */ 2 41 2 mbz1 bit (12) unal, 2 42 2 tag bit (6) unal, /* fault tag 3 47(8), ITS 43(8) if snapped */ 2 43 2 44 2 offset fixed bin (18) unsigned unal, /* word offset of link */ 2 45 2 mbz2 bit (3) unal, 2 46 2 bit_offset fixed bin (6) unsigned unal, /* bit offset (in practice, always 0) */ 2 47 2 mbz3 bit (3) unal, 2 48 2 modifier bit (6) unal; /* modifier to be left in snapped link */ 2 49 2 50 declare 1 linkage_header based aligned, /* linkage block header */ 2 51 2 def_ptr ptr, /* pointer to definition section */ 2 52 2 symbol_ptr ptr unal, /* pointer to symbol section in object segment */ 2 53 2 original_linkage_ptr 2 54 ptr unal, /* pointer to linkage section in object segment */ 2 55 2 unused bit (72), 2 56 2 stats, 2 57 3 begin_links fixed bin (18) unsigned unal, /* offset (rel to this section) of first link */ 2 58 3 block_length fixed bin (18) unsigned unal, /* number of words in this linkage section */ 2 59 3 segment_number 2 60 fixed bin (18) unsigned unal, /* text segment number associated with this section */ 2 61 3 static_length fixed bin (18) unsigned unal; /* number of words of static for this segment */ 2 62 2 63 declare 1 linkage_header_flags 2 64 aligned based, /* overlay of def_ptr for flags */ 2 65 2 pad1 bit (28) unaligned, /* flags are in first word */ 2 66 2 static_vlas bit (1) unaligned, /* static section "owns" some LA/VLA segments */ 2 67 2 perprocess_static 2 68 bit (1) unaligned, /* 1 copy of static section is shared among all tasks/run units */ 2 69 2 pad2 bit (6) unaligned; 2 70 2 71 declare 1 virgin_linkage_header 2 72 aligned based, /* template for linkage header in object segment */ 2 73 2 pad bit (30) unaligned, /* is filled in by linker */ 2 74 2 defs_in_link bit (6) unaligned, /* =o20 if defs in linkage (nonstandard) */ 2 75 2 def_offset fixed bin (18) unsigned unaligned, 2 76 /* offset of definition section */ 2 77 2 first_ref_relp fixed bin (18) unsigned unaligned, 2 78 /* offset of trap-at-first-reference offset array */ 2 79 2 filled_in_later bit (144), 2 80 2 link_begin fixed bin (18) unsigned unaligned, 2 81 /* offset of first link */ 2 82 2 linkage_section_lng 2 83 fixed bin (18) unsigned unaligned, 2 84 /* length of linkage section */ 2 85 2 segno_pad fixed bin (18) unsigned unaligned, 2 86 /* will be segment number of copied linkage */ 2 87 2 static_length fixed bin (18) unsigned unaligned; 2 88 /* length of static section */ 2 89 2 90 declare 1 fr_traps based aligned, /* First Reference Trap Procedures */ 2 91 2 decl_vers fixed bin, /* version of this struc, value=1, ABS reloc */ 2 92 2 n_traps fixed bin, /* number of traps on this segment, ABS */ 2 93 2 trap_array (n_fr_traps refer (fr_traps.n_traps)) aligned, 2 94 3 call_relp fixed bin (18) unsigned unaligned, 2 95 /* LINK18, offset of link defining procedure to call */ 2 96 3 info_relp fixed bin (18) unsigned unaligned; 2 97 /* LINK18, offser of link defining argument list for trap proc */ 2 98 2 99 declare FR_TRAPS_VERSION_1 init (1) fixed bin internal static options (constant); 2 100 declare FAULT_TAG_1 bit(6) unaligned init ("40"b3) static options (constant); 2 101 declare FAULT_TAG_2 bit(6) unaligned init ("46"b3) static options (constant); 2 102 declare FAULT_TAG_3 bit(6) unaligned init ("47"b3) static options (constant); 2 103 2 104 /* END INCLUDE FILE object_link_dcls.incl.pl1 */ 1415 3 1 /* BEGIN INCLUDE FILE its.incl.pl1 3 2* modified 27 July 79 by JRDavis to add its_unsigned 3 3* Internal format of ITS pointer, including ring-number field for follow-on processor */ 3 4 3 5 dcl 1 its based aligned, /* declaration for ITS type pointer */ 3 6 2 pad1 bit (3) unaligned, 3 7 2 segno bit (15) unaligned, /* segment number within the pointer */ 3 8 2 ringno bit (3) unaligned, /* ring number within the pointer */ 3 9 2 pad2 bit (9) unaligned, 3 10 2 its_mod bit (6) unaligned, /* should be 43(8) */ 3 11 3 12 2 offset bit (18) unaligned, /* word offset within the addressed segment */ 3 13 2 pad3 bit (3) unaligned, 3 14 2 bit_offset bit (6) unaligned, /* bit offset within the word */ 3 15 2 pad4 bit (3) unaligned, 3 16 2 mod bit (6) unaligned; /* further modification */ 3 17 3 18 dcl 1 itp based aligned, /* declaration for ITP type pointer */ 3 19 2 pr_no bit (3) unaligned, /* number of pointer register to use */ 3 20 2 pad1 bit (27) unaligned, 3 21 2 itp_mod bit (6) unaligned, /* should be 41(8) */ 3 22 3 23 2 offset bit (18) unaligned, /* word offset from pointer register word offset */ 3 24 2 pad2 bit (3) unaligned, 3 25 2 bit_offset bit (6) unaligned, /* bit offset relative to new word offset */ 3 26 2 pad3 bit (3) unaligned, 3 27 2 mod bit (6) unaligned; /* further modification */ 3 28 3 29 3 30 dcl 1 its_unsigned based aligned, /* just like its, but with unsigned binary */ 3 31 2 pad1 bit (3) unaligned, 3 32 2 segno fixed bin (15) unsigned unaligned, 3 33 2 ringno fixed bin (3) unsigned unaligned, 3 34 2 pad2 bit (9) unaligned, 3 35 2 its_mod bit (6) unaligned, 3 36 3 37 2 offset fixed bin (18) unsigned unaligned, 3 38 2 pad3 bit (3) unaligned, 3 39 2 bit_offset fixed bin (6) unsigned unaligned, 3 40 2 pad4 bit (3) unaligned, 3 41 2 mod bit (6) unaligned; 3 42 3 43 dcl 1 itp_unsigned based aligned, /* just like itp, but with unsigned binary where appropriate */ 3 44 2 pr_no fixed bin (3) unsigned unaligned, 3 45 2 pad1 bit (27) unaligned, 3 46 2 itp_mod bit (6) unaligned, 3 47 3 48 2 offset fixed bin (18) unsigned unaligned, 3 49 2 pad2 bit (3) unaligned, 3 50 2 bit_offset fixed bin (6) unsigned unaligned, 3 51 2 pad3 bit (3) unaligned, 3 52 2 mod bit (6) unaligned; 3 53 3 54 3 55 dcl ITS_MODIFIER bit (6) unaligned internal static options (constant) init ("43"b3); 3 56 dcl ITP_MODIFIER bit (6) unaligned internal static options (constant) init ("41"b3); 3 57 3 58 /* END INCLUDE FILE its.incl.pl1 */ 1416 4 1 /* BEGIN INCLUDE FILE -- lot.incl.pl1 S.Webber 9/74, Modified by R. Bratt 04/76, modified by M. Weaver 7/76 */ 4 2 /* modified by M. Weaver 3/77 */ 4 3 4 4 dcl lotp ptr; 4 5 4 6 dcl 1 lot based (lotp) aligned, 4 7 2 lp (0:9999) ptr unaligned; /* array of packed pointers to linkage sections */ 4 8 4 9 dcl lot_fault bit (36) aligned static options (constant) init ("111000000000000000000000000000000000"b); 4 10 /* lot fault has fault code = 0 and offset = 0 */ 4 11 4 12 dcl isotp ptr; 4 13 dcl 1 isot based (isotp) aligned, 4 14 2 isp (0:9999) ptr unaligned; 4 15 4 16 dcl 1 isot1 (0 :9999) aligned based, 4 17 2 flags unaligned, 4 18 3 fault bit (2) unaligned, 4 19 3 system bit (1) unaligned, 4 20 3 mbz bit (6) unaligned, 4 21 2 fault_code fixed bin (8) unaligned, 4 22 2 static_offset bit (18) unaligned; 4 23 4 24 4 25 /* END INCLUDE FILE lot.incl.pl1 */ 1417 5 1 /* BEGIN INCLUDE FILE ... stack_header.incl.pl1 .. 3/72 Bill Silver */ 5 2 /* modified 7/76 by M. Weaver for *system links and more system use of areas */ 5 3 /* modified 3/77 by M. Weaver to add rnt_ptr */ 5 4 /* Modified April 1983 by C. Hornig for tasking */ 5 5 5 6 /****^ HISTORY COMMENTS: 5 7* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), 5 8* audit(86-08-05,Schroth), install(86-11-03,MR12.0-1206): 5 9* added the heap_header_ptr definition. 5 10* 2) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 5 11* audit(86-10-10,Fawcett), install(86-11-03,MR12.0-1206): 5 12* Modified to support control point management. These changes were actually 5 13* made in February 1985 by G. Palter. 5 14* 3) change(86-10-22,Fawcett), approve(86-10-22,MCR7473), 5 15* audit(86-10-22,Farley), install(86-11-03,MR12.0-1206): 5 16* Remove the old_lot pointer and replace it with cpm_data_ptr. Use the 18 5 17* bit pad after cur_lot_size for the cpm_enabled. This was done to save some 5 18* space int the stack header and change the cpd_ptr unal to cpm_data_ptr 5 19* (ITS pair). 5 20* END HISTORY COMMENTS */ 5 21 5 22 /* format: style2 */ 5 23 5 24 dcl sb ptr; /* the main pointer to the stack header */ 5 25 5 26 dcl 1 stack_header based (sb) aligned, 5 27 2 pad1 (4) fixed bin, /* (0) also used as arg list by outward_call_handler */ 5 28 2 cpm_data_ptr ptr, /* (4) pointer to control point which owns this stack */ 5 29 2 combined_stat_ptr ptr, /* (6) pointer to area containing separate static */ 5 30 2 clr_ptr ptr, /* (8) pointer to area containing linkage sections */ 5 31 2 max_lot_size fixed bin (17) unal, /* (10) DU number of words allowed in lot */ 5 32 2 main_proc_invoked fixed bin (11) unal, /* (10) DL nonzero if main procedure invoked in run unit */ 5 33 2 have_static_vlas bit (1) unal, /* (10) DL "1"b if (very) large arrays are being used in static */ 5 34 2 pad4 bit (2) unal, 5 35 2 run_unit_depth fixed bin (2) unal, /* (10) DL number of active run units stacked */ 5 36 2 cur_lot_size fixed bin (17) unal, /* (11) DU number of words (entries) in lot */ 5 37 2 cpm_enabled bit (18) unal, /* (11) DL non-zero if control point management is enabled */ 5 38 2 system_free_ptr ptr, /* (12) pointer to system storage area */ 5 39 2 user_free_ptr ptr, /* (14) pointer to user storage area */ 5 40 2 null_ptr ptr, /* (16) */ 5 41 2 stack_begin_ptr ptr, /* (18) pointer to first stack frame on the stack */ 5 42 2 stack_end_ptr ptr, /* (20) pointer to next useable stack frame */ 5 43 2 lot_ptr ptr, /* (22) pointer to the lot for the current ring */ 5 44 2 signal_ptr ptr, /* (24) pointer to signal procedure for current ring */ 5 45 2 bar_mode_sp ptr, /* (26) value of sp before entering bar mode */ 5 46 2 pl1_operators_ptr ptr, /* (28) pointer to pl1_operators_$operator_table */ 5 47 2 call_op_ptr ptr, /* (30) pointer to standard call operator */ 5 48 2 push_op_ptr ptr, /* (32) pointer to standard push operator */ 5 49 2 return_op_ptr ptr, /* (34) pointer to standard return operator */ 5 50 2 return_no_pop_op_ptr 5 51 ptr, /* (36) pointer to standard return / no pop operator */ 5 52 2 entry_op_ptr ptr, /* (38) pointer to standard entry operator */ 5 53 2 trans_op_tv_ptr ptr, /* (40) pointer to translator operator ptrs */ 5 54 2 isot_ptr ptr, /* (42) pointer to ISOT */ 5 55 2 sct_ptr ptr, /* (44) pointer to System Condition Table */ 5 56 2 unwinder_ptr ptr, /* (46) pointer to unwinder for current ring */ 5 57 2 sys_link_info_ptr ptr, /* (48) pointer to *system link name table */ 5 58 2 rnt_ptr ptr, /* (50) pointer to Reference Name Table */ 5 59 2 ect_ptr ptr, /* (52) pointer to event channel table */ 5 60 2 assign_linkage_ptr ptr, /* (54) pointer to storage for (obsolete) hcs_$assign_linkage */ 5 61 2 heap_header_ptr ptr, /* (56) pointer to the heap header for this ring */ 5 62 2 trace, 5 63 3 frames, 5 64 4 count fixed bin, /* (58) number of trace frames */ 5 65 4 top_ptr ptr unal, /* (59) pointer to last trace frame */ 5 66 3 in_trace bit (36) aligned, /* (60) trace antirecursion flag */ 5 67 2 pad2 bit (36), /* (61) */ 5 68 2 pad5 pointer; /* (62) pointer to future stuff */ 5 69 5 70 /* The following offset refers to a table within the pl1 operator table. */ 5 71 5 72 dcl tv_offset fixed bin init (361) internal static; 5 73 /* (551) octal */ 5 74 5 75 5 76 /* The following constants are offsets within this transfer vector table. */ 5 77 5 78 dcl ( 5 79 call_offset fixed bin init (271), 5 80 push_offset fixed bin init (272), 5 81 return_offset fixed bin init (273), 5 82 return_no_pop_offset fixed bin init (274), 5 83 entry_offset fixed bin init (275) 5 84 ) internal static; 5 85 5 86 5 87 5 88 5 89 5 90 /* The following declaration is an overlay of the whole stack header. Procedures which 5 91* move the whole stack header should use this overlay. 5 92**/ 5 93 5 94 dcl stack_header_overlay (size (stack_header)) fixed bin based (sb); 5 95 5 96 5 97 5 98 /* END INCLUDE FILE ... stack_header.incl.pl1 */ 1418 6 1 /* BEGIN INCLUDE FILE ... system_link_names.incl.pl1 */ 6 2 6 3 6 4 /****^ HISTORY COMMENTS: 6 5* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), audit(86-11-12,Zwick), 6 6* install(86-11-20,MR12.0-1222): 6 7* added the declaration of the heap_header. 6 8* 2) change(86-10-20,DGHowe), approve(86-10-20,MCR7420), audit(86-11-12,Zwick), 6 9* install(86-11-20,MR12.0-1222): 6 10* add the seg ptr to the variable node structure. 6 11* END HISTORY COMMENTS */ 6 12 6 13 6 14 /* created by M. Weaver 7/28/76 */ 6 15 /* Modified: 82-11-19 by T. Oke to add LIST_TEMPLATE_INIT. */ 6 16 /* Modified 02/11/83 by M. Weaver to add have_vla_variables flag */ 6 17 6 18 6 19 dcl 1 variable_table_header aligned based, /* header for name table */ 6 20 2 hash_table (0:63) ptr unaligned, /* hash table for variable nodes */ 6 21 2 total_search_time fixed bin (71), /* total time to search for variables */ 6 22 2 total_allocation_time fixed bin (71), /* total time spent allocating and initializing nodes and variables */ 6 23 2 number_of_searches fixed bin, /* number of times names were looked up */ 6 24 2 number_of_variables fixed bin (35), /* number of variables allocated by the linker, incl deletions */ 6 25 2 flags unaligned, 6 26 3 have_vla_variables bit (1) unaligned, /* on if some variables are > sys_info$max_seg_size */ 6 27 3 pad bit (11) unaligned, 6 28 2 cur_num_of_variables fixed bin (24) unal, /* current number of variables allocated */ 6 29 2 number_of_steps fixed bin, /* total number of nodes looked at */ 6 30 2 total_allocated_size fixed bin (35); /* current amount of storage in user area */ 6 31 6 32 6 33 dcl 1 variable_node aligned based, /* individual variable information */ 6 34 2 forward_thread ptr unaligned, /* thread to next node off same hash bucket */ 6 35 2 vbl_size fixed bin (24) unsigned unaligned, /* length in words of variable */ 6 36 2 init_type fixed bin (11) unaligned, /* 0=not init; 3=init template; 4=area 5=list_template*/ 6 37 2 time_allocated fixed bin (71), /* time when variable was allocated */ 6 38 2 vbl_ptr ptr, /* pointer to variable's storage */ 6 39 2 init_ptr ptr, /* pointer to original init info in object seg */ 6 40 2 name_size fixed bin(21) aligned, /* length of name in characters */ 6 41 2 name char (nchars refer (variable_node.name_size)), /* name of variable */ 6 42 2 seg_ptr pointer; 6 43 6 44 /* variable_node.seg_ptr 6 45* Is a pointer to the segment containing the initialization information 6 46* for this variable. It is used as a segment base pointer for external 6 47* pointer initialization via list_init_. 6 48* 6 49* The init_ptr can not be used as a reference to the defining segment 6 50* due to the possibility of set_fortran_common being used to initialize 6 51* the external variables. sfc will generate an initialization information 6 52* structure if multiple intialization sizes are found in the specified 6 53* segments. sfc stores the address of this structure in the init_ptr field. 6 54* This is one reason why sfc does not perform external pointer 6 55* initialization. 6 56* 6 57* The seg_ptr is set to point at the segment used to define the 6 58* initialization information. term_ sets this field to null on termination 6 59* due to the possiblity of executing a different segment which defines 6 60* initialization information. In this way the seg_ptr field will either 6 61* be valid or null. 6 62**/ 6 63 6 64 dcl 1 heap_header based, 6 65 2 version char(8), /* specifies the verison of the header */ 6 66 2 heap_name_list_ptr pointer, /* points to the variable_table_header for this heap */ 6 67 2 previous_heap_ptr pointer, /* points to the previous heap or is null */ 6 68 2 area_ptr pointer, /* points to the heap area */ 6 69 2 execution_level fixed bin (17); /* specifies the execution level this header deals with */ 6 70 6 71 dcl heap_header_version_1 char(8) static options (constant) 6 72 init ("Heap_v01"); 6 73 6 74 6 75 /* END INCLUDE FILE ... system_link_names.incl.pl1 */ 1419 1420 1421 end term_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/18/00 1154.2 term_.pl1 >udd>sm>ds>w>ml>term_.pl1 1414 1 11/24/86 1326.9 definition_dcls.incl.pl1 >ldd>incl>definition_dcls.incl.pl1 1415 2 11/24/86 1326.9 object_link_dcls.incl.pl1 >ldd>incl>object_link_dcls.incl.pl1 1416 3 11/26/79 1420.6 its.incl.pl1 >ldd>incl>its.incl.pl1 1417 4 08/05/77 1122.4 lot.incl.pl1 >ldd>incl>lot.incl.pl1 1418 5 11/07/86 1650.3 stack_header.incl.pl1 >ldd>incl>stack_header.incl.pl1 1419 6 11/24/86 1326.9 system_link_names.incl.pl1 >ldd>incl>system_link_names.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. ITS_MODIFIER constant bit(6) initial packed unaligned dcl 3-55 ref 1015 a_code parameter fixed bin(35,0) dcl 57 set ref 27 177 210 243 276 306 338 371 1400* a_dname parameter char packed unaligned dcl 53 set ref 27 165* a_ename parameter char packed unaligned dcl 54 set ref 27 165* a_refname parameter char packed unaligned dcl 55 set ref 177 198* 201* 210 231* 243 265* 267* a_segp parameter pointer dcl 56 set ref 276 295* 306 326* 338 358* 371 386* actual_code 000232 automatic fixed bin(35,0) dcl 880 in procedure "terminate_segno" set ref 890* 894* 899 899* actual_code 000220 automatic fixed bin(35,0) dcl 813 in procedure "terminate_single_refname" set ref 834* 838* 843 843* addwordno builtin function dcl 123 ref 615 1011 1055 1369 based_area based area(1024) dcl 1098 in procedure "free_linkage" ref 1156 1166 based_area based area(1024) dcl 1248 in procedure "free_faulted_linkage" ref 1301 1311 baseptr builtin function dcl 124 ref 1129 1138 bc 000177 automatic fixed bin(24,0) dcl 426 set ref 439* 440 446* block_length 6(18) based fixed bin(18,0) level 3 in structure "lh" packed packed unsigned unaligned dcl 558 in procedure "get_segs" ref 638 670 707 block_length 6(18) based fixed bin(18,0) level 3 in structure "linkage_header" packed packed unsigned unaligned dcl 2-50 in procedure "term_" ref 1285 c 000100 automatic fixed bin(17,0) dcl 938 in procedure "unsnap_links" set ref 1031* 1035 1040 1040 1040 1047 1047 1047* c 000100 automatic fixed bin(17,0) dcl 564 in procedure "get_segs" set ref 682* 683 690 690* char builtin function dcl 125 ref 690 690 cleanup 000104 stack reference condition dcl 118 ref 163 196 229 263 293 324 356 clr_ptr 10 based pointer level 2 dcl 5-26 ref 1166 1311 combined_stat_ptr 6 based pointer level 2 dcl 5-26 ref 1156 1301 component_count 2 based fixed bin(15,0) level 2 unsigned dcl 559 ref 618 682 compp 000102 automatic pointer dcl 565 set ref 690* 691 696 696 702 720 cur_lot_size 13 based fixed bin(17,0) level 2 packed packed unaligned dcl 5-26 ref 1360 def_offset 1 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 933 ref 998 def_ptr based pointer level 2 dcl 558 ref 596 definition_flags based structure level 1 packed packed unaligned dcl 1-42 definition_header based structure level 1 dcl 1-58 defs_in_link 0(30) based bit(6) level 2 packed packed unaligned dcl 933 ref 998 dh based structure level 1 dcl 560 dhp 000104 automatic pointer dcl 566 set ref 596* 613 615 615 dn 000125 automatic char(168) packed unaligned dcl 425 set ref 445* 446* dname parameter char packed unaligned dcl 416 in procedure "initiate_name" set ref 395 430* 439* 445* dname 000106 automatic char(168) packed unaligned dcl 567 in procedure "get_segs" set ref 660* 661* 661 690* dnl 000160 automatic fixed bin(17,0) dcl 568 set ref 660* 661 ec 000221 automatic fixed bin(35,0) dcl 814 in procedure "terminate_single_refname" set ref 819* 820 820* 825* 826 837* 838 838 ec 000124 automatic fixed bin(35,0) dcl 424 in procedure "initiate_name" set ref 430* 434 439* 446* 453 467 469* ec 000206 automatic fixed bin(35,0) dcl 510 in procedure "find_refname" set ref 515* 516* ec 000103 automatic fixed bin(35,0) dcl 114 in procedure "term_" set ref 386* 388* 660* 690* 691* ec 000234 automatic fixed bin(35,0) dcl 882 in procedure "terminate_segno" set ref 893* 894 894 ec parameter fixed bin(35,0) dcl 1398 in procedure "exit" ref 1384 1400 ename parameter char packed unaligned dcl 417 in procedure "initiate_name" set ref 395 430* 439* 445* ename 000161 automatic char(32) packed unaligned dcl 569 in procedure "get_segs" set ref 660* error_table_$dirseg 000054 external static fixed bin(35,0) dcl 92 set ref 434 451* error_table_$invalidsegno 000052 external static fixed bin(35,0) dcl 90 ref 826 error_table_$seg_unknown 000050 external static fixed bin(35,0) dcl 88 set ref 459* 471* error_table_$segknown 000046 external static fixed bin(35,0) dcl 87 ref 453 467 false constant bit(1) initial packed unaligned dcl 49 ref 955 966 1017 1027 1358 fault based bit(2) array level 3 packed packed unaligned dcl 4-16 ref 1367 find_command_$clear 000010 constant entry external dcl 61 ref 166 199 232 296 327 359 first_ref_relp 1(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 933 ref 1002 1002 flags based structure array level 2 in structure "isot1" packed packed unaligned dcl 4-16 in procedure "term_" flags 2 based structure array level 2 in structure "seg" dcl 1096 in procedure "free_linkage" flags 2 based structure array level 2 in structure "seg" dcl 556 in procedure "get_segs" set ref 634* 666* 703* fortran_storage_manager_$free 000012 constant entry external dcl 62 ref 1151 1296 forward_thread based pointer level 2 packed packed unaligned dcl 6-33 ref 1197 found 000101 automatic bit(1) packed unaligned dcl 939 set ref 965* 1017* 1031 1035* 1040* 1047* 1055 get_system_free_area_ 000014 constant entry external dcl 64 ref 578 774 hash_table based pointer array level 2 packed packed unaligned dcl 6-19 ref 1183 1183 1185 hbound builtin function dcl 126 ref 1183 hcs_$fs_get_path_name 000016 constant entry external dcl 65 ref 660 hcs_$fs_get_seg_ptr 000020 constant entry external dcl 67 ref 515 hcs_$get_uid_seg 000022 constant entry external dcl 68 ref 825 hcs_$high_low_seg_count 000024 constant entry external dcl 69 ref 975 hcs_$initiate 000026 constant entry external dcl 70 ref 430 690 hcs_$initiate_count 000030 constant entry external dcl 73 ref 446 hcs_$status_minf 000032 constant entry external dcl 76 ref 439 hcs_$terminate_name 000034 constant entry external dcl 78 ref 819 hcs_$terminate_noname 000036 constant entry external dcl 79 ref 386 458 469 768 hcs_$terminate_seg 000040 constant entry external dcl 80 ref 837 893 hcsc 000102 automatic fixed bin(15,0) dcl 940 set ref 975* 976 977 high_seg 000103 automatic fixed bin(17,0) dcl 941 set ref 977* 981 i 000106 automatic fixed bin(17,0) dcl 1255 in procedure "free_faulted_linkage" set ref 1269* 1270* i 000171 automatic fixed bin(17,0) dcl 570 in procedure "get_segs" set ref 678* 686* 686 702 703 704 705 706 707 710 711 712 719 720 i 000244 automatic fixed bin(17,0) dcl 1102 in procedure "free_linkage" set ref 1183* 1185* init_ptr 6 based pointer level 2 dcl 6-33 set ref 1190 1191 1193* isot based structure level 1 dcl 4-13 isot1 based structure array level 1 dcl 4-16 isot_ptr 52 based pointer level 2 dcl 5-26 ref 1117 1279 1354 isotp 000110 automatic pointer dcl 1256 in procedure "free_faulted_linkage" set ref 1279* 1307 isotp 000246 automatic pointer dcl 1103 in procedure "free_linkage" set ref 1117* 1162 isotp 000100 automatic pointer dcl 1348 in procedure "get_lp" set ref 1354* 1367 1369 1373 isp based pointer array level 2 in structure "isot" packed packed unaligned dcl 4-13 in procedure "term_" set ref 1162* 1307* 1369 1373 isp 000172 automatic pointer dcl 571 in procedure "get_segs" set ref 582* 639 641 642 643 671 673 674 675 696* 708 710 711 712 isp 000104 automatic pointer dcl 942 in procedure "unsnap_links" set ref 985* its_mod 0(30) based bit(6) level 2 packed packed unaligned dcl 3-30 ref 1015 its_unsigned based structure level 1 dcl 3-30 lbound builtin function dcl 127 ref 1183 lh based structure level 1 dcl 558 in procedure "get_segs" lh based structure level 1 dcl 934 in procedure "unsnap_links" lhp 000106 automatic pointer dcl 943 in procedure "unsnap_links" set ref 985* 989 994 1011 lhp 000174 automatic pointer dcl 572 in procedure "get_segs" set ref 582* 584 596 636 637 638 638 643 668 669 670 670 675 696* 697 705 706 707 707 712 link_begin 6 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 933 ref 1007 link_end 4 based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 931 in procedure "unsnap_links" ref 1040 link_end 4 based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 1096 in procedure "free_linkage" ref 1131 link_end 4 based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 556 in procedure "get_segs" set ref 638* 670* 707* link_init based structure level 1 dcl 1-205 link_segno 3 based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 931 in procedure "unsnap_links" ref 1040 link_segno 3 based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 556 in procedure "get_segs" set ref 636* 668* 705* link_segno 3 based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 1096 in procedure "free_linkage" ref 1122 1129 link_start 3(18) based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 1096 in procedure "free_linkage" ref 1130 1131 link_start 3(18) based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 931 in procedure "unsnap_links" ref 1040 link_start 3(18) based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 556 in procedure "get_segs" set ref 637* 669* 706* linkage_header based structure level 1 dcl 2-50 ref 1369 linkage_header_flags based structure level 1 dcl 2-63 linkage_section based bit(36) array dcl 1095 in procedure "free_linkage" ref 1166 linkage_section based bit(36) array packed unaligned dcl 1249 in procedure "free_faulted_linkage" ref 1311 linkage_section_lng 6(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 933 ref 1000 linkl 000250 automatic fixed bin(18,0) dcl 1104 in procedure "free_linkage" set ref 1131* 1166 linkl 000112 automatic fixed bin(18,0) dcl 1257 in procedure "free_faulted_linkage" set ref 1285* 1311 linkp 000252 automatic pointer dcl 1105 in procedure "free_linkage" set ref 1129* 1130* 1130 1139 1151 1151* 1166 linkp parameter pointer dcl 1342 in procedure "get_lp" set ref 1322 1356* 1366* 1369 1369 linkp 000114 automatic pointer dcl 1258 in procedure "free_faulted_linkage" set ref 1283* 1285 1286 1296 1296* 1311 lk based pointer dcl 932 set ref 1024 1025 1055* 1055 lk_end 000110 automatic fixed bin(17,0) dcl 944 set ref 998* 1000* 1002* 1002 1007 lk_segno 000111 automatic fixed bin(18,0) unsigned dcl 945 set ref 1024* 1035 1040 1047 lk_word 000112 automatic fixed bin(18,0) unsigned dcl 946 set ref 1025* 1040 1040 1047 1047 lkp 000114 automatic pointer dcl 947 set ref 1011* 1015 1024 1025 1055 lot based structure level 1 dcl 4-6 lot_fault constant bit(36) initial dcl 4-9 ref 1170 1313 1363 lot_ptr 26 based pointer level 2 dcl 5-26 ref 1116 1278 1353 lotp 000116 automatic pointer dcl 1259 in procedure "free_faulted_linkage" set ref 1278* 1313 lotp 000254 automatic pointer dcl 1106 in procedure "free_linkage" set ref 1116* 1170 lotp 000102 automatic pointer dcl 1349 in procedure "get_lp" set ref 1353* 1363 1363 1366 low_seg 000116 automatic fixed bin(17,0) dcl 948 set ref 976* 981 lp based pointer array level 2 packed packed unaligned dcl 4-6 set ref 1170* 1313* 1363 1363 1366 ltrim builtin function dcl 128 ref 690 690 min builtin function dcl 129 ref 1002 mm based structure level 1 dcl 559 mmp 000176 automatic pointer dcl 573 set ref 615* 616 618 682 683 msf_map based structure level 1 dcl 1-318 msf_map_relp 0(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 560 ref 613 615 msf_map_version_1 000000 constant char(8) initial packed unaligned dcl 1-323 ref 616 my_component 3 based fixed bin(15,0) level 2 unsigned dcl 559 ref 683 name_size 10 based fixed bin(21,0) level 2 dcl 6-33 ref 1194 np 000256 automatic pointer dcl 1107 set ref 1185* 1185* 1190 1191 1193 1194* 1197 nsegs 000117 automatic fixed bin(15,0) dcl 949 set ref 975* 977 null builtin function dcl 130 ref 161 194 227 261 291 322 354 385 451 469 516 584 639 655 671 691 697 708 762 768 840 896 989 1134 1145 1156 1176 1185 1190 1193 1194 1290 1301 1356 1357 offset 000120 automatic fixed bin(17,0) dcl 950 set ref 1007* 1011 1055* original_linkage_ptr 3 based pointer level 2 packed packed unaligned dcl 934 ref 994 pathname_ 000042 constant entry external dcl 81 ref 445 plio2_$close_in_this_static 000044 constant entry external dcl 82 ref 1145 1290 plio2_data_fsb_thread_ 000056 external static pointer initial dcl 94 set ref 1145 1145* 1290 1290* refname parameter char packed unaligned dcl 803 in procedure "terminate_single_refname" set ref 784 819* refname parameter char packed unaligned dcl 504 in procedure "find_refname" set ref 486 515* s 000260 automatic fixed bin(17,0) dcl 1108 in procedure "free_linkage" set ref 1121* 1122 1128 1129 1130 1131 1131 1132 1138 1139 1140 1140 1156* 1190* 1191* s 000222 automatic fixed bin(17,0) dcl 815 in procedure "terminate_single_refname" set ref 836* 837 840* s 000100 automatic fixed bin(17,0) dcl 757 in procedure "clean_up" set ref 767* 768 768* s 000233 automatic fixed bin(17,0) dcl 881 in procedure "terminate_segno" set ref 892* 893 896* sb 000262 automatic pointer dcl 1109 in procedure "free_linkage" set ref 1115* 1116 1117 1156 1166 1174 sb 000104 automatic pointer dcl 1350 in procedure "get_lp" set ref 1352* 1353 1354 1360 sb 000120 automatic pointer dcl 1260 in procedure "free_faulted_linkage" set ref 1276* 1278 1279 1301 1311 seg based structure array level 1 dcl 556 in procedure "get_segs" set ref 590 591* 632 653 654* 719* seg based structure array level 1 dcl 876 in procedure "terminate_segno" seg based structure array level 1 dcl 1096 in procedure "free_linkage" seg based structure array level 1 dcl 809 in procedure "terminate_single_refname" seg based structure array level 1 dcl 931 in procedure "unsnap_links" seg based structure array level 1 dcl 752 in procedure "clean_up" set ref 775 seg_ct parameter fixed bin(17,0) dcl 1243 in procedure "free_faulted_linkage" ref 1208 1269 seg_ct parameter fixed bin(17,0) dcl 1091 in procedure "free_linkage" ref 1071 1121 1190 seg_ct parameter fixed bin(17,0) dcl 552 in procedure "get_segs" set ref 531 589* 590 605* 616* 618* 620* 627 632 653 654 655 seg_ct parameter fixed bin(17,0) dcl 748 in procedure "clean_up" ref 732 767 775 seg_ct parameter fixed bin(17,0) dcl 805 in procedure "terminate_single_refname" set ref 784 832* 836 seg_ct parameter fixed bin(17,0) dcl 927 in procedure "unsnap_links" set ref 909 970* 1031 seg_ct parameter fixed bin(17,0) dcl 506 in procedure "find_refname" set ref 486 522* seg_ct parameter fixed bin(17,0) dcl 419 in procedure "initiate_name" set ref 395 477* seg_ct parameter fixed bin(17,0) dcl 872 in procedure "terminate_segno" set ref 854 886* 892 seg_fault_error 000000 stack reference condition dcl 119 ref 598 622 957 seg_no 000121 automatic fixed bin(18,0) dcl 951 in procedure "unsnap_links" set ref 970* 981* 985* seg_no parameter fixed bin(18,0) dcl 1244 in procedure "free_faulted_linkage" set ref 1208 1270 1283* 1307 1313 seg_no 000264 automatic fixed bin(18,0) unsigned dcl 1110 in procedure "free_linkage" set ref 1128* 1162 1170 seg_ptr based pointer level 2 dcl 6-33 set ref 1194* seg_tempp 000200 automatic pointer dcl 574 set ref 653* 654 655 656 segment based structure array level 1 dcl 98 segment_count 000102 automatic fixed bin(17,0) dcl 113 set ref 163* 165* 167* 168* 196* 198* 200* 201* 229* 231* 233* 234* 263* 265* 266* 267* 293* 295* 297* 324* 326* 328* 329* 356* 358* 360* 361* 1405* segno builtin function dcl 131 in procedure "term_" ref 582 582 636 641 668 673 696 696 705 710 1024 1035 1128 1191 1191 1270 segno parameter fixed bin(18,0) dcl 1341 in procedure "get_lp" ref 1322 1360 1363 1363 1366 1367 1369 1373 segp 000210 automatic pointer dcl 511 in procedure "find_refname" set ref 515* 516 522* segp 000122 automatic pointer dcl 423 in procedure "initiate_name" set ref 430* 446* 451 458* 469 469* 477* segp parameter pointer dcl 550 in procedure "get_segs" set ref 531 582 582 592 633 660* 665 segs based structure array level 1 dcl 1250 segsp 000100 automatic pointer dcl 112 in procedure "term_" set ref 161* 163* 165* 167* 168* 194* 196* 198* 200* 201* 227* 229* 231* 233* 234* 261* 263* 265* 266* 267* 291* 293* 295* 297* 322* 324* 326* 328* 329* 354* 356* 358* 360* 361* 385* 1405* segsp parameter pointer dcl 871 in procedure "terminate_segno" set ref 854 886* 893 896 segsp parameter pointer dcl 551 in procedure "get_segs" set ref 531 590* 591 592 632* 633 634 635 636 637 638 641 642 643 656* 665 666 667 668 669 670 673 674 675 702 703 704 705 706 707 710 711 712 719 720 segsp parameter pointer dcl 1242 in procedure "free_faulted_linkage" ref 1208 1270 segsp parameter pointer dcl 505 in procedure "find_refname" set ref 486 522* segsp parameter pointer dcl 418 in procedure "initiate_name" set ref 395 477* segsp parameter pointer dcl 926 in procedure "unsnap_links" set ref 909 970* 1035 1040 1040 1040 1047 1047 1047 segsp parameter pointer dcl 804 in procedure "terminate_single_refname" set ref 784 825 832* 837 840 segsp parameter pointer dcl 1090 in procedure "free_linkage" ref 1071 1122 1128 1129 1130 1131 1131 1132 1138 1139 1140 1140 1156 1191 segsp parameter pointer dcl 747 in procedure "clean_up" ref 732 762 768 768 775 sep_stat parameter bit(1) packed unaligned dcl 1344 set ref 1322 1358* 1367* 1372* separate_static 2 based bit(1) array level 3 in structure "seg" packed packed unaligned dcl 556 in procedure "get_segs" set ref 635* 667* 704* separate_static 2 based bit(1) array level 3 in structure "seg" packed packed unaligned dcl 1096 in procedure "free_linkage" ref 1156 setwordno builtin function dcl 132 ref 1130 1139 size builtin function dcl 133 ref 1369 ss 000122 automatic bit(1) packed unaligned dcl 1261 in procedure "free_faulted_linkage" set ref 1283* 1301 ss 000202 automatic bit(1) packed unaligned dcl 575 in procedure "get_segs" set ref 582* 635 667 696* 704 stack_header based structure level 1 dcl 5-26 stackbaseptr builtin function dcl 134 ref 1115 1276 1352 stat_end 5(18) based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 556 in procedure "get_segs" set ref 643* 675* 712* stat_end 5(18) based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 931 in procedure "unsnap_links" ref 1047 stat_end 5(18) based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 1096 in procedure "free_linkage" ref 1140 stat_segno 4(18) based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 1096 in procedure "free_linkage" ref 1132 1138 stat_segno 4(18) based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 931 in procedure "unsnap_links" ref 1047 stat_segno 4(18) based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 556 in procedure "get_segs" set ref 641* 673* 710* stat_start 5 based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 931 in procedure "unsnap_links" ref 1047 stat_start 5 based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 1096 in procedure "free_linkage" ref 1139 1140 stat_start 5 based fixed bin(18,0) array level 2 in structure "seg" packed packed unsigned unaligned dcl 556 in procedure "get_segs" set ref 642* 674* 711* static_length 7(18) based fixed bin(18,0) level 3 in structure "lh" packed packed unsigned unaligned dcl 558 in procedure "get_segs" ref 643 675 712 static_length 7(18) based fixed bin(18,0) level 3 in structure "linkage_header" packed packed unsigned unaligned dcl 2-50 in procedure "term_" ref 1286 static_section based bit(36) array packed unaligned dcl 1251 in procedure "free_faulted_linkage" ref 1301 static_section based bit(36) array dcl 1097 in procedure "free_linkage" ref 1156 static_vlas 0(28) based bit(1) level 2 packed packed unaligned dcl 2-63 ref 1151 1296 statl 000265 automatic fixed bin(18,0) dcl 1111 in procedure "free_linkage" set ref 1135* 1140* 1145* 1156 statl 000123 automatic fixed bin(18,0) dcl 1262 in procedure "free_faulted_linkage" set ref 1286* 1290* 1301 statp parameter pointer dcl 1343 in procedure "get_lp" set ref 1322 1357* 1369* 1373* statp 000124 automatic pointer dcl 1263 in procedure "free_faulted_linkage" set ref 1283* 1290* 1301 1301 statp 000266 automatic pointer dcl 1112 in procedure "free_linkage" set ref 1134* 1138* 1139* 1145* 1156 1156 stats 6 based structure level 2 in structure "linkage_header" dcl 2-50 in procedure "term_" stats 6 based structure level 2 in structure "lh" dcl 558 in procedure "get_segs" string builtin function dcl 135 set ref 634* 666* 703* substr builtin function dcl 136 ref 661 sys_area based area(1024) dcl 753 in procedure "clean_up" ref 775 sys_area based area(1024) dcl 557 in procedure "get_segs" ref 590 632 653 sys_areap 000204 automatic pointer dcl 576 in procedure "get_segs" set ref 578* 590 632 653 sys_areap 000102 automatic pointer dcl 758 in procedure "clean_up" set ref 774* 775 sys_infop 000270 automatic pointer dcl 1113 set ref 1174* 1176 1183 1183 1185 sys_link_info_ptr 60 based pointer level 2 dcl 5-26 ref 1174 textp based pointer array level 2 in structure "seg" dcl 931 in procedure "unsnap_links" ref 1035 textp based pointer array level 2 in structure "seg" dcl 1096 in procedure "free_linkage" ref 1128 1191 textp based pointer array level 2 in structure "seg" dcl 556 in procedure "get_segs" set ref 592* 633* 655* 665* 702* 720* textp based pointer array level 2 in structure "seg" dcl 876 in procedure "terminate_segno" set ref 893* 896* textp based pointer array level 2 in structure "seg" dcl 809 in procedure "terminate_single_refname" set ref 825* 837* 840* textp based pointer array level 2 in structure "segs" dcl 1250 in procedure "free_faulted_linkage" ref 1270 textp based pointer array level 2 in structure "seg" dcl 752 in procedure "clean_up" set ref 768 768* trap_errors 000122 automatic bit(1) packed unaligned dcl 952 set ref 955* 963 966* 1022* 1027* true constant bit(1) initial packed unaligned dcl 48 ref 965 1022 1035 1040 1047 1367 1372 unspec builtin function dcl 137 set ref 591* 654* 719* 1055* 1055 1162* 1170* 1307* 1313* 1363 1363 variable_node based structure level 1 dcl 6-33 variable_table_header based structure level 1 dcl 6-19 version based char(8) level 2 dcl 559 ref 616 virgin_linkage_header based structure level 1 dcl 2-71 vlh based structure level 1 dcl 933 vlhp 000124 automatic pointer dcl 953 set ref 994* 998 998 1000 1002 1002 1007 1055 wordno builtin function dcl 138 ref 637 638 642 643 669 670 674 675 706 707 711 712 1025 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. CLASS_HEAP internal static fixed bin(3,0) initial unsigned dcl 1-25 CLASS_LINKAGE internal static fixed bin(3,0) initial unsigned dcl 1-25 CLASS_NAMES internal static char(12) initial array packed unaligned dcl 1-35 CLASS_SEGNAME internal static fixed bin(3,0) initial unsigned dcl 1-25 CLASS_STATIC internal static fixed bin(3,0) initial unsigned dcl 1-25 CLASS_SYMBOL internal static fixed bin(3,0) initial unsigned dcl 1-25 CLASS_SYSTEM internal static fixed bin(3,0) initial unsigned dcl 1-25 CLASS_TEXT internal static fixed bin(3,0) initial unsigned dcl 1-25 FAULT_TAG_1 internal static bit(6) initial packed unaligned dcl 2-100 FAULT_TAG_2 internal static bit(6) initial packed unaligned dcl 2-101 FAULT_TAG_3 internal static bit(6) initial packed unaligned dcl 2-102 FR_TRAPS_VERSION_1 internal static fixed bin(17,0) initial dcl 2-99 INIT_COPY_INFO internal static fixed bin(17,0) initial dcl 1-194 INIT_DEFERRED internal static fixed bin(17,0) initial dcl 1-194 INIT_DEFINE_AREA internal static fixed bin(17,0) initial dcl 1-194 INIT_LIST_TEMPLATE internal static fixed bin(17,0) initial dcl 1-194 INIT_NO_INIT internal static fixed bin(17,0) initial dcl 1-194 ITP_MODIFIER internal static bit(6) initial packed unaligned dcl 3-56 LINK_CREATE_IF_NOT_FOUND internal static fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 LINK_OBSOLETE_2 internal static fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 LINK_REFNAME_BASE internal static fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 LINK_REFNAME_OFFSETNAME internal static fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 LINK_SELF_BASE internal static fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 LINK_SELF_OFFSETNAME internal static fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 LINK_TYPE_NAMES internal static varying char(32) initial array dcl 1-153 SECTION_HEAP internal static fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 SECTION_LINK internal static fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 SECTION_STATIC internal static fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 SECTION_SYMBOL internal static fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 SECTION_SYSTEM internal static fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 SECTION_TEXT internal static fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 SECTION_UNUSED internal static fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 SYMBOLIC_SECTION_NAMES internal static char(8) initial array packed unaligned dcl 1-38 acc_string based structure level 1 dcl 1-327 acc_string_length automatic fixed bin(21,0) dcl 1-334 acc_string_ptr automatic pointer dcl 1-326 call_offset internal static fixed bin(17,0) initial dcl 5-78 comp_ht_n_entries automatic fixed bin(17,0) dcl 1-297 comp_ht_ptr automatic pointer dcl 1-288 component_ht based structure level 1 dcl 1-289 def_header_ptr automatic pointer dcl 1-57 def_ht_n_entries automatic fixed bin(17,0) dcl 1-284 def_ht_ptr automatic pointer dcl 1-277 def_ptr automatic pointer dcl 1-71 definition based structure level 1 dcl 1-72 definition_ht based structure level 1 dcl 1-278 dup_table_n_names automatic fixed bin(17,0) dcl 1-310 dup_table_ptr automatic pointer dcl 1-301 duplicate_table based structure level 1 dcl 1-302 entry_offset internal static fixed bin(17,0) initial dcl 5-78 exp_ptr automatic pointer dcl 1-128 exp_word based structure level 1 dcl 1-129 fr_traps based structure level 1 dcl 2-90 heap_header based structure level 1 unaligned dcl 6-64 heap_header_version_1 internal static char(8) initial packed unaligned dcl 6-71 isotp automatic pointer dcl 4-12 itp based structure level 1 dcl 3-18 itp_unsigned based structure level 1 dcl 3-43 its based structure level 1 dcl 3-5 link_init_copy_info based structure level 1 dcl 1-211 link_init_deferred based structure level 1 dcl 1-270 link_init_list_template based structure level 1 dcl 1-219 link_init_n_bits_in_datum automatic fixed bin(35,0) dcl 1-261 link_init_n_words automatic fixed bin(17,0) dcl 1-215 link_init_n_words_in_list automatic fixed bin(17,0) dcl 1-226 link_init_ptr automatic pointer dcl 1-204 link_trap_pair based structure level 1 dcl 1-177 link_trap_ptr automatic pointer dcl 1-176 list_template_entry based structure level 1 dcl 1-239 lotp automatic pointer dcl 4-4 msf_map_ptr automatic pointer dcl 1-317 object_link based structure level 1 dcl 2-28 partial_link based structure level 1 dcl 2-38 pointer_init_template based structure level 1 packed packed unaligned dcl 1-253 push_offset internal static fixed bin(17,0) initial dcl 5-78 return_no_pop_offset internal static fixed bin(17,0) initial dcl 5-78 return_offset internal static fixed bin(17,0) initial dcl 5-78 sb automatic pointer dcl 5-24 segname_definition based structure level 1 dcl 1-90 segname_ptr automatic pointer dcl 1-89 stack_header_overlay based fixed bin(17,0) array dcl 5-94 tv_offset internal static fixed bin(17,0) initial dcl 5-72 type_pair based structure level 1 dcl 1-160 type_ptr automatic pointer dcl 1-159 NAMES DECLARED BY EXPLICIT CONTEXT. EXIT 001163 constant label dcl 1405 ref 1401 SKIP 001743 constant label dcl 622 in procedure "get_segs" ref 606 SKIP 003331 constant label dcl 1061 in procedure "unsnap_links" ref 971 UNSNAP 003314 constant label dcl 1055 ref 967 clean_up 002467 constant entry internal dcl 732 ref 163 196 229 263 293 324 356 1405 exit 004041 constant entry internal dcl 1384 ref 170 203 236 269 299 331 363 388 451 459 471 516 691 820 843 899 find_refname 001517 constant entry internal dcl 486 ref 198 231 265 free_faulted_linkage 003617 constant entry internal dcl 1208 ref 970 free_linkage 003334 constant entry internal dcl 1071 ref 329 832 886 get_lp 003755 constant entry internal dcl 1322 ref 582 696 985 1283 get_segs 001602 constant entry internal dcl 531 ref 295 326 358 477 522 initiate_name 001174 constant entry internal dcl 395 ref 165 no_clear 000455 constant entry external dcl 243 no_name 001131 constant entry external dcl 371 nomakeunknown 000717 constant entry external dcl 306 refname 000333 constant entry external dcl 210 seg_ptr 001024 constant entry external dcl 338 single_refname 000171 constant entry external dcl 177 term_ 000034 constant entry external dcl 27 terminate_segno 002727 constant entry internal dcl 854 ref 168 234 361 terminate_single_refname 002554 constant entry internal dcl 784 ref 201 267 unsnap 000614 constant entry external dcl 276 unsnap_links 003022 constant entry internal dcl 909 ref 167 200 233 266 297 328 360 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 4550 4630 4066 4560 Length 5206 4066 60 342 462 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME term_ 296 external procedure is an external procedure. on unit on line 163 72 on unit on unit on line 196 72 on unit on unit on line 229 72 on unit on unit on line 263 72 on unit on unit on line 293 72 on unit on unit on line 324 72 on unit on unit on line 356 72 on unit initiate_name internal procedure shares stack frame of external procedure term_. find_refname internal procedure shares stack frame of external procedure term_. get_segs 218 internal procedure enables or reverts conditions. on unit on line 598 64 on unit clean_up 78 internal procedure is called by several nonquick procedures. terminate_single_refname internal procedure shares stack frame of external procedure term_. terminate_segno internal procedure shares stack frame of external procedure term_. unsnap_links 114 internal procedure enables or reverts conditions. on unit on line 957 110 on unit free_linkage internal procedure shares stack frame of external procedure term_. free_faulted_linkage internal procedure shares stack frame of on unit on line 957. get_lp 70 internal procedure is called by several nonquick procedures. exit 64 internal procedure is called by several nonquick procedures. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME clean_up 000100 s clean_up 000102 sys_areap clean_up get_lp 000100 isotp get_lp 000102 lotp get_lp 000104 sb get_lp get_segs 000100 c get_segs 000102 compp get_segs 000104 dhp get_segs 000106 dname get_segs 000160 dnl get_segs 000161 ename get_segs 000171 i get_segs 000172 isp get_segs 000174 lhp get_segs 000176 mmp get_segs 000200 seg_tempp get_segs 000202 ss get_segs 000204 sys_areap get_segs on unit on line 957 000106 i free_faulted_linkage 000110 isotp free_faulted_linkage 000112 linkl free_faulted_linkage 000114 linkp free_faulted_linkage 000116 lotp free_faulted_linkage 000120 sb free_faulted_linkage 000122 ss free_faulted_linkage 000123 statl free_faulted_linkage 000124 statp free_faulted_linkage term_ 000100 segsp term_ 000102 segment_count term_ 000103 ec term_ 000122 segp initiate_name 000124 ec initiate_name 000125 dn initiate_name 000177 bc initiate_name 000206 ec find_refname 000210 segp find_refname 000220 actual_code terminate_single_refname 000221 ec terminate_single_refname 000222 s terminate_single_refname 000232 actual_code terminate_segno 000233 s terminate_segno 000234 ec terminate_segno 000244 i free_linkage 000246 isotp free_linkage 000250 linkl free_linkage 000252 linkp free_linkage 000254 lotp free_linkage 000256 np free_linkage 000260 s free_linkage 000262 sb free_linkage 000264 seg_no free_linkage 000265 statl free_linkage 000266 statp free_linkage 000270 sys_infop free_linkage unsnap_links 000100 c unsnap_links 000101 found unsnap_links 000102 hcsc unsnap_links 000103 high_seg unsnap_links 000104 isp unsnap_links 000106 lhp unsnap_links 000110 lk_end unsnap_links 000111 lk_segno unsnap_links 000112 lk_word unsnap_links 000114 lkp unsnap_links 000116 low_seg unsnap_links 000117 nsegs unsnap_links 000120 offset unsnap_links 000121 seg_no unsnap_links 000122 trap_errors unsnap_links 000124 vlhp unsnap_links THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_char_temp unpk_to_pk call_ext_out_desc call_ext_out call_int_this call_int_other return_mac tra_ext_1 enable_op shorten_stack ext_entry ext_entry_desc int_entry op_alloc_ op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. find_command_$clear fortran_storage_manager_$free get_system_free_area_ hcs_$fs_get_path_name hcs_$fs_get_seg_ptr hcs_$get_uid_seg hcs_$high_low_seg_count hcs_$initiate hcs_$initiate_count hcs_$status_minf hcs_$terminate_name hcs_$terminate_noname hcs_$terminate_seg pathname_ plio2_$close_in_this_static THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$dirseg error_table_$invalidsegno error_table_$seg_unknown error_table_$segknown plio2_data_fsb_thread_ LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 27 000030 161 000057 163 000061 165 000110 166 000136 167 000143 168 000153 170 000155 177 000164 194 000207 196 000211 198 000240 199 000262 200 000267 201 000277 203 000321 210 000330 227 000351 229 000353 231 000402 232 000424 233 000431 234 000441 236 000443 243 000452 261 000473 263 000475 265 000524 266 000546 267 000556 269 000600 276 000607 291 000624 293 000626 295 000655 296 000670 297 000675 299 000705 306 000714 322 000727 324 000731 326 000760 327 000773 328 001000 329 001010 331 001012 338 001021 354 001034 356 001036 358 001065 359 001100 360 001105 361 001115 363 001117 371 001126 385 001141 386 001143 388 001155 1405 001163 1407 001173 395 001174 430 001212 434 001257 439 001263 440 001324 445 001326 446 001351 451 001415 453 001431 458 001435 459 001446 462 001455 467 001456 469 001460 471 001474 477 001503 479 001516 486 001517 515 001530 516 001553 522 001565 524 001600 531 001601 578 001607 582 001615 584 001641 589 001645 590 001650 591 001660 592 001663 593 001666 596 001667 598 001672 605 001706 606 001712 613 001715 615 001721 616 001724 618 001734 619 001737 620 001740 622 001743 627 001744 632 001750 633 001760 634 001763 635 001766 636 001772 637 001777 638 002002 639 002012 641 002016 642 002022 643 002027 645 002033 653 002034 654 002043 655 002054 656 002071 660 002072 661 002124 665 002130 666 002135 667 002140 668 002144 669 002151 670 002154 671 002164 673 002170 674 002174 675 002201 678 002205 682 002207 683 002217 686 002222 690 002223 691 002317 696 002334 697 002355 702 002361 703 002370 704 002373 705 002377 706 002406 707 002412 708 002423 710 002427 711 002434 712 002442 714 002447 719 002450 720 002461 723 002463 725 002465 732 002466 762 002474 767 002501 768 002511 770 002535 774 002537 775 002546 777 002553 784 002554 819 002565 820 002604 825 002614 826 002633 832 002637 834 002650 836 002651 837 002661 838 002702 840 002706 841 002714 843 002716 847 002726 854 002727 886 002731 890 002742 892 002743 893 002753 894 002774 896 003000 897 003006 899 003010 902 003020 909 003021 955 003027 957 003030 963 003044 965 003047 966 003051 967 003052 970 003055 971 003070 975 003073 976 003104 977 003107 981 003112 985 003121 989 003140 994 003144 998 003147 1000 003157 1002 003162 1007 003172 1011 003203 1015 003206 1017 003212 1022 003213 1024 003215 1025 003221 1027 003224 1031 003225 1035 003237 1040 003254 1047 003274 1051 003312 1055 003314 1059 003326 1061 003331 1064 003333 1071 003334 1115 003336 1116 003340 1117 003342 1121 003344 1122 003353 1128 003363 1129 003371 1130 003375 1131 003401 1132 003407 1134 003413 1135 003415 1136 003416 1138 003417 1139 003422 1140 003427 1145 003436 1151 003455 1156 003467 1162 003504 1166 003506 1170 003511 1172 003514 1174 003516 1176 003521 1183 003525 1185 003531 1190 003540 1191 003556 1193 003574 1194 003576 1196 003607 1197 003611 1198 003614 1201 003616 1208 003617 1269 003621 1270 003631 1272 003643 1276 003645 1278 003647 1279 003651 1283 003653 1285 003671 1286 003675 1290 003700 1296 003717 1301 003731 1307 003742 1311 003745 1313 003747 1315 003753 1322 003754 1352 003762 1353 003764 1354 003766 1356 003770 1357 003773 1358 003774 1360 004000 1363 004004 1366 004011 1367 004013 1369 004023 1372 004032 1373 004035 1377 004037 1384 004040 1400 004046 1401 004052 ----------------------------------------------------------- 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