COMPILATION LISTING OF SEGMENT link_snap Compiled by: Multics PL/I Compiler, Release 32f, of October 9, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 11/11/89 1045.0 mst Sat Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1986 * 6* * * 7* *********************************************************** */ 8 9 10 11 12 /****^ HISTORY COMMENTS: 13* 1) change(86-05-02,Elhard), approve(86-05-02,MCR7391), 14* audit(86-07-18,DGHowe), install(86-11-20,MR12.0-1222): 15* Rewritten to support object multisegment files. In particular, support 16* of indirect definitions, deferred initialization, partial links, and 17* preliminary support for *heap links. 18* 2) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), 19* audit(86-11-05,Elhard), install(86-11-20,MR12.0-1222): 20* added a check for heap links and a call to set_ext_variable_$star_heap 21* when a heap link is found. 22* 3) change(86-06-24,DGHowe), approve(86-06-24,MCR7420), 23* audit(86-11-05,Elhard), install(86-11-20,MR12.0-1222): 24* added a segment pointer to the calling sequences of for_linker and 25* star_heap for ext pointer initialization. 26* 4) change(87-06-10,Elhard), approve(87-07-17,MCR7739), 27* audit(87-06-10,RWaters), install(87-07-17,MR12.1-1043): 28* Critical fix to correct snapping of CREATE_IF_NOT_FOUND (type 6) links to 29* targets with no offset name, or nonexistent targets. 30* END HISTORY COMMENTS */ 31 32 33 /* format: style1,insnl,ifthendo,indthenelse,^indnoniterdo,^inditerdo,indcom,^indthenbegin,^indprocbody,ind2,ll79,initcol0,dclind4,idind24,struclvlind1,comcol41 */ 34 35 link_snap: 36 proc; 37 38 /*** ****************************************************************/ 39 /*** */ 40 /*** Name: link_snap */ 41 /*** Input: none */ 42 /*** Function: This procedure implements the Multics dynamic */ 43 /*** linking mechanism. Four entries exist in this */ 44 /*** procedure: */ 45 /*** link_snap$link_fault - This entry is called as */ 46 /*** due to a fault_tag_2 */ 47 /*** (linkage) fault. */ 48 /*** link_snap$link_force - This entry corresponds */ 49 /*** to the hcs_$link_force */ 50 /*** gate entry. It basicly */ 51 /*** duplicates the action of */ 52 /*** a link_fault without */ 53 /*** taking a fault. */ 54 /*** link_snap$make_ptr - This entry corresponds */ 55 /*** to the hcs_$make_ptr */ 56 /*** gate entry. It simulates */ 57 /*** a type-3 or type-4 link */ 58 /*** fault and returns the */ 59 /*** target as a pointer. */ 60 /*** link_snap$make_entry - This entry corresponds */ 61 /*** to the hcs_$make_entry */ 62 /*** gate entry. It simulates */ 63 /*** a type-3 or type-4 link */ 64 /*** fault and returns the */ 65 /*** target as an entry value */ 66 /*** */ 67 /*** ****************************************************************/ 68 69 /* constants */ 70 71 dcl true bit (1) static options (constant) init ("1"b); 72 dcl false bit (1) static options (constant) init ("0"b); 73 74 dcl indirect bit (6) static options (constant) init ("20"b3); 75 76 dcl Link_fault fixed bin static options (constant) init (1); 77 dcl Link_force fixed bin static options (constant) init (2); 78 dcl Make_ptr fixed bin static options (constant) init (3); 79 dcl Make_entry fixed bin static options (constant) init (4); 80 81 dcl No_retry bit (1) static options (constant) init ("0"b); 82 dcl Will_retry bit (1) static options (constant) init ("1"b); 83 84 dcl zero_word bit (36) static options (constant) init (""b); 85 86 dcl None fixed bin (18) unsigned unaligned 87 static options (constant) init (0); 88 89 /* parameters */ 90 91 dcl a_mcp ptr parameter; 92 dcl a_link_pairp ptr parameter; 93 dcl a_dummy fixed bin parameter; 94 dcl a_code fixed bin (35) parameter; 95 dcl a_refp ptr parameter; 96 dcl a_seg_name char (*) parameter; 97 dcl a_offset_name char (*) parameter; 98 dcl a_targetp ptr parameter; 99 dcl a_targete entry parameter; 100 101 /* procedures */ 102 103 dcl condition_ entry (char (*), entry); 104 dcl fs_search entry (ptr, char (*), bit (1) aligned, ptr, 105 fixed bin (35)); 106 dcl fs_search$same_directory 107 entry (ptr, char (*), ptr, fixed bin (35)); 108 dcl get_defptr_ entry (ptr, ptr, ptr, ptr, fixed bin (35)); 109 dcl level$get entry () returns (fixed bin (3)); 110 dcl level$set entry (fixed bin (3)); 111 dcl link_man$other_linkage entry (ptr, ptr, ptr, ptr, fixed bin (35)); 112 dcl link_man$own_linkage entry (ptr, ptr, ptr, ptr, fixed bin (35)); 113 dcl page$enter_data entry (ptr unal, fixed bin); 114 dcl set_ext_variable_$for_linker 115 entry (char (*), ptr, ptr, ptr, bit (1) aligned, 116 ptr, fixed bin (35), ptr, ptr, ptr, ptr); 117 dcl set_ext_variable_$star_heap 118 entry (char (*), ptr, ptr, ptr, bit (1) aligned, 119 ptr, fixed bin (35)); 120 dcl trap_caller_caller_ entry (ptr, ptr, ptr, ptr, ptr, ptr, 121 fixed bin (35)); 122 dcl usage_values entry (fixed bin (30) aligned, 123 fixed bin (71) aligned); 124 125 /* external */ 126 127 dcl 01 ahd$link_meters (4) aligned external like link_meters; 128 dcl error_table_$bad_class_def 129 external fixed bin (35); 130 dcl error_table_$bad_deferred_init 131 external fixed bin (35); 132 dcl error_table_$bad_indirect_def 133 external fixed bin (35); 134 dcl error_table_$bad_link_type 135 external fixed bin (35); 136 dcl error_table_$bad_self_ref 137 external fixed bin (35); 138 dcl error_table_$first_reference_trap 139 external fixed bin (35); 140 dcl error_table_$illegal_ft2 141 external fixed bin (35); 142 dcl error_table_$no_defs external fixed bin (35); 143 dcl error_table_$no_ext_sym external fixed bin (35); 144 dcl error_table_$no_linkage external fixed bin (35); 145 dcl error_table_$unexpected_ft2 146 external fixed bin (35); 147 dcl pds$link_meters_bins (4) external fixed bin (30); 148 dcl pds$link_meters_pgwaits (4) external fixed bin (30); 149 dcl pds$link_meters_times (4) external fixed bin (35); 150 dcl pds$stacks (0:7) external ptr; 151 152 /* based */ 153 154 dcl 01 based_entry aligned based, 155 02 code_ptr ptr, 156 02 env_ptr ptr; 157 dcl 01 expr aligned like exp_word based (exprp); 158 dcl 01 link_pair aligned like object_link based (link_pairp); 159 dcl 01 offsetname aligned based (offsetnamep), 160 02 count fixed bin (9) unsigned unaligned, 161 02 string char (offsetname.count) unaligned; 162 dcl 01 segname aligned based (segnamep), 163 02 count fixed bin (9) unsigned unaligned, 164 02 string char (segname.count) unaligned; 165 dcl 01 type_pr aligned like type_pair based (type_prp); 166 dcl 01 usage aligned based, 167 02 time fixed bin (71), 168 02 pf fixed bin (30); 169 170 /* automatic */ 171 172 dcl 01 automatic_offsetname aligned automatic, 173 02 count fixed bin (9) unsigned unaligned, 174 02 string char (256) unaligned; 175 dcl 01 automatic_segname aligned automatic, 176 02 count fixed bin (9) unsigned unaligned, 177 02 string char (32) unaligned; 178 dcl 01 call_info aligned automatic, 179 02 type fixed bin, 180 02 save_ring fixed bin, 181 02 mcp ptr, 182 02 codep ptr, 183 02 start aligned like usage, 184 02 finish aligned like usage, 185 02 search aligned like usage, 186 02 get_linkage aligned like usage, 187 02 def_search aligned like usage; 188 dcl call_infop ptr automatic; 189 dcl code fixed bin (35) automatic; 190 dcl connect_fail_code fixed bin (35) automatic; 191 dcl defp ptr automatic; 192 dcl exprp ptr automatic; 193 dcl init_infop ptr automatic; 194 dcl instrp ptr automatic; 195 dcl link_pairp ptr automatic; 196 dcl linkp ptr automatic; 197 dcl nchars fixed bin automatic; 198 dcl offset_name char (256) automatic; 199 dcl offsetnamep ptr automatic; 200 dcl refp ptr automatic; 201 dcl retry_sw bit (1) automatic; 202 dcl seg_name char (32) automatic; 203 dcl segnamep ptr automatic; 204 dcl segp ptr automatic; 205 dcl star_system_sw bit (1) automatic; 206 dcl target_linkagep ptr automatic; 207 dcl targetp ptr automatic; 208 dcl textp ptr automatic; 209 dcl type_prp ptr automatic; 210 dcl MSF_sw bit (1) aligned automatic; 211 212 /* builtin */ 213 214 dcl addr builtin; 215 dcl addrel builtin; 216 dcl baseno builtin; 217 dcl baseptr builtin; 218 dcl bin builtin; 219 dcl char builtin; 220 dcl divide builtin; 221 dcl index builtin; 222 dcl length builtin; 223 dcl ltrim builtin; 224 dcl max builtin; 225 dcl min builtin; 226 dcl null builtin; 227 dcl ptr builtin; 228 dcl rtrim builtin; 229 dcl substr builtin; 230 dcl unspec builtin; 231 232 return; 233 234 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 235 236 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 237 238 239 link_fault: 240 entry (a_mcp); /** machine conditions (i/o) */ 241 242 /*** ****************************************************************/ 243 /*** */ 244 /*** Name: link_snap$link_fault */ 245 /*** Input: mcp */ 246 /*** Function: handles a fault_tag_2 (linkage) fault. The mcp */ 247 /*** pointer points to the machine conditions at the */ 248 /*** time of the fault. If the link snapping is */ 249 /*** successfull, the machine conditions will be */ 250 /*** adjusted to allow the fault to be restarted. */ 251 /*** Output: mcp */ 252 /*** */ 253 /*** ****************************************************************/ 254 255 /* copy the parameters into automatic storage */ 256 257 mcp = a_mcp; 258 259 call_infop = addr (call_info); 260 call_info.type = Link_fault; 261 call_info.mcp = mcp; 262 call_info.save_ring = level$get (); 263 264 /* since this is a fault, the trap routines can't set a return code */ 265 266 call_info.codep = null; 267 268 /* set validation level to the level that the fault occurred at */ 269 270 scup = addr (mc.scu (0)); 271 call level$set (bin (scu.ppr.prr, 3)); 272 273 /* get a pointer to the faulting link pair and instruction */ 274 275 link_pairp = ptr (baseptr (bin (scu.tpr.tsr, 15)), scu.ca); 276 instrp = ptr (baseptr (bin (scu.ppr.psr, 15)), scu.ilc); 277 278 /* trace the fault */ 279 280 call page$enter_data ((instrp), linkage_fault_start); 281 282 /* make sure the fault_tag_2 wasn't in an instruction */ 283 284 if instrp -> its.its_mod = FAULT_TAG_2 285 then call exit (call_infop, error_table_$unexpected_ft2, null); 286 287 goto link_join; 288 289 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 290 291 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 292 293 294 link_force: 295 entry (a_link_pairp, /** ptr to link to snap (in ) */ 296 a_dummy, /** unused (---) */ 297 a_code); /** error code (out) */ 298 299 /*** ****************************************************************/ 300 /*** */ 301 /*** Name: link_snap$link_force */ 302 /*** Input: link_pairp */ 303 /*** Function: given a pointer to a link, snap it without taking */ 304 /*** a fault. This entry is functionally the same as */ 305 /*** link_snap$link_fault except that it is entered */ 306 /*** via gate call rather than fault entry. */ 307 /*** Output: code */ 308 /*** */ 309 /*** ****************************************************************/ 310 311 /* not a fault entry */ 312 313 mcp = null; 314 315 /* copy parameters into automatic storage */ 316 317 link_pairp = a_link_pairp; 318 319 /* set up call info */ 320 321 call_infop = addr (call_info); 322 call_info.type = Link_force; 323 call_info.mcp = null; 324 call_info.save_ring = -1; 325 326 /* save error code address in case we trap out to the user ring and */ 327 /* the trap procedure needs to set the error code. */ 328 329 call_info.codep = addr (a_code); 330 331 /* for a link_force call, we use the link itself as the start point */ 332 /* for tracing purposes. */ 333 334 call page$enter_data ((link_pairp), linkage_fault_start); 335 336 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 337 338 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 339 340 341 link_join: 342 343 /* clear out the metering information */ 344 345 call_info.search.time = 0; 346 call_info.search.pf = 0; 347 call_info.get_linkage.time = 0; 348 call_info.get_linkage.pf = 0; 349 call_info.def_search.time = 0; 350 call_info.def_search.pf = 0; 351 352 /* meter the fault time etc. */ 353 354 call usage_values (call_info.start.pf, call_info.start.time); 355 356 if link_pair.tag ^= FAULT_TAG_2 357 then if call_info.type = Link_force 358 then call exit (call_infop, 0, baseptr (0)); 359 else call exit (call_infop, error_table_$illegal_ft2, null); 360 361 /* get the linkage section and text pointers */ 362 363 linkp = addrel (link_pairp, link_pair.header_relp); 364 textp = baseptr (linkp -> linkage_header.stats.segment_number); 365 target_linkagep = null; 366 367 /* validate the definition pointer */ 368 369 if addr (linkp -> linkage_header.def_ptr) -> its.its_mod ^= ITS_MODIFIER 370 then call exit (call_infop, error_table_$no_defs, null); 371 else defp = linkp -> linkage_header.def_ptr; 372 373 /* validate that all first reference traps have been run */ 374 375 if linkp -> virgin_linkage_header.first_ref_relp ^= 0 376 then call exit (call_infop, error_table_$first_reference_trap, null); 377 378 /* now that things look reasonably valid, we start decoding the link */ 379 380 exprp = addrel (defp, link_pair.expression_relp); 381 type_prp = addrel (defp, expr.type_relp); 382 383 /* first we check the link to see if it should be converted into a */ 384 /* *system link. Trap-before links to datmk_ and certain type-6 */ 385 /* links are converted to *system links. */ 386 387 call convert_trap_link (call_infop, linkp, defp, type_prp, offset_name, 388 init_infop, star_system_sw); 389 390 if star_system_sw 391 then do; 392 393 /* the link either was a *system link, or has become one */ 394 395 call star_system (call_infop, link_pairp, defp, linkp, type_prp, 396 offset_name, init_infop, targetp); 397 call snap (targetp, (expr.expression), link_pairp); 398 call meter (call_infop, (type_pr.type)); 399 call exit (call_infop, 0, targetp); 400 end; 401 402 /* see if we have a C *heap link */ 403 404 if type_pr.type = LINK_SELF_OFFSETNAME & type_pr.segname_relp = CLASS_HEAP 405 then do; 406 407 /* C *heap links are similar to *system links except that they */ 408 /* are allocated separately, and have a level associated with */ 409 /* them so that recursive invocations get new copies and they */ 410 /* can be released when the invocation returns. */ 411 412 call star_heap (call_infop, defp, linkp, type_prp, targetp); 413 call snap (targetp, (expr.expression), link_pairp); 414 call meter (call_infop, (type_pr.type)); 415 call exit (call_infop, 0, targetp); 416 end; 417 418 /* now see if there is a trap pointer. Anything with a trap */ 419 /* pointer that wasn't converted to a *system link, and isn't a */ 420 /* create link, we now treat as a trap-before link, and try to run */ 421 /* the trap. */ 422 423 if type_pr.type ^= LINK_CREATE_IF_NOT_FOUND & type_pr.trap_relp ^= None 424 then do; 425 426 /* actually is a trap-before link, trap out to the user */ 427 /* ring to execute the trap procedure. */ 428 429 /* NB. We don't try to complete tracing or metering in this */ 430 /* case since it would be rather meaningless anyway. . . */ 431 432 call adjust_mc (mcp); 433 call trap_caller_caller_ (mcp, linkp, defp, type_prp, link_pairp, 434 call_info.codep, code); 435 436 /* usually we don't return, but. . . */ 437 438 call exit (call_infop, code, baseptr (0)); 439 end; 440 441 /* at this point we assume we have a reasonably standard link and */ 442 /* can just snap it according to type. */ 443 444 if /* case */ type_pr.type = LINK_SELF_BASE 445 then do; 446 call self_reference (call_infop, (type_pr.segname_relp), textp, 447 targetp); 448 call snap (targetp, (expr.expression), link_pairp); 449 call meter (call_infop, (type_pr.type)); 450 call exit (call_infop, 0, targetp); 451 end; 452 453 else if type_pr.type = LINK_OBSOLETE_2 454 then call exit (call_infop, error_table_$bad_link_type, null); 455 456 else if type_pr.type = LINK_REFNAME_BASE 457 then do; 458 segnamep = addrel (defp, type_pr.segname_relp); 459 if defp -> definition_header.msf_map_relp ^= None 460 then MSF_sw = true; 461 else MSF_sw = false; 462 call search_for_segment (call_infop, segnamep, textp, MSF_sw, segp, 463 code); 464 if segp = null 465 then call exit (call_infop, code, null); 466 call snap (segp, (expr.expression), link_pairp); 467 call meter (call_infop, (type_pr.type)); 468 call exit (call_infop, 0, segp); 469 end; 470 471 else if type_pr.type = LINK_REFNAME_OFFSETNAME 472 then do; 473 segnamep = addrel (defp, type_pr.segname_relp); 474 if defp -> definition_header.msf_map_relp ^= None 475 then MSF_sw = true; 476 else MSF_sw = false; 477 call search_for_segment (call_infop, segnamep, textp, MSF_sw, segp, 478 code); 479 if segp = null 480 then call exit (call_infop, code, null); 481 call condition_ ("seg_fault_error", connect_fail_handler_); 482 call get_offsetnamep (call_infop, defp, type_prp, offsetnamep); 483 call get_definition (call_infop, segnamep, offsetnamep, segp, 484 No_retry, target_linkagep, targetp); 485 call snap (targetp, (expr.expression), link_pairp); 486 call meter (call_infop, (type_pr.type)); 487 call trap (call_infop, target_linkagep, targetp); 488 call exit (call_infop, 0, targetp); 489 end; 490 491 else if type_pr.type = LINK_SELF_OFFSETNAME 492 then do; 493 call self_reference (call_infop, (type_pr.segname_relp), textp, 494 targetp); 495 496 /* insure that segname won't be found */ 497 498 segnamep = addr (zero_word); 499 call get_offsetnamep (call_infop, defp, type_prp, offsetnamep); 500 call get_definition (call_infop, segnamep, offsetnamep, textp, 501 No_retry, (null), targetp); 502 call snap (targetp, (expr.expression), link_pairp); 503 call meter (call_infop, (type_pr.type)); 504 call exit (call_infop, 0, targetp); 505 end; 506 507 else if type_pr.type = LINK_CREATE_IF_NOT_FOUND 508 then do; 509 510 /* NB. since we have already processed the trap case, we will */ 511 /* assume that this link can be treated as a type-4 until */ 512 /* something breaks. */ 513 514 segnamep = addrel (defp, type_pr.segname_relp); 515 if defp -> definition_header.msf_map_relp ^= None 516 then MSF_sw = true; 517 else MSF_sw = false; 518 call search_for_segment (call_infop, segnamep, textp, MSF_sw, segp, 519 code); 520 if segp = null 521 then do; 522 523 /* OK. something broke. now we try to treat this as a */ 524 /* *system link so that the caller will get something. */ 525 526 call get_offsetnamep (call_infop, defp, type_prp, offsetnamep); 527 if offsetnamep = null 528 then offset_name = segname.string || "$"; 529 else offset_name = segname.string || "$" || offsetname.string; 530 if type_pr.trap_relp = 0 531 then init_infop = null; 532 else init_infop = addrel (defp, type_pr.trap_relp); 533 call star_system (call_infop, link_pairp, defp, linkp, type_prp, 534 offset_name, init_infop, targetp); 535 call snap (targetp, (expr.expression), link_pairp); 536 call meter (call_infop, (type_pr.type)); 537 call exit (call_infop, 0, targetp); 538 end; 539 540 call condition_ ("seg_fault_error", connect_fail_handler_); 541 call get_offsetnamep (call_infop, defp, type_prp, offsetnamep); 542 543 /* dont try to do a definition search if no entrypoint name was given */ 544 545 if offsetnamep ^= null 546 then call get_definition (call_infop, segnamep, offsetnamep, segp, 547 No_retry, target_linkagep, targetp); 548 else targetp = segp; 549 call snap (targetp, (expr.expression), link_pairp); 550 call meter (call_infop, (type_pr.type)); 551 call trap (call_infop, target_linkagep, targetp); 552 call exit (call_infop, 0, targetp); 553 end; 554 555 else call exit (call_infop, error_table_$bad_link_type, null); 556 557 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 558 559 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 560 561 562 make_ptr: 563 entry (a_refp, /** referencing dir ptr (in ) */ 564 a_seg_name, /** segname to find (in ) */ 565 a_offset_name, /** entrypoint to find (in ) */ 566 a_targetp, /** target ptr returned (out) */ 567 a_code); /** error code (out) */ 568 569 /*** ****************************************************************/ 570 /*** */ 571 /*** Name: link_snap$make_ptr */ 572 /*** Input: refp, seg_name, offset_name */ 573 /*** Function: Using the segname and optional offsetname given, */ 574 /*** snap a simulated type-3 (if a null offsetname) */ 575 /*** or type-4 (if non-null) link and return a pointer */ 576 /*** to the target. The reference pointer is passed */ 577 /*** to fs_search in order to evaluate the referencing */ 578 /*** dir search rule. If it is null, the referencing */ 579 /*** dir rule is skipped. */ 580 /*** Output: targetp, code */ 581 /*** */ 582 /*** ****************************************************************/ 583 584 /* preset the return values */ 585 586 a_targetp = null; 587 588 /* set up the call info */ 589 590 call_info.type = Make_ptr; 591 592 goto make_join; 593 594 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 595 596 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 597 598 599 make_entry: 600 entry (a_refp, /** referencing dir ptr (in ) */ 601 a_seg_name, /** segname to find (in ) */ 602 a_offset_name, /** entrypoint to find (in ) */ 603 a_targete, /** entry returned (out) */ 604 a_code); /** error code (out) */ 605 606 /*** ****************************************************************/ 607 /*** */ 608 /*** Name: link_snap$make_entry */ 609 /*** Input: refp, seg_name, offset_name */ 610 /*** Function: performs the same function as link_snap$make_ptr */ 611 /*** except that an entry value is returned instead of */ 612 /*** a pointer value. The other difference between */ 613 /*** calling make_entry and make_ptr is that if the */ 614 /*** offsetname value is null on a call to make_entry */ 615 /*** the target linkage section is combined and any */ 616 /*** first reference traps run. This is because it is */ 617 /*** assumed that if you want an entry returned, you */ 618 /*** plan on calling it, and to call it the linkage */ 619 /*** section should be combined. */ 620 /*** Output: targete, code */ 621 /*** */ 622 /*** ****************************************************************/ 623 624 call_info.type = Make_entry; 625 626 /* preset the returned entry */ 627 628 addr (a_targete) -> based_entry.code_ptr = null; 629 addr (a_targete) -> based_entry.env_ptr = null; 630 631 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 632 633 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 634 635 636 make_join: 637 638 /* meter and trace the make_ptr/make_entry call */ 639 640 call usage_values (call_info.start.pf, call_info.start.time); 641 call page$enter_data (baseptr (0), linkage_fault_start); 642 643 /* clear out the metering information */ 644 645 call_info.search.time = 0; 646 call_info.search.pf = 0; 647 call_info.get_linkage.time = 0; 648 call_info.get_linkage.pf = 0; 649 call_info.def_search.time = 0; 650 call_info.def_search.pf = 0; 651 652 /* set up the common call_info stuff */ 653 654 call_infop = addr (call_info); 655 call_info.codep = addr (a_code); 656 call_info.mcp, mcp = null; 657 call_info.save_ring = -1; 658 659 /* copy the args into automatic storage */ 660 661 refp = a_refp; 662 seg_name = a_seg_name; 663 offset_name = a_offset_name; 664 665 /* preset the return code */ 666 667 a_code = 0; 668 669 /* try to determine whether the ref pointer refers to an MSF */ 670 671 if refp = null 672 then MSF_sw = false; 673 else do; 674 call link_man$own_linkage (ptr (refp, 0), linkp, null, null, code); 675 if code ^= 0 676 then MSF_sw = false; 677 else if addr (linkp -> linkage_header.def_ptr) -> its.its_mod ^= 678 ITS_MODIFIER 679 then MSF_sw = false; 680 else do; 681 defp = linkp -> linkage_header.def_ptr; 682 if defp -> definition_header.msf_map_relp ^= None 683 then MSF_sw = true; 684 else MSF_sw = false; 685 end; 686 end; 687 688 /* search for the segment */ 689 690 call fs_search (refp, seg_name, MSF_sw, segp, code); 691 if code ^= 0 692 then call exit (call_infop, code, null); 693 694 /* set up to handle connection failure gracefully */ 695 696 call condition_ ("seg_fault_error", connect_fail_handler_); 697 698 nchars = length (rtrim (offset_name)); 699 700 if nchars = 0 701 then do; 702 703 /* no offsetname, so just meter, finish tracing and return */ 704 705 if call_info.type = Make_ptr 706 then call meter (call_infop, (LINK_REFNAME_BASE)); 707 else do; 708 709 /* if we are returning an entry, we must combine the */ 710 /* target linkage section first. If we combine the linkage */ 711 /* section we should run any first reference traps. */ 712 713 call combine_linkage (call_infop, segp, (null), target_linkagep, 714 (null), (null)); 715 call meter (call_infop, (LINK_REFNAME_BASE)); 716 call trap (call_infop, target_linkagep, segp); 717 end; 718 call exit (call_infop, 0, segp); 719 end; 720 721 /* set up the segname/offsetname pointers */ 722 723 segnamep = addr (automatic_segname); 724 offsetnamep = addr (automatic_offsetname); 725 726 /* clear them out */ 727 728 unspec (automatic_segname) = ""b; 729 unspec (automatic_offsetname) = ""b; 730 731 /* save the passed segname/offsetname values */ 732 733 automatic_segname.count = length (rtrim (seg_name)); 734 substr (automatic_segname.string, 1, automatic_segname.count) = 735 substr (seg_name, 1, automatic_segname.count); 736 737 automatic_offsetname.count = length (rtrim (offset_name)); 738 substr (automatic_offsetname.string, 1, automatic_offsetname.count) = 739 substr (offset_name, 1, automatic_offsetname.count); 740 741 /* if the offsetname and segname are the same, we want */ 742 /* get_definition to retry using the offsetname "main_" */ 743 /* if this attempt fails */ 744 745 if seg_name = offset_name 746 then retry_sw = Will_retry; 747 else retry_sw = No_retry; 748 749 call get_definition (call_infop, segnamep, offsetnamep, segp, retry_sw, 750 target_linkagep, targetp); 751 752 call meter (call_infop, (LINK_REFNAME_OFFSETNAME)); 753 call trap (call_infop, target_linkagep, targetp); 754 call exit (call_infop, 0, targetp); 755 756 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 757 758 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 759 760 761 convert_trap_link: 762 proc (infop, /** call info pointer (in ) */ 763 linkp, /** linkage pointer (in ) */ 764 defp, /** definition pointer (in ) */ 765 type_prp, /** type_pair pointer (in ) */ 766 offset_name, /** entrypoint name (out) */ 767 init_infop, /** init_info pointer (out) */ 768 star_system_sw); /** *system or mapped (out) */ 769 770 /*** ****************************************************************/ 771 /*** */ 772 /*** Name: convert_trap_link */ 773 /*** Input: infop, linkp, defp, type_prp */ 774 /*** Function: determines whether the link in question has a */ 775 /*** trap_relp value. If it does, then the link is */ 776 /*** a probably a *system link (type-5, class-5) or */ 777 /*** should should be treated as one. If it is not */ 778 /*** not a *system link, and should be, we determine */ 779 /*** what the offset_name to be found is and what the */ 780 /*** init_info pointer should be and then set the flag */ 781 /*** to indicate that this is to be snapped as a */ 782 /*** *system link. */ 783 /*** Output: offset_name, init_infop, star_system_sw */ 784 /*** */ 785 /*** ****************************************************************/ 786 787 /* parameters */ 788 789 dcl infop ptr parameter; 790 dcl linkp ptr parameter; 791 dcl defp ptr parameter; 792 dcl type_prp ptr parameter; 793 dcl offset_name char (256) parameter; 794 dcl init_infop ptr parameter; 795 dcl star_system_sw bit (1) parameter; 796 797 /* based */ 798 799 dcl based_ptr ptr based; 800 dcl 01 offsetname aligned based (offsetnamep), 801 02 count fixed bin (9) unsigned unaligned, 802 02 string char (offsetname.count) unaligned; 803 dcl 01 segname aligned based (segnamep), 804 02 count fixed bin (9) unsigned unaligned, 805 02 string char (segname.count) unaligned; 806 dcl 01 trap aligned like link_trap_pair based (trapp); 807 dcl 01 type_pr aligned like type_pair based (type_prp); 808 809 /* automatic */ 810 811 dcl code fixed bin (35) automatic; 812 dcl init_linkp ptr automatic; 813 dcl offsetnamep ptr automatic; 814 dcl segnamep ptr automatic; 815 dcl trapp ptr automatic; 816 817 segnamep = addrel (defp, type_pr.segname_relp); 818 offsetnamep = addrel (defp, type_pr.offsetname_relp); 819 820 /* preset output variables */ 821 822 star_system_sw = false; 823 offset_name = offsetname.string; 824 if type_pr.trap_relp = None 825 then init_infop = null; 826 else init_infop = addrel (defp, type_pr.trap_relp); 827 828 /* first see if it is actually a *system link */ 829 830 if type_pr.type = LINK_SELF_OFFSETNAME & type_pr.segname_relp = CLASS_SYSTEM 831 then do; 832 star_system_sw = true; 833 return; 834 end; 835 836 /* now check the conditions for converting a type 6 link */ 837 838 if type_pr.type = LINK_CREATE_IF_NOT_FOUND 839 then do; 840 841 /* check for pl1 ext static */ 842 843 if segname.string = "stat_" 844 then do; 845 star_system_sw = true; 846 return; 847 end; 848 849 /* check for fortran common blocks */ 850 851 if offsetname.count = 0 852 then if index (segname.string, ".com") = segname.count - 3 853 then do; 854 star_system_sw = true; 855 offset_name = substr (segname.string, 1, segname.count - 4); 856 if offset_name = "b_" /* blank common */ 857 then offset_name = "blnk*com"; 858 return; 859 end; 860 else ; 861 862 /* check for cobol FSB link */ 863 864 else if segname.string = "cobol_fsb_" 865 then do; 866 offset_name = "cobol_fsb_" || offsetname.string; 867 star_system_sw = true; 868 return; 869 end; 870 end; 871 872 if type_pr.type = LINK_REFNAME_OFFSETNAME & type_pr.trap_relp ^= None 873 then do; 874 875 /* if we have a type 4 link with a trap-before link to datmk_ */ 876 /* we force-snap the info-link of the trap, use that as the */ 877 /* init_info pointer and use the offsetname from the original */ 878 /* link as the name and then treat as a *system link. */ 879 880 trapp = addrel (defp, type_pr.trap_relp); 881 if segname.string = "stat_" 882 then if addrel (defp, 883 addrel (defp, 884 addrel (defp, addrel (linkp, trap.call_relp) 885 -> object_link.expression_relp) 886 -> exp_word.type_relp) 887 -> type_pair.segname_relp) -> acc_string.string = "datmk_" 888 then do; 889 init_linkp = addrel (linkp, trap.info_relp); 890 891 /* snap the info link */ 892 893 call link_force (init_linkp, 0, code); 894 if code ^= 0 895 then call exit (call_infop, code, null); 896 897 init_infop = init_linkp -> based_ptr; 898 star_system_sw = true; 899 end; 900 end; 901 902 end convert_trap_link; 903 904 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 905 906 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 907 908 909 star_system: 910 proc (infop, /** call_info pointer (in ) */ 911 link_pairp, /** pointer to link (in ) */ 912 defp, /** definition pointer (in ) */ 913 linkp, /** linkage pointer (in ) */ 914 type_prp, /** type_pair pointer (in ) */ 915 offset_name, /** ext var name string (in ) */ 916 init_infop, /** init_info pointer (in ) */ 917 targetp); /** target variable (out) */ 918 919 /*** ****************************************************************/ 920 /*** */ 921 /*** Name: star_system */ 922 /*** Input: infop, link_pairp, defp, linkp, type_prp, */ 923 /*** offset_name, init_infop */ 924 /*** Function: determines the target of a *system link. This */ 925 /*** procedure calls set_ext_variable_ to return the */ 926 /*** variable_node which defines the named external */ 927 /*** variable, and then returns a pointer to the var */ 928 /*** itself. */ 929 /*** Output: targetp */ 930 /*** */ 931 /*** ****************************************************************/ 932 933 /* parameters */ 934 935 dcl infop ptr parameter; 936 dcl link_pairp ptr parameter; 937 dcl defp ptr parameter; 938 dcl linkp ptr parameter; 939 dcl type_prp ptr parameter; 940 dcl offset_name char (256) parameter; 941 dcl init_infop ptr parameter; 942 dcl targetp ptr parameter; 943 944 /* based */ 945 946 dcl 01 info aligned like call_info based (infop); 947 948 /* automatic */ 949 950 dcl code fixed bin (35) automatic; 951 dcl sb ptr automatic; 952 953 /* set the stack base pointer */ 954 955 if info.mcp = null 956 then sb = pds$stacks (level$get ()); 957 else sb = ptr (info.mcp -> mc.prs (6), 0); 958 959 /* check to see if this variable has a deferred initialization type */ 960 961 call deferred_init (infop, init_infop, linkp); 962 963 /* now call set_ext_variable_ to get the variable node. Note that */ 964 /* this call may not return if the target is an uninitialized VLA, */ 965 /* since this requires a call to fortran_storage_manager_. We cant */ 966 /* call this in ring 0 so we trap out to the user ring to call out */ 967 /* to set up the VLA. The fortran_storage_manager_ is responsible */ 968 /* for completing the link snap. */ 969 970 call set_ext_variable_$for_linker (offset_name, init_infop, sb, 971 ptr (init_infop, 0), ("0"b), targetp, code, info.mcp, def_ptr, 972 type_prp, link_pairp); 973 if code ^= 0 974 then call exit (infop, code, null); 975 976 /* get a pointer to the actual variable instead of the node */ 977 978 targetp = targetp -> variable_node.vbl_ptr; 979 980 end star_system; 981 982 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 983 984 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 985 986 987 star_heap: 988 proc (infop, /** call_info pointer (in ) */ 989 defp, /** def section ptr (in ) */ 990 linkp, /** linkage section ptr (in ) */ 991 type_prp, /** type_pair pointer (in ) */ 992 targetp); /** target pointer (out) */ 993 994 /*** ****************************************************************/ 995 /*** */ 996 /*** Name: star_heap */ 997 /*** Input: infop, defp, linkp, type_prp */ 998 /*** Function: given a pointer to the type_pair and definition */ 999 /*** section for a link, get the offsetname and init */ 1000 /*** info pointer and call set_ext_variable_$star_heap */ 1001 /*** to find or create the variable. */ 1002 /*** Output: targetp */ 1003 /*** */ 1004 /*** ****************************************************************/ 1005 1006 /* parameters */ 1007 1008 dcl infop ptr parameter; 1009 dcl defp ptr parameter; 1010 dcl linkp ptr parameter; 1011 dcl type_prp ptr parameter; 1012 dcl targetp ptr parameter; 1013 1014 /* based */ 1015 1016 dcl 01 info aligned like call_info based (infop); 1017 dcl 01 offsetname aligned based (offsetnamep), 1018 02 count fixed bin (9) unsigned unaligned, 1019 02 string char (offsetname.count) unaligned; 1020 dcl 01 type_pr aligned like type_pair based (type_prp); 1021 1022 /* automatic */ 1023 1024 dcl init_infop ptr automatic; 1025 dcl offsetnamep ptr automatic; 1026 dcl sb ptr automatic; 1027 dcl offset_name char (256) automatic; 1028 1029 /* extract the variable name and init_info pointer */ 1030 1031 offsetnamep = addrel (defp, type_pr.offsetname_relp); 1032 offset_name = offsetname.string; 1033 1034 if type_pr.trap_relp = None 1035 then init_infop = null; 1036 else init_infop = addrel (defp, type_pr.trap_relp); 1037 1038 /* get the stack base pointer */ 1039 1040 if info.mcp = null 1041 then sb = pds$stacks (level$get ()); 1042 else sb = ptr (info.mcp -> mc.prs (6), 0); 1043 1044 /* get new init_info pointer if initialization type = INIT_DEFERRED */ 1045 1046 call deferred_init (infop, init_infop, linkp); 1047 1048 /* call set_ext_variable_$star_heap to allocate the variable and */ 1049 /* return a node ptr */ 1050 1051 call set_ext_variable_$star_heap (offset_name, init_infop, sb, 1052 ptr (init_infop, 0), ("0"b), targetp, code); 1053 if code ^= 0 1054 then call exit (infop, code, null); 1055 1056 /* set the target to point to the variable itself */ 1057 1058 targetp = targetp -> variable_node.vbl_ptr; 1059 1060 end star_heap; 1061 1062 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1063 1064 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1065 1066 1067 deferred_init: 1068 proc (infop, /** call_info pointer (in ) */ 1069 init_infop, /** init_info pointer (i/o) */ 1070 linkp); /** linkage section ptr (in ) */ 1071 1072 /*** ****************************************************************/ 1073 /*** */ 1074 /*** Name: deferred_init */ 1075 /*** Input: infop, init_infop, linkp */ 1076 /*** Function: locates the initialization info for deferred init */ 1077 /*** external or heap initialization. The procedure */ 1078 /*** for deferred initialization is as follows: */ 1079 /*** - check to see if the init type is deferred. */ 1080 /*** - if so, extract the target_relp and link_relp */ 1081 /*** from the init_info. */ 1082 /*** - make sure the link referenced by target_relp */ 1083 /*** has been snapped. */ 1084 /*** - chase the link to find the target segments */ 1085 /*** linkage header. */ 1086 /*** - extract the def_ptr and original_linkage_ptr */ 1087 /*** from the linkage_header. */ 1088 /*** - apply the link_relp to the original_linkage */ 1089 /*** pointer to find the unsnapped link. */ 1090 /*** - extract a pointer to the init_info from the */ 1091 /*** def_ptr and type_pair. */ 1092 /*** - return the actual init_info pointer. */ 1093 /*** Output: init_infop */ 1094 /*** */ 1095 /*** ****************************************************************/ 1096 1097 /* parameters */ 1098 1099 dcl infop ptr parameter; 1100 dcl init_infop ptr parameter; 1101 dcl linkp ptr parameter; 1102 1103 /* based */ 1104 1105 dcl 01 lh aligned like linkage_header based (lhp); 1106 dcl based_ptr ptr based; 1107 dcl 01 type_pr aligned like type_pair based (type_prp); 1108 dcl 01 expr aligned like exp_word based (exprp); 1109 dcl 01 link_pair aligned like object_link based (link_pairp); 1110 dcl 01 init_info aligned like link_init_deferred 1111 based (init_infop); 1112 1113 /* automatic */ 1114 1115 dcl target_ptr_ptr ptr automatic; 1116 dcl lhp ptr automatic; 1117 dcl exprp ptr automatic; 1118 dcl type_prp ptr automatic; 1119 dcl link_pairp ptr automatic; 1120 1121 /* if no init_info, or init_info is not deferred, just return */ 1122 1123 if init_infop = null 1124 then return; 1125 1126 if init_info.header.type ^= INIT_DEFERRED 1127 then return; 1128 1129 /* get the target partial link and make sure it is snapped */ 1130 1131 target_ptr_ptr = addrel (linkp, init_info.target_relp); 1132 if target_ptr_ptr -> its.its_mod ^= ITS_MODIFIER 1133 then call exit (infop, error_table_$bad_deferred_init, null); 1134 1135 /* make sure the target of the link looks somewhat like a linkage */ 1136 /* header and that the definition pointer is a pointer */ 1137 1138 lhp = target_ptr_ptr -> based_ptr; 1139 if addr (lh.def_ptr) -> its.its_mod ^= ITS_MODIFIER 1140 then call exit (infop, error_table_$no_defs, null); 1141 else defp = lh.def_ptr; 1142 1143 /* get a pointer to the link specified in the original linkage */ 1144 /* section and make sure it looks like an unsnapped link. */ 1145 1146 link_pairp = addrel (lh.original_linkage_ptr, init_info.link_relp); 1147 if link_pair.tag ^= FAULT_TAG_2 1148 then call exit (infop, error_table_$bad_deferred_init, null); 1149 1150 /* now decode the link and get a pointer to the init_info */ 1151 1152 exprp = addrel (defp, link_pair.expression_relp); 1153 type_prp = addrel (defp, expr.type_relp); 1154 if type_pr.trap_relp = None 1155 then init_infop = null; 1156 else init_infop = addrel (defp, type_pr.trap_relp); 1157 1158 end deferred_init; 1159 1160 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1161 1162 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1163 1164 1165 self_reference: 1166 proc (infop, /** call_info pointer (in ) */ 1167 class, /** link class (in ) */ 1168 textp, /** segment pointer (in ) */ 1169 targetp); /** section pointer (out) */ 1170 1171 /*** ****************************************************************/ 1172 /*** */ 1173 /*** Name: self_reference */ 1174 /*** Input: infop, class, textp */ 1175 /*** Function: given a link class and a pointer to the owners */ 1176 /*** text_section, get the other section pointers and */ 1177 /*** return a pointer to the section specified by the */ 1178 /*** class of the link. */ 1179 /*** Output: targetp */ 1180 /*** */ 1181 /*** ****************************************************************/ 1182 1183 /* parameters */ 1184 1185 dcl infop ptr parameter; 1186 dcl class fixed bin (18) unsigned parameter; 1187 dcl textp ptr parameter; 1188 dcl targetp ptr parameter; 1189 1190 /* automatic */ 1191 1192 dcl code fixed bin (35) automatic; 1193 dcl linkp ptr automatic; 1194 dcl staticp ptr automatic; 1195 dcl symbolp ptr automatic; 1196 1197 /* get pointers to the various sections */ 1198 1199 call link_man$own_linkage (textp, linkp, staticp, symbolp, code); 1200 if code ^= 0 1201 then call exit (infop, code, null); 1202 1203 /* return the section pointer based on the link class */ 1204 1205 if /* case */ class = CLASS_TEXT 1206 then targetp = textp; 1207 else if class = CLASS_LINKAGE 1208 then targetp = linkp; 1209 else if class = CLASS_STATIC 1210 then targetp = staticp; 1211 else if class = CLASS_SYMBOL 1212 then targetp = symbolp; 1213 else call exit (infop, error_table_$bad_self_ref, null); 1214 1215 end self_reference; 1216 1217 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1218 1219 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1220 1221 1222 search_for_segment: 1223 proc (infop, /** call_info pointer (in ) */ 1224 segnamep, /** segname acc pointer (in ) */ 1225 refp, /** referencing pointer (in ) */ 1226 MSF_sw, /** is caller an MSF (in ) */ 1227 segp, /** found segment ptr (out) */ 1228 code); /** error code (out) */ 1229 1230 /*** ****************************************************************/ 1231 /*** */ 1232 /*** Name: search_for_segment */ 1233 /*** Input: infop, segnamep, refp */ 1234 /*** Function: calls fs_search to search for the refname given */ 1235 /*** by the acc_string pointer to by segnamep, and */ 1236 /*** meters the call. */ 1237 /*** Output: segp, code */ 1238 /*** */ 1239 /*** ****************************************************************/ 1240 1241 /* parameters */ 1242 1243 dcl infop ptr parameter; 1244 dcl segnamep ptr parameter; 1245 dcl refp ptr parameter; 1246 dcl MSF_sw bit (1) aligned parameter; 1247 dcl segp ptr parameter; 1248 dcl code fixed bin (35) parameter; 1249 1250 /* based */ 1251 1252 dcl 01 info aligned like call_info based (infop); 1253 dcl 01 segname aligned based (segnamep), 1254 02 count fixed bin (9) unsigned unaligned, 1255 02 string char (segname.count) unaligned; 1256 1257 /* automatic */ 1258 1259 dcl 01 finish aligned like usage automatic; 1260 dcl 01 start aligned like usage automatic; 1261 1262 /* do the search and meter the time an pagewaits */ 1263 1264 call usage_values (start.pf, start.time); 1265 1266 call fs_search (refp, segname.string, MSF_sw, segp, code); 1267 1268 call usage_values (finish.pf, finish.time); 1269 1270 /* calculate the metering info and add it to the search metering */ 1271 1272 info.search.pf = info.search.pf + (finish.pf - start.pf); 1273 info.search.time = info.search.time + (finish.time - start.time); 1274 1275 end search_for_segment; 1276 1277 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1278 1279 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1280 1281 1282 get_offsetnamep: 1283 proc (infop, /** call_info pointer (in ) */ 1284 defp, /** definition pointer (in ) */ 1285 type_prp, /** type_pair pointer (in ) */ 1286 offsetnamep); /** offsetname pointer (out) */ 1287 1288 /*** ****************************************************************/ 1289 /*** */ 1290 /*** Name: get_offsetnamep */ 1291 /*** Input: infop, defp, type_prp */ 1292 /*** Function: extract a pointer to the offsetname for the link */ 1293 /*** from the type_pair. If there is no offsetname */ 1294 /*** or the type is 6 and the offset name length is 0, */ 1295 /*** the null pointer is returned. */ 1296 /*** Output: offsetnamep */ 1297 /*** */ 1298 /*** ****************************************************************/ 1299 1300 /* parameters */ 1301 1302 dcl infop ptr parameter; 1303 dcl defp ptr parameter; 1304 dcl type_prp ptr parameter; 1305 dcl offsetnamep ptr parameter; 1306 1307 /* based */ 1308 1309 dcl 01 offsetname aligned based (offsetnamep), 1310 02 count fixed bin (9) unsigned unaligned, 1311 02 string char (offsetname.count) unaligned; 1312 dcl 01 type_pr aligned like type_pair based (type_prp); 1313 1314 if type_pr.offsetname_relp = None 1315 then offsetnamep = null; 1316 else do; 1317 1318 /* type-6 links use a valid acc_string with a zero length instead. */ 1319 1320 offsetnamep = addrel (defp, type_pr.offsetname_relp); 1321 if type_pr.type = LINK_CREATE_IF_NOT_FOUND & offsetname.count = 0 1322 then offsetnamep = null; 1323 end; 1324 1325 end get_offsetnamep; 1326 1327 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1328 1329 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1330 1331 1332 combine_linkage: 1333 proc (infop, /** call_info pointer (in ) */ 1334 segp, /** target segment ptr (in ) */ 1335 textp, /** text section ptr (out) */ 1336 linkp, /** linkage section ptr (out) */ 1337 statp, /** static section ptr (out) */ 1338 symbp); /** symbol section ptr (out) */ 1339 1340 /*** ****************************************************************/ 1341 /*** */ 1342 /*** Name: combine_linkage */ 1343 /*** Input: infop, segp */ 1344 /*** Function: given a pointer to a segment (segp), combine the */ 1345 /*** linkage section (if necessary) and return the */ 1346 /*** pointers to the various sections. This routine */ 1347 /*** also meters the call. */ 1348 /*** Output: textp, linkp, statp, symbp */ 1349 /*** */ 1350 /*** ****************************************************************/ 1351 1352 /* parameters */ 1353 1354 dcl infop ptr parameter; 1355 dcl segp ptr parameter; 1356 dcl textp ptr parameter; 1357 dcl linkp ptr parameter; 1358 dcl statp ptr parameter; 1359 dcl symbp ptr parameter; 1360 1361 /* based */ 1362 1363 dcl 01 info aligned like call_info based (infop); 1364 1365 /* automatic */ 1366 1367 dcl 01 finish aligned like usage automatic; 1368 dcl 01 start aligned like usage automatic; 1369 1370 /* combine the linkage section and meter the time and pagewaits */ 1371 1372 call usage_values (start.pf, start.time); 1373 1374 textp = ptr (segp, 0); 1375 call link_man$other_linkage (textp, linkp, statp, symbp, code); 1376 1377 call usage_values (finish.pf, finish.time); 1378 1379 /* add in to metering info */ 1380 1381 info.get_linkage.pf = info.get_linkage.pf + (finish.pf - start.pf); 1382 info.get_linkage.time = info.get_linkage.time + (finish.time - start.time); 1383 1384 if code ^= 0 1385 then call exit (infop, code, null); 1386 1387 if linkp = null 1388 then call exit (infop, error_table_$no_linkage, null); 1389 1390 end combine_linkage; 1391 1392 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1393 1394 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1395 1396 1397 get_definition: 1398 proc (infop, /** call_info pointer (in ) */ 1399 segnamep, /** segname acc ptr (in ) */ 1400 offsetnamep, /** offsetname acc ptr (in ) */ 1401 segp, /** segment to search (in ) */ 1402 retry, /** will retry "main_" (in ) */ 1403 target_linkagep, /** linkp of target seg (out) */ 1404 targetp); /** target pointer (out) */ 1405 1406 /*** ****************************************************************/ 1407 /*** */ 1408 /*** Name: get_definition */ 1409 /*** Input: infop, segnamep, offsetnamep, segp, retry */ 1410 /*** Function: combines the linkage section for the segment */ 1411 /*** specified, and then searches the definition */ 1412 /*** section for a definition matching the segname */ 1413 /*** and offsetname given and meters the search. */ 1414 /*** A pointer to the definition target is then */ 1415 /*** generated based on the definition class, the */ 1416 /*** section pointers returned by combining the */ 1417 /*** linkage, and the definition offset. If the */ 1418 /*** search fails and the retry flag is set, we */ 1419 /*** try another search for the entrypoint "main_". */ 1420 /*** Output: targetp */ 1421 /*** */ 1422 /*** ****************************************************************/ 1423 1424 /* constant */ 1425 1426 dcl 01 main_acc aligned static options (constant), 1427 02 count fixed bin (9) unsigned unaligned init (5), 1428 02 string char (5) unaligned init ("main_"); 1429 1430 /* parameters */ 1431 1432 dcl infop ptr parameter; 1433 dcl segnamep ptr parameter; 1434 dcl offsetnamep ptr parameter; 1435 dcl retry bit (1) parameter; 1436 dcl target_linkagep ptr parameter; 1437 dcl segp ptr parameter; 1438 dcl targetp ptr parameter; 1439 1440 /* based */ 1441 1442 dcl based_ptr ptr based; 1443 dcl 01 def aligned like definition based (defp); 1444 dcl 01 info aligned like call_info based (infop); 1445 1446 /* automatic */ 1447 1448 dcl code fixed bin (35) automatic; 1449 dcl defp ptr automatic; 1450 dcl 01 finish aligned like usage automatic; 1451 dcl linkp ptr automatic; 1452 dcl 01 start aligned like usage automatic; 1453 dcl statp ptr automatic; 1454 dcl symbp ptr automatic; 1455 dcl textp ptr automatic; 1456 1457 /* if we have no name to search for, don't bother trying */ 1458 1459 if offsetnamep = null 1460 then return; 1461 1462 /* combine the linkage section and get the section pointers */ 1463 1464 call combine_linkage (infop, segp, textp, linkp, statp, symbp); 1465 1466 /* save the linkage pointer in case we have first reference traps to run */ 1467 1468 target_linkagep = linkp; 1469 1470 call usage_values (start.pf, start.time); 1471 call get_defptr_ (linkp -> linkage_header.def_ptr, segnamep, offsetnamep, 1472 defp, code); 1473 call usage_values (finish.pf, finish.time); 1474 1475 /* update the metering info */ 1476 1477 info.def_search.pf = info.def_search.pf + (finish.pf - start.pf); 1478 info.def_search.time = info.def_search.time + (finish.time - start.time); 1479 1480 if retry & code = error_table_$no_ext_sym 1481 then do; 1482 1483 /* retry the search with an offsetname of "main_" */ 1484 1485 call usage_values (start.pf, start.time); 1486 call get_defptr_ (linkp -> linkage_header.def_ptr, segnamep, 1487 addr (main_acc), defp, code); 1488 call usage_values (finish.pf, finish.time); 1489 1490 /* add to the metering info */ 1491 1492 info.def_search.pf = info.def_search.pf + (finish.pf - start.pf); 1493 info.def_search.time = info.def_search.time + (finish.time - start.time); 1494 1495 end; 1496 1497 if code ^= 0 1498 then call exit (infop, code, null); 1499 1500 /* check for an indirect definition */ 1501 1502 if def.indirect 1503 then do; 1504 1505 /* an indirect definition (used only in component 0 of an */ 1506 /* object MSF) is used to refer to something in another */ 1507 /* component by adding another indirection through a partial */ 1508 /* link. In this case the thing_relp is the offset in the */ 1509 /* linkage section of a partial link to the actual definition */ 1510 /* target. In some cases this link will have been snapped */ 1511 /* already by the msf_prelink_ first reference trap, if not, we */ 1512 /* snap the link, and then use the indirection to give us our */ 1513 /* definition target. */ 1514 1515 if def.class ^= CLASS_LINKAGE 1516 then call exit (infop, error_table_$bad_indirect_def, null); 1517 1518 /* if the link is snapped, just get the value and return */ 1519 1520 targetp = addrel (linkp, def.thing_relp); 1521 if targetp -> its.its_mod = ITS_MODIFIER 1522 then do; 1523 targetp = targetp -> based_ptr; 1524 return; 1525 end; 1526 1527 /* if not make sure it is a partial link */ 1528 1529 if targetp -> its.its_mod ^= FAULT_TAG_3 1530 then call exit (infop, error_table_$bad_indirect_def, null); 1531 1532 /* then snap it, get the value and return */ 1533 1534 call snap_partial_link (infop, targetp, textp); 1535 targetp = targetp -> based_ptr; 1536 return; 1537 end; 1538 1539 /* calculate the target based on the definition class and offset */ 1540 1541 if /* case */ def.class = CLASS_TEXT 1542 then targetp = addrel (textp, def.thing_relp); 1543 else if def.class = CLASS_LINKAGE 1544 then targetp = addrel (linkp, def.thing_relp); 1545 else if def.class = CLASS_STATIC 1546 then targetp = addrel (statp, def.thing_relp); 1547 else if def.class = CLASS_SYMBOL 1548 then targetp = addrel (symbp, def.thing_relp); 1549 else call exit (infop, error_table_$bad_class_def, null); 1550 1551 end get_definition; 1552 1553 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1554 1555 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1556 1557 1558 snap_partial_link: 1559 proc (infop, /** call_info pointer (in ) */ 1560 link_pairp, /** link pair to snap (i/o) */ 1561 refp); /** ref ptr for search (in ) */ 1562 1563 /*** ****************************************************************/ 1564 /*** */ 1565 /*** Name: snap_partial_link */ 1566 /*** Input: infop, link_pairp, refp */ 1567 /*** Function: snaps a partial link to another component in */ 1568 /*** the same directory. */ 1569 /*** Output: link_pairp */ 1570 /*** */ 1571 /*** ****************************************************************/ 1572 1573 /* parameters */ 1574 1575 dcl infop ptr parameter; 1576 dcl link_pairp ptr parameter; 1577 dcl refp ptr parameter; 1578 1579 /* based */ 1580 1581 dcl based_ptr ptr based; 1582 dcl 01 info aligned like call_info based (infop); 1583 dcl 01 link_pair aligned like partial_link based (link_pairp); 1584 1585 /* automatic */ 1586 1587 dcl 01 finish aligned like usage automatic; 1588 dcl linkp ptr automatic; 1589 dcl refname char (32) automatic; 1590 dcl 01 start aligned like usage automatic; 1591 dcl statp ptr automatic; 1592 dcl symbp ptr automatic; 1593 dcl textp ptr automatic; 1594 1595 /* get the name of the other component */ 1596 1597 refname = ltrim (char (link_pair.component)); 1598 1599 /* perform the search and meter the time and pagewaits */ 1600 1601 call usage_values (start.pf, start.time); 1602 call fs_search$same_directory (refp, refname, segp, code); 1603 call usage_values (finish.pf, finish.time); 1604 1605 /* update the metering info */ 1606 1607 info.search.pf = info.search.pf + (finish.pf - start.pf); 1608 info.search.time = info.search.time + (finish.time - start.time); 1609 1610 /* if we didn't find it, something is broken . . . */ 1611 1612 if code ^= 0 1613 then call exit (infop, code, null); 1614 1615 /* combine the target linkage section */ 1616 1617 call combine_linkage (infop, segp, textp, linkp, statp, symbp); 1618 1619 /* now snap the link based on the type and offset in the link */ 1620 1621 if /* case */ link_pair.type = CLASS_TEXT 1622 then link_pairp -> based_ptr = addrel (textp, link_pair.offset); 1623 else if link_pair.type = CLASS_LINKAGE 1624 then link_pairp -> based_ptr = addrel (linkp, link_pair.offset); 1625 else if link_pair.type = CLASS_STATIC 1626 then link_pairp -> based_ptr = addrel (statp, link_pair.offset); 1627 else if link_pair.type = CLASS_SYMBOL 1628 then link_pairp -> based_ptr = addrel (symbp, link_pair.offset); 1629 else call exit (infop, error_table_$bad_indirect_def, null); 1630 1631 end snap_partial_link; 1632 1633 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1634 1635 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1636 1637 1638 snap: 1639 proc (targetp, /** value to snap to (in ) */ 1640 expression, /** offset to add (in ) */ 1641 link_pairp); /** link pair to snap (i/o) */ 1642 1643 /*** ****************************************************************/ 1644 /*** */ 1645 /*** Name: snap */ 1646 /*** Input: targetp, expression, link_pairp */ 1647 /*** Function: completes the snapping of the link and sets */ 1648 /*** targetp to point to the same value as the snapped */ 1649 /*** link; */ 1650 /*** Output: targetp, link_pairp */ 1651 /*** */ 1652 /*** ****************************************************************/ 1653 1654 /* parameters */ 1655 1656 dcl targetp ptr parameter; 1657 dcl expression fixed bin (17) parameter; 1658 dcl link_pairp ptr parameter; 1659 1660 /* based */ 1661 1662 dcl 01 link_as_its aligned like its based (link_pairp); 1663 dcl 01 link_pair aligned like object_link based (link_pairp); 1664 dcl link_ptr ptr based (link_pairp); 1665 1666 /* automatic */ 1667 1668 dcl modifier bit (6) automatic; 1669 dcl sb ptr automatic; 1670 1671 /* add in the expression value */ 1672 1673 targetp = addrel (targetp, expression); 1674 1675 /* get the original modifier from the link */ 1676 1677 modifier = link_pair.modifier; 1678 1679 /* store the new pointer back into the link */ 1680 1681 link_ptr = targetp; 1682 1683 /* put the link modifier back in */ 1684 1685 link_as_its.mod = modifier; 1686 1687 /* put the run-depth into the pointer */ 1688 1689 sb = pds$stacks (level$get ()); 1690 link_pair.run_depth = sb -> stack_header.run_unit_depth; 1691 1692 end snap; 1693 1694 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1695 1696 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1697 1698 1699 meter: 1700 proc (infop, /** call_info pointer (in ) */ 1701 type); /** link type (in ) */ 1702 1703 /*** ****************************************************************/ 1704 /*** */ 1705 /*** Name: meter */ 1706 /*** Input: infop, type */ 1707 /*** Function: given the call_info structure containing the */ 1708 /*** metering info for the last call, and the type of */ 1709 /*** link snapped, update the perprocess link meters */ 1710 /*** in pds and the system_wide meters in ahd. */ 1711 /*** Output: none */ 1712 /*** */ 1713 /*** ****************************************************************/ 1714 1715 /* parameters */ 1716 1717 dcl infop ptr parameter; 1718 dcl type fixed bin (18) unsigned parameter; 1719 1720 /* based */ 1721 1722 dcl 01 info aligned like call_info based (infop); 1723 dcl 01 lm aligned like link_meters based (lmp); 1724 1725 /* automatic */ 1726 1727 dcl elapsed_time fixed bin (35) automatic; 1728 dcl elapsed_pf fixed bin (30) automatic; 1729 dcl bin_no fixed bin automatic; 1730 dcl lmp ptr automatic; 1731 1732 /* get the final metering values */ 1733 1734 call usage_values (info.finish.pf, info.finish.time); 1735 1736 /* calculate the elapsed time and pagewaits */ 1737 1738 elapsed_time = bin (info.finish.time - info.start.time, 35); 1739 elapsed_pf = bin (info.finish.pf - info.start.pf, 30); 1740 1741 /* determine which bin this fault goes into */ 1742 1743 bin_no = max (1, min (4, divide (elapsed_time, 25000, 17, 0) + 1)); 1744 1745 /* update the counts in pds */ 1746 1747 pds$link_meters_bins (bin_no) = pds$link_meters_bins (bin_no) + 1; 1748 pds$link_meters_pgwaits (bin_no) = pds$link_meters_pgwaits (bin_no) + 1749 elapsed_pf; 1750 pds$link_meters_times (bin_no) = pds$link_meters_times (bin_no) + 1751 elapsed_time; 1752 1753 /* update the ahd link meters */ 1754 1755 lmp = addr (ahd$link_meters (bin_no)); 1756 1757 lm.total = lm.total + 1; 1758 lm.pf = lm.pf + elapsed_pf; 1759 lm.time = lm.time + elapsed_time; 1760 1761 if /* case */ (info.type = Link_fault | info.type = Link_force) & 1762 (type = LINK_REFNAME_BASE | type = LINK_REFNAME_OFFSETNAME) 1763 then do; 1764 lm.search_pf = lm.search_pf + info.search.pf; 1765 lm.search_time = lm.search_time + info.search.time; 1766 lm.get_linkage_pf = lm.get_linkage_pf + info.get_linkage.pf; 1767 lm.get_linkage_time = lm.get_linkage_time + info.get_linkage.time; 1768 lm.defsearch_pf = lm.defsearch_pf + info.def_search.pf; 1769 lm.defsearch_time = lm.defsearch_time + info.def_search.time; 1770 end; 1771 else if type = LINK_CREATE_IF_NOT_FOUND 1772 then do; 1773 lm.total_type_6 = lm.total_type_6 + 1; 1774 lm.type_6_pf = lm.type_6_pf + elapsed_pf; 1775 lm.type_6_time = lm.type_6_time + elapsed_time; 1776 end; 1777 else do; 1778 if info.type = Make_entry | info.type = Make_ptr 1779 then lm.tot_make_ptr = lm.tot_make_ptr + 1; 1780 lm.total_others = lm.total_others + 1; 1781 lm.others_pf = lm.others_pf + elapsed_pf; 1782 lm.others_time = lm.others_time + elapsed_time; 1783 end; 1784 1785 end meter; 1786 1787 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1788 1789 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1790 1791 1792 trap: 1793 proc (infop, /** call_info pointer (in ) */ 1794 target_linkagep, /** target linkage scn (in ) */ 1795 targetp); /** return value (in ) */ 1796 1797 /*** ****************************************************************/ 1798 /*** */ 1799 /*** Name: trap */ 1800 /*** Input: infop, target_linkagep, targetp */ 1801 /*** Function: executes first reference traps in the target of */ 1802 /*** the link snapped. Since this operation involves */ 1803 /*** calling back out to the user ring, we set fix up */ 1804 /*** the maching conditions, error codes, and return */ 1805 /*** values prior to calling trap_caller_caller_. */ 1806 /*** If there are no traps, we return and exit through */ 1807 /*** the normal mechanism. */ 1808 /*** Output: none */ 1809 /*** */ 1810 /*** ****************************************************************/ 1811 1812 /* parameters */ 1813 1814 dcl infop ptr parameter; 1815 dcl target_linkagep ptr parameter; 1816 dcl targetp ptr parameter; 1817 1818 /* based */ 1819 1820 dcl 01 info aligned like call_info based (infop); 1821 1822 /* now we see if we have first reference traps to run in the target */ 1823 /* of the link we just finished snapping. */ 1824 1825 if target_linkagep ^= null 1826 then do; 1827 if target_linkagep -> virgin_linkage_header.first_ref_relp ^= None 1828 then do; 1829 1830 /* we adjust the machine conditions now, since we won't */ 1831 /* return from trap_caller_caller_ . . . */ 1832 1833 call adjust_mc (mcp); 1834 1835 /* set the return values */ 1836 1837 if info.type ^= Link_fault 1838 then a_code = 0; 1839 1840 if /* case */ info.type = Make_ptr 1841 then a_targetp = targetp; 1842 else if info.type = Make_entry 1843 then addr (a_targete) -> based_entry.code_ptr = targetp; 1844 1845 /* now we complete tracing of the fault, since the trap */ 1846 /* should not return. */ 1847 1848 call page$enter_data ((targetp), linkage_fault_end); 1849 1850 /* trap back to the user ring and execute the firstref traps */ 1851 1852 call trap_caller_caller_ (info.mcp, target_linkagep, null, 1853 null, null, info.codep, code); 1854 1855 /* just in case we returned. . . */ 1856 1857 if info.mcp ^= null 1858 then call exit (infop, code, null); 1859 end; 1860 1861 end; 1862 1863 end trap; 1864 1865 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1866 1867 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1868 1869 1870 adjust_mc: 1871 proc (mcp); /** machine conditions (in ) */ 1872 1873 /*** ****************************************************************/ 1874 /*** */ 1875 /*** Name: adjust_mc */ 1876 /*** Input: mcp */ 1877 /*** Function: adjusts the fault machine conditions so that the */ 1878 /*** fault can be restarted. */ 1879 /*** Output: none. */ 1880 /*** */ 1881 /*** ****************************************************************/ 1882 1883 /* parameters */ 1884 1885 dcl mcp ptr parameter; 1886 1887 /* based */ 1888 1889 dcl 01 instr aligned based (instrp), 1890 02 address bit (18) unaligned, 1891 02 op_code bit (12) unaligned, 1892 02 modifier bit (6) unaligned; 1893 1894 /* automatic */ 1895 1896 dcl scup ptr automatic; 1897 dcl instrp ptr automatic; 1898 1899 /* don't try fixing machine conditions that aren't there. . . */ 1900 1901 if mcp = null 1902 then return; 1903 1904 scup = addr (mcp -> mc.scu); 1905 instrp = addr (scup -> scu.even_inst); 1906 instr.address = scup -> scu.ca; 1907 instr.modifier = indirect; 1908 1909 end adjust_mc; 1910 1911 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1912 1913 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1914 1915 connect_fail_handler_: 1916 proc (a_mcp, /** machine conditions (in ) */ 1917 a_condition_name, /** condition name (in ) */ 1918 a_wcp, /** crawlout info (in ) */ 1919 a_infop, /** condition info (in ) */ 1920 a_continue_flag); /** continue flag (out) */ 1921 1922 /*** ****************************************************************/ 1923 /*** */ 1924 /*** Name: connect_fail_handler_ */ 1925 /*** Input: mcp, condition_name, wcp, infop, continue_flag */ 1926 /*** Function: handles the seg_fault condition. This handler */ 1927 /*** in enabled prior to the definition search in */ 1928 /*** type-4 and type-6 links. When invoked, the */ 1929 /*** faulting segment is compared with the global */ 1930 /*** variable segp, it the segments are not the same, */ 1931 /*** this means we have faulted somewhere unexpected, */ 1932 /*** so we continue to signal. If the fault occurred */ 1933 /*** on the expected segment, we assume it is because */ 1934 /*** of a connection failure and simply return abort */ 1935 /*** the link fault returning the appropriate code. */ 1936 /*** */ 1937 /*** NB. Because of the machanism involved, this */ 1938 /*** procedure assumes that the global variables */ 1939 /*** segp and call_infop are set prior to the */ 1940 /*** establishment of the condition handler. */ 1941 /*** Output: none */ 1942 /*** */ 1943 /*** ****************************************************************/ 1944 1945 /* parameters */ 1946 1947 dcl a_mcp ptr parameter; 1948 dcl a_condition_name char (*) parameter; 1949 dcl a_wcp ptr parameter; 1950 dcl a_infop ptr parameter; 1951 dcl a_continue_flag bit (1) parameter; 1952 1953 /* automatic */ 1954 1955 dcl faulted_segno fixed bin (18) automatic; 1956 dcl segno fixed bin (18) automatic; 1957 dcl scup ptr automatic; 1958 1959 /* get the segment numbers of the faulting segment and the target */ 1960 /* segment of the current link snapping operation */ 1961 1962 a_continue_flag = false; 1963 scup = addr (a_mcp -> mc.scu); 1964 faulted_segno = bin (scup -> scu.tpr.tsr, 18); 1965 segno = bin (baseno (segp), 18); 1966 1967 /* if they are different, continue to signal */ 1968 1969 if faulted_segno ^= segno 1970 then do; 1971 a_continue_flag = true; 1972 return; 1973 end; 1974 1975 /* otherwise assume a connection failure, and return the code */ 1976 1977 connect_fail_code = a_mcp -> mc.errcode; 1978 1979 /* NB. here we set a global code and do a non-local goto which */ 1980 /* then calls the exit procedure rather than calling exit */ 1981 /* directly in order to keep the exit and adjust_mc procedures */ 1982 /* as quick procedures. */ 1983 1984 goto CONNECT_FAIL_EXIT; 1985 1986 end connect_fail_handler_; 1987 1988 CONNECT_FAIL_EXIT: 1989 call exit (call_infop, connect_fail_code, null); 1990 1991 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1992 1993 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1994 1995 1996 exit: 1997 proc (infop, /** call_info pointer (in ) */ 1998 code, /** code to return (in ) */ 1999 targetp); /** target (for trace) (in ) */ 2000 2001 /*** ****************************************************************/ 2002 /*** */ 2003 /*** Name: exit */ 2004 /*** Input: info, code, targetp */ 2005 /*** Function: returns from the fault or gate entry and cleans */ 2006 /*** up. This procedure differs depending on where */ 2007 /*** we entered from: */ 2008 /*** link_fault - save the code in the machine */ 2009 /*** conditions, adjust the machine */ 2010 /*** conditions to allow restart, reset */ 2011 /*** the validation level back, */ 2012 /*** complete the fault trace, and exit */ 2013 /*** link_force - set the code to be returned, */ 2014 /*** complete the fault trace, and exit */ 2015 /*** make_ptr - set the return pointer and code, */ 2016 /*** complete the fault trace, and exit */ 2017 /*** make_entry - set the return entry and code, */ 2018 /*** complete the fault trace, and exit */ 2019 /*** */ 2020 /*** NB. When completing the fault trace, the code to */ 2021 /*** be returned is examined. If it it nonzero, */ 2022 /*** the info_ptr for the call to page$enter_data */ 2023 /*** is 0|0. If the code is zero, the targetp */ 2024 /*** value is passed to page$enter_data. */ 2025 /*** Output: none */ 2026 /*** */ 2027 /*** ****************************************************************/ 2028 2029 /* parameters */ 2030 2031 dcl infop ptr parameter; 2032 dcl code fixed bin (35) parameter; 2033 dcl targetp ptr parameter; 2034 2035 /* based */ 2036 2037 dcl 01 info aligned like call_info based (infop); 2038 dcl 01 exit_mc aligned like mc based (info.mcp); 2039 2040 /* if we had a make_ptr or make_entry call, set the return value */ 2041 2042 if /* case */ info.type = Make_ptr 2043 then a_targetp = targetp; 2044 else if info.type = Make_entry 2045 then addr (a_targete) -> based_entry.code_ptr = targetp; 2046 2047 /* return the code */ 2048 2049 if info.type = Link_fault 2050 then do; 2051 call level$set ((info.save_ring)); 2052 exit_mc.errcode = code; 2053 call adjust_mc (info.mcp); 2054 end; 2055 else a_code = code; 2056 2057 /* complete fault tracing */ 2058 2059 if code = 0 2060 then call page$enter_data ((targetp), linkage_fault_end); 2061 else call page$enter_data (baseptr (0), linkage_fault_end); 2062 2063 /* non-local goto to outer level and return */ 2064 2065 goto EXIT; 2066 2067 end exit; 2068 2069 EXIT: 2070 return; 2071 2072 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 2073 2074 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 2075 2076 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 */ 2077 2078 2 1 /* BEGIN INCLUDE FILE its.incl.pl1 2 2* modified 27 July 79 by JRDavis to add its_unsigned 2 3* Internal format of ITS pointer, including ring-number field for follow-on processor */ 2 4 2 5 dcl 1 its based aligned, /* declaration for ITS type pointer */ 2 6 2 pad1 bit (3) unaligned, 2 7 2 segno bit (15) unaligned, /* segment number within the pointer */ 2 8 2 ringno bit (3) unaligned, /* ring number within the pointer */ 2 9 2 pad2 bit (9) unaligned, 2 10 2 its_mod bit (6) unaligned, /* should be 43(8) */ 2 11 2 12 2 offset bit (18) unaligned, /* word offset within the addressed segment */ 2 13 2 pad3 bit (3) unaligned, 2 14 2 bit_offset bit (6) unaligned, /* bit offset within the word */ 2 15 2 pad4 bit (3) unaligned, 2 16 2 mod bit (6) unaligned; /* further modification */ 2 17 2 18 dcl 1 itp based aligned, /* declaration for ITP type pointer */ 2 19 2 pr_no bit (3) unaligned, /* number of pointer register to use */ 2 20 2 pad1 bit (27) unaligned, 2 21 2 itp_mod bit (6) unaligned, /* should be 41(8) */ 2 22 2 23 2 offset bit (18) unaligned, /* word offset from pointer register word offset */ 2 24 2 pad2 bit (3) unaligned, 2 25 2 bit_offset bit (6) unaligned, /* bit offset relative to new word offset */ 2 26 2 pad3 bit (3) unaligned, 2 27 2 mod bit (6) unaligned; /* further modification */ 2 28 2 29 2 30 dcl 1 its_unsigned based aligned, /* just like its, but with unsigned binary */ 2 31 2 pad1 bit (3) unaligned, 2 32 2 segno fixed bin (15) unsigned unaligned, 2 33 2 ringno fixed bin (3) unsigned unaligned, 2 34 2 pad2 bit (9) unaligned, 2 35 2 its_mod bit (6) unaligned, 2 36 2 37 2 offset fixed bin (18) unsigned unaligned, 2 38 2 pad3 bit (3) unaligned, 2 39 2 bit_offset fixed bin (6) unsigned unaligned, 2 40 2 pad4 bit (3) unaligned, 2 41 2 mod bit (6) unaligned; 2 42 2 43 dcl 1 itp_unsigned based aligned, /* just like itp, but with unsigned binary where appropriate */ 2 44 2 pr_no fixed bin (3) unsigned unaligned, 2 45 2 pad1 bit (27) unaligned, 2 46 2 itp_mod bit (6) unaligned, 2 47 2 48 2 offset fixed bin (18) unsigned unaligned, 2 49 2 pad2 bit (3) unaligned, 2 50 2 bit_offset fixed bin (6) unsigned unaligned, 2 51 2 pad3 bit (3) unaligned, 2 52 2 mod bit (6) unaligned; 2 53 2 54 2 55 dcl ITS_MODIFIER bit (6) unaligned internal static options (constant) init ("43"b3); 2 56 dcl ITP_MODIFIER bit (6) unaligned internal static options (constant) init ("41"b3); 2 57 2 58 /* END INCLUDE FILE its.incl.pl1 */ 2079 2080 3 1 /* START OF: link_meters.incl.pl1 * * * * * * * * * * * * * * * * */ 3 2 3 3 /* Written December 1980 by J. Bongiovanni */ 3 4 3 5 /* link_meters is an array of data maintained by link_snap. 3 6* It is updated on each successful call to link_snap, based 3 7* on the virtual cpu time consumed during the call, as follows: 3 8* 3 9* vcpu time (ms.) array index 3 10* 3 11* < 25 1 3 12* 25 - 50 2 3 13* 50 - 75 3 3 14* > 75 4 3 15**/ 3 16 3 17 dcl 1 link_meters (4) aligned based, 3 18 2 total fixed bin (35), /* total number calls */ 3 19 2 pf fixed bin (30), /* total number page faults */ 3 20 2 time fixed bin (35), /* total vcpu time (microsec.) */ 3 21 2 search_pf fixed bin (30), /* page faults while searching for segment */ 3 22 2 search_time fixed bin (35), /* vcpu time while searching for segment */ 3 23 2 get_linkage_pf fixed bin (30), /* page faults while combining linkage */ 3 24 2 get_linkage_time fixed bin (35), /* vcpu time while combining linkage */ 3 25 2 defsearch_pf fixed bin (30), /* page faults while searching definitions */ 3 26 2 defsearch_time fixed bin (35), /* vcpu time while searching definitions */ 3 27 2 total_others fixed bin (30), /* count of types 1, 2, and 5 */ 3 28 2 others_pf fixed bin (30), /* page faults while processing types 1, 2, 5 */ 3 29 2 others_time fixed bin (35), /* vcpu time while processing types 1, 2, 5 */ 3 30 2 tot_make_ptr fixed bin (30), /* count of calls to make_ptr and make_seg */ 3 31 2 total_type_6 fixed bin (30), /* count of type 6 */ 3 32 2 create_pf fixed bin (30), /* obsolete - retained for metering consistency */ 3 33 2 create_time fixed bin (35), /* obsolete - retained for metering consistency */ 3 34 2 type_6_pf fixed bin (30), /* page faults while processing type 6 */ 3 35 2 type_6_time fixed bin (35); /* vcpu time while processing type 6 */ 3 36 3 37 3 38 /* END OF: link_meters.incl.pl1 * * * * * * * * * * * * * * * * */ 2082 4 1 /* */ 4 2 /* BEGIN INCLUDE FILE mc.incl.pl1 Created Dec 72 for 6180 - WSS. */ 4 3 /* Modified 06/07/76 by Greenberg for mc.resignal */ 4 4 /* Modified 07/07/76 by Morris for fault register data */ 4 5 /* Modified 08/28/80 by J. A. Bush for the DPS8/70M CVPU */ 4 6 /* Modified '82 to make values constant */ 4 7 4 8 /* words 0-15 pointer registers */ 4 9 4 10 dcl mcp ptr; 4 11 4 12 dcl 1 mc based (mcp) aligned, 4 13 2 prs (0:7) ptr, /* POINTER REGISTERS */ 4 14 (2 regs, /* registers */ 4 15 3 x (0:7) bit (18), /* index registers */ 4 16 3 a bit (36), /* accumulator */ 4 17 3 q bit (36), /* q-register */ 4 18 3 e bit (8), /* exponent */ 4 19 3 pad1 bit (28), 4 20 3 t bit (27), /* timer register */ 4 21 3 pad2 bit (6), 4 22 3 ralr bit (3), /* ring alarm register */ 4 23 4 24 2 scu (0:7) bit (36), 4 25 4 26 2 mask bit (72), /* mem controller mask at time of fault */ 4 27 2 ips_temp bit (36), /* Temporary storage for IPS info */ 4 28 2 errcode fixed bin (35), /* fault handler's error code */ 4 29 2 fim_temp, 4 30 3 unique_index bit (18) unal, /* unique index for restarting faults */ 4 31 3 resignal bit (1) unal, /* recompute signal name with fcode below */ 4 32 3 fcode bit (17) unal, /* fault code used as index to FIM table and SCT */ 4 33 2 fault_reg bit (36), /* fault register */ 4 34 2 pad2 bit (1), 4 35 2 cpu_type fixed bin (2) unsigned, /* L68 = 0, DPS8/70M = 1 */ 4 36 2 ext_fault_reg bit (15), /* extended fault reg for DPS8/70M CPU */ 4 37 2 fault_time bit (54), /* time of fault */ 4 38 4 39 2 eis_info (0:7) bit (36)) unaligned; 4 40 4 41 4 42 dcl (apx fixed bin init (0), 4 43 abx fixed bin init (1), 4 44 bpx fixed bin init (2), 4 45 bbx fixed bin init (3), 4 46 lpx fixed bin init (4), 4 47 lbx fixed bin init (5), 4 48 spx fixed bin init (6), 4 49 sbx fixed bin init (7)) internal static options (constant); 4 50 4 51 4 52 4 53 4 54 dcl scup ptr; 4 55 4 56 dcl 1 scu based (scup) aligned, /* SCU DATA */ 4 57 4 58 4 59 /* WORD (0) */ 4 60 4 61 (2 ppr, /* PROCEDURE POINTER REGISTER */ 4 62 3 prr bit (3), /* procedure ring register */ 4 63 3 psr bit (15), /* procedure segment register */ 4 64 3 p bit (1), /* procedure privileged bit */ 4 65 4 66 2 apu, /* APPENDING UNIT STATUS */ 4 67 3 xsf bit (1), /* ext seg flag - IT modification */ 4 68 3 sdwm bit (1), /* match in SDW Ass. Mem. */ 4 69 3 sd_on bit (1), /* SDW Ass. Mem. ON */ 4 70 3 ptwm bit (1), /* match in PTW Ass. Mem. */ 4 71 3 pt_on bit (1), /* PTW Ass. Mem. ON */ 4 72 3 pi_ap bit (1), /* Instr Fetch or Append cycle */ 4 73 3 dsptw bit (1), /* Fetch of DSPTW */ 4 74 3 sdwnp bit (1), /* Fetch of SDW non paged */ 4 75 3 sdwp bit (1), /* Fetch of SDW paged */ 4 76 3 ptw bit (1), /* Fetch of PTW */ 4 77 3 ptw2 bit (1), /* Fetch of pre-paged PTW */ 4 78 3 fap bit (1), /* Fetch of final address paged */ 4 79 3 fanp bit (1), /* Fetch of final address non-paged */ 4 80 3 fabs bit (1), /* Fetch of final address absolute */ 4 81 4 82 2 fault_cntr bit (3), /* number of retrys of EIS instructions */ 4 83 4 84 4 85 /* WORD (1) */ 4 86 4 87 2 fd, /* FAULT DATA */ 4 88 3 iro bit (1), /* illegal ring order */ 4 89 3 oeb bit (1), /* out of execute bracket */ 4 90 3 e_off bit (1), /* no execute */ 4 91 3 orb bit (1), /* out of read bracket */ 4 92 3 r_off bit (1), /* no read */ 4 93 3 owb bit (1), /* out of write bracket */ 4 94 3 w_off bit (1), /* no write */ 4 95 3 no_ga bit (1), /* not a gate */ 4 96 3 ocb bit (1), /* out of call bracket */ 4 97 3 ocall bit (1), /* outward call */ 4 98 3 boc bit (1), /* bad outward call */ 4 99 3 inret bit (1), /* inward return */ 4 100 3 crt bit (1), /* cross ring transfer */ 4 101 3 ralr bit (1), /* ring alarm register */ 4 102 3 am_er bit (1), /* associative memory fault */ 4 103 3 oosb bit (1), /* out of segment bounds */ 4 104 3 paru bit (1), /* processor parity upper */ 4 105 3 parl bit (1), /* processor parity lower */ 4 106 3 onc_1 bit (1), /* op not complete type 1 */ 4 107 3 onc_2 bit (1), /* op not complete type 2 */ 4 108 4 109 2 port_stat, /* PORT STATUS */ 4 110 3 ial bit (4), /* illegal action lines */ 4 111 3 iac bit (3), /* illegal action channel */ 4 112 3 con_chan bit (3), /* connect channel */ 4 113 4 114 2 fi_num bit (5), /* (fault/interrupt) number */ 4 115 2 fi_flag bit (1), /* 1 => fault, 0 => interrupt */ 4 116 4 117 4 118 /* WORD (2) */ 4 119 4 120 2 tpr, /* TEMPORARY POINTER REGISTER */ 4 121 3 trr bit (3), /* temporary ring register */ 4 122 3 tsr bit (15), /* temporary segment register */ 4 123 4 124 2 pad2 bit (9), 4 125 4 126 2 cpu_no bit (3), /* CPU number */ 4 127 4 128 2 delta bit (6), /* tally modification DELTA */ 4 129 4 130 4 131 /* WORD (3) */ 4 132 4 133 2 word3 bit (18), 4 134 4 135 2 tsr_stat, /* TSR STATUS for 1,2,&3 word instructions */ 4 136 3 tsna, /* Word 1 status */ 4 137 4 prn bit (3), /* Word 1 PR number */ 4 138 4 prv bit (1), /* Word 1 PR valid bit */ 4 139 3 tsnb, /* Word 2 status */ 4 140 4 prn bit (3), /* Word 2 PR number */ 4 141 4 prv bit (1), /* Word 2 PR valid bit */ 4 142 3 tsnc, /* Word 3 status */ 4 143 4 prn bit (3), /* Word 3 PR number */ 4 144 4 prv bit (1), /* Word 3 PR valid bit */ 4 145 4 146 2 tpr_tbr bit (6), /* TPR.TBR field */ 4 147 4 148 4 149 /* WORD (4) */ 4 150 4 151 2 ilc bit (18), /* INSTRUCTION COUNTER */ 4 152 4 153 2 ir, /* INDICATOR REGISTERS */ 4 154 3 zero bit (1), /* zero indicator */ 4 155 3 neg bit (1), /* negative indicator */ 4 156 3 carry bit (1), /* carryry indicator */ 4 157 3 ovfl bit (1), /* overflow indicator */ 4 158 3 eovf bit (1), /* eponent overflow */ 4 159 3 eufl bit (1), /* exponent underflow */ 4 160 3 oflm bit (1), /* overflow mask */ 4 161 3 tro bit (1), /* tally runout */ 4 162 3 par bit (1), /* parity error */ 4 163 3 parm bit (1), /* parity mask */ 4 164 3 bm bit (1), /* ^bar mode */ 4 165 3 tru bit (1), /* truncation mode */ 4 166 3 mif bit (1), /* multi-word instruction mode */ 4 167 3 abs bit (1), /* absolute mode */ 4 168 3 hex bit (1), /* hexadecimal exponent mode */ 4 169 3 pad bit (3), 4 170 4 171 4 172 /* WORD (5) */ 4 173 4 174 2 ca bit (18), /* COMPUTED ADDRESS */ 4 175 4 176 2 cu, /* CONTROL UNIT STATUS */ 4 177 3 rf bit (1), /* on first cycle of repeat instr */ 4 178 3 rpt bit (1), /* repeat instruction */ 4 179 3 rd bit (1), /* repeat double instruction */ 4 180 3 rl bit (1), /* repeat link instruciton */ 4 181 3 pot bit (1), /* IT modification */ 4 182 3 pon bit (1), /* return type instruction */ 4 183 3 xde bit (1), /* XDE from Even location */ 4 184 3 xdo bit (1), /* XDE from Odd location */ 4 185 3 poa bit (1), /* operation preparation */ 4 186 3 rfi bit (1), /* tells CPU to refetch instruction */ 4 187 3 its bit (1), /* ITS modification */ 4 188 3 if bit (1), /* fault occured during instruction fetch */ 4 189 4 190 2 cpu_tag bit (6)) unaligned, /* computed tag field */ 4 191 4 192 4 193 /* WORDS (6,7) */ 4 194 4 195 2 even_inst bit (36), /* even instruction of faulting pair */ 4 196 4 197 2 odd_inst bit (36); /* odd instruction of faulting pair */ 4 198 4 199 4 200 4 201 4 202 4 203 4 204 /* ALTERNATE SCU DECLARATION */ 4 205 4 206 4 207 dcl 1 scux based (scup) aligned, 4 208 4 209 (2 pad0 bit (36), 4 210 4 211 2 fd, /* GROUP II FAULT DATA */ 4 212 3 isn bit (1), /* illegal segment number */ 4 213 3 ioc bit (1), /* illegal op code */ 4 214 3 ia_am bit (1), /* illegal address - modifier */ 4 215 3 isp bit (1), /* illegal slave procedure */ 4 216 3 ipr bit (1), /* illegal procedure */ 4 217 3 nea bit (1), /* non existent address */ 4 218 3 oobb bit (1), /* out of bounds */ 4 219 3 pad bit (29), 4 220 4 221 2 pad2 bit (36), 4 222 4 223 2 pad3a bit (18), 4 224 4 225 2 tsr_stat (0:2), /* TSR STATUS as an ARRAY */ 4 226 3 prn bit (3), /* PR number */ 4 227 3 prv bit (1), /* PR valid bit */ 4 228 4 229 2 pad3b bit (6)) unaligned, 4 230 4 231 2 pad45 (0:1) bit (36), 4 232 4 233 2 instr (0:1) bit (36); /* Instruction ARRAY */ 4 234 4 235 4 236 4 237 /* END INCLUDE FILE mc.incl.pl1 */ 2083 2084 5 1 /* BEGIN INCLUDE FILE object_link_dcls.incl.pl1 BIM 1981 from linkdcl */ 5 2 5 3 5 4 /****^ HISTORY COMMENTS: 5 5* 1) change(86-05-02,Elhard), approve(86-05-02,MCR7391), 5 6* audit(86-11-18,Schroth), install(86-11-20,MR12.0-1222): 5 7* Modified to add partial_link structure for an object MSF partially snapped 5 8* link. 5 9* 2) change(86-11-13,DGHowe), approve(86-11-13,MCR7391), audit(86-11-13,Zwick), 5 10* install(86-11-20,MR12.0-1222): 5 11* Added a declaration of FAULT_TAG_1, FAULT_TAG_2 and FAULT_TAG_3. 5 12* END HISTORY COMMENTS */ 5 13 5 14 5 15 /* format: style3 */ 5 16 /* everything you ever wanted in a linkage section */ 5 17 5 18 /* 5 19* Last Modified (Date and Reason): 5 20* 15 Nov 1971 by C Garman 5 21* 6/75 by M.Weaver to add virgin_linkage_header declaration 5 22* 6/75 by S.Webber to comment existing structures better 5 23* 9/77 by M. Weaver to add run_depth to link 5 24* 7/81 by B. Margulies for firstref structure, unsigned fixed bins. 5 25* 3/83 by M. Weaver to add flags overlaying def_ptr 5 26**/ 5 27 5 28 declare 1 object_link based aligned, /* link pair in linkage section */ 5 29 2 header_relp fixed bin (17) unal, /* rel pointer to beginning of linkage, always negative */ 5 30 2 ringno fixed bin (3) unsigned unal, /* MBZ */ 5 31 2 mbz bit (6) unal, 5 32 2 run_depth fixed bin (2) unal, /* run unit depth, filled when link is snapped */ 5 33 2 tag bit (6) unal, /* fault tag. 46(8) if not snapped, 43(8) if snapped */ 5 34 2 expression_relp fixed bin (18) unsigned unal, /* pointer (rel to defs) of expression word */ 5 35 2 mbz2 bit (12) unal, 5 36 2 modifier bit (6) unal; /* modifier to be left in snapped link */ 5 37 5 38 declare 1 partial_link based aligned, /* partially snapped link */ 5 39 2 type fixed bin (3) unsigned unal, /* target section of link */ 5 40 2 component fixed bin (15) unsigned unal, /* target component index */ 5 41 2 mbz1 bit (12) unal, 5 42 2 tag bit (6) unal, /* fault tag 3 47(8), ITS 43(8) if snapped */ 5 43 5 44 2 offset fixed bin (18) unsigned unal, /* word offset of link */ 5 45 2 mbz2 bit (3) unal, 5 46 2 bit_offset fixed bin (6) unsigned unal, /* bit offset (in practice, always 0) */ 5 47 2 mbz3 bit (3) unal, 5 48 2 modifier bit (6) unal; /* modifier to be left in snapped link */ 5 49 5 50 declare 1 linkage_header based aligned, /* linkage block header */ 5 51 2 def_ptr ptr, /* pointer to definition section */ 5 52 2 symbol_ptr ptr unal, /* pointer to symbol section in object segment */ 5 53 2 original_linkage_ptr 5 54 ptr unal, /* pointer to linkage section in object segment */ 5 55 2 unused bit (72), 5 56 2 stats, 5 57 3 begin_links fixed bin (18) unsigned unal, /* offset (rel to this section) of first link */ 5 58 3 block_length fixed bin (18) unsigned unal, /* number of words in this linkage section */ 5 59 3 segment_number 5 60 fixed bin (18) unsigned unal, /* text segment number associated with this section */ 5 61 3 static_length fixed bin (18) unsigned unal; /* number of words of static for this segment */ 5 62 5 63 declare 1 linkage_header_flags 5 64 aligned based, /* overlay of def_ptr for flags */ 5 65 2 pad1 bit (28) unaligned, /* flags are in first word */ 5 66 2 static_vlas bit (1) unaligned, /* static section "owns" some LA/VLA segments */ 5 67 2 perprocess_static 5 68 bit (1) unaligned, /* 1 copy of static section is shared among all tasks/run units */ 5 69 2 pad2 bit (6) unaligned; 5 70 5 71 declare 1 virgin_linkage_header 5 72 aligned based, /* template for linkage header in object segment */ 5 73 2 pad bit (30) unaligned, /* is filled in by linker */ 5 74 2 defs_in_link bit (6) unaligned, /* =o20 if defs in linkage (nonstandard) */ 5 75 2 def_offset fixed bin (18) unsigned unaligned, 5 76 /* offset of definition section */ 5 77 2 first_ref_relp fixed bin (18) unsigned unaligned, 5 78 /* offset of trap-at-first-reference offset array */ 5 79 2 filled_in_later bit (144), 5 80 2 link_begin fixed bin (18) unsigned unaligned, 5 81 /* offset of first link */ 5 82 2 linkage_section_lng 5 83 fixed bin (18) unsigned unaligned, 5 84 /* length of linkage section */ 5 85 2 segno_pad fixed bin (18) unsigned unaligned, 5 86 /* will be segment number of copied linkage */ 5 87 2 static_length fixed bin (18) unsigned unaligned; 5 88 /* length of static section */ 5 89 5 90 declare 1 fr_traps based aligned, /* First Reference Trap Procedures */ 5 91 2 decl_vers fixed bin, /* version of this struc, value=1, ABS reloc */ 5 92 2 n_traps fixed bin, /* number of traps on this segment, ABS */ 5 93 2 trap_array (n_fr_traps refer (fr_traps.n_traps)) aligned, 5 94 3 call_relp fixed bin (18) unsigned unaligned, 5 95 /* LINK18, offset of link defining procedure to call */ 5 96 3 info_relp fixed bin (18) unsigned unaligned; 5 97 /* LINK18, offser of link defining argument list for trap proc */ 5 98 5 99 declare FR_TRAPS_VERSION_1 init (1) fixed bin internal static options (constant); 5 100 declare FAULT_TAG_1 bit(6) unaligned init ("40"b3) static options (constant); 5 101 declare FAULT_TAG_2 bit(6) unaligned init ("46"b3) static options (constant); 5 102 declare FAULT_TAG_3 bit(6) unaligned init ("47"b3) static options (constant); 5 103 5 104 /* END INCLUDE FILE object_link_dcls.incl.pl1 */ 2085 2086 6 1 /* BEGIN INCLUDE FILE ... stack_header.incl.pl1 .. 3/72 Bill Silver */ 6 2 /* modified 7/76 by M. Weaver for *system links and more system use of areas */ 6 3 /* modified 3/77 by M. Weaver to add rnt_ptr */ 6 4 /* Modified April 1983 by C. Hornig for tasking */ 6 5 6 6 /****^ HISTORY COMMENTS: 6 7* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), 6 8* audit(86-08-05,Schroth), install(86-11-03,MR12.0-1206): 6 9* added the heap_header_ptr definition. 6 10* 2) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 6 11* audit(86-10-10,Fawcett), install(86-11-03,MR12.0-1206): 6 12* Modified to support control point management. These changes were actually 6 13* made in February 1985 by G. Palter. 6 14* 3) change(86-10-22,Fawcett), approve(86-10-22,MCR7473), 6 15* audit(86-10-22,Farley), install(86-11-03,MR12.0-1206): 6 16* Remove the old_lot pointer and replace it with cpm_data_ptr. Use the 18 6 17* bit pad after cur_lot_size for the cpm_enabled. This was done to save some 6 18* space int the stack header and change the cpd_ptr unal to cpm_data_ptr 6 19* (ITS pair). 6 20* END HISTORY COMMENTS */ 6 21 6 22 /* format: style2 */ 6 23 6 24 dcl sb ptr; /* the main pointer to the stack header */ 6 25 6 26 dcl 1 stack_header based (sb) aligned, 6 27 2 pad1 (4) fixed bin, /* (0) also used as arg list by outward_call_handler */ 6 28 2 cpm_data_ptr ptr, /* (4) pointer to control point which owns this stack */ 6 29 2 combined_stat_ptr ptr, /* (6) pointer to area containing separate static */ 6 30 2 clr_ptr ptr, /* (8) pointer to area containing linkage sections */ 6 31 2 max_lot_size fixed bin (17) unal, /* (10) DU number of words allowed in lot */ 6 32 2 main_proc_invoked fixed bin (11) unal, /* (10) DL nonzero if main procedure invoked in run unit */ 6 33 2 have_static_vlas bit (1) unal, /* (10) DL "1"b if (very) large arrays are being used in static */ 6 34 2 pad4 bit (2) unal, 6 35 2 run_unit_depth fixed bin (2) unal, /* (10) DL number of active run units stacked */ 6 36 2 cur_lot_size fixed bin (17) unal, /* (11) DU number of words (entries) in lot */ 6 37 2 cpm_enabled bit (18) unal, /* (11) DL non-zero if control point management is enabled */ 6 38 2 system_free_ptr ptr, /* (12) pointer to system storage area */ 6 39 2 user_free_ptr ptr, /* (14) pointer to user storage area */ 6 40 2 null_ptr ptr, /* (16) */ 6 41 2 stack_begin_ptr ptr, /* (18) pointer to first stack frame on the stack */ 6 42 2 stack_end_ptr ptr, /* (20) pointer to next useable stack frame */ 6 43 2 lot_ptr ptr, /* (22) pointer to the lot for the current ring */ 6 44 2 signal_ptr ptr, /* (24) pointer to signal procedure for current ring */ 6 45 2 bar_mode_sp ptr, /* (26) value of sp before entering bar mode */ 6 46 2 pl1_operators_ptr ptr, /* (28) pointer to pl1_operators_$operator_table */ 6 47 2 call_op_ptr ptr, /* (30) pointer to standard call operator */ 6 48 2 push_op_ptr ptr, /* (32) pointer to standard push operator */ 6 49 2 return_op_ptr ptr, /* (34) pointer to standard return operator */ 6 50 2 return_no_pop_op_ptr 6 51 ptr, /* (36) pointer to standard return / no pop operator */ 6 52 2 entry_op_ptr ptr, /* (38) pointer to standard entry operator */ 6 53 2 trans_op_tv_ptr ptr, /* (40) pointer to translator operator ptrs */ 6 54 2 isot_ptr ptr, /* (42) pointer to ISOT */ 6 55 2 sct_ptr ptr, /* (44) pointer to System Condition Table */ 6 56 2 unwinder_ptr ptr, /* (46) pointer to unwinder for current ring */ 6 57 2 sys_link_info_ptr ptr, /* (48) pointer to *system link name table */ 6 58 2 rnt_ptr ptr, /* (50) pointer to Reference Name Table */ 6 59 2 ect_ptr ptr, /* (52) pointer to event channel table */ 6 60 2 assign_linkage_ptr ptr, /* (54) pointer to storage for (obsolete) hcs_$assign_linkage */ 6 61 2 heap_header_ptr ptr, /* (56) pointer to the heap header for this ring */ 6 62 2 trace, 6 63 3 frames, 6 64 4 count fixed bin, /* (58) number of trace frames */ 6 65 4 top_ptr ptr unal, /* (59) pointer to last trace frame */ 6 66 3 in_trace bit (36) aligned, /* (60) trace antirecursion flag */ 6 67 2 pad2 bit (36), /* (61) */ 6 68 2 pad5 pointer; /* (62) pointer to future stuff */ 6 69 6 70 /* The following offset refers to a table within the pl1 operator table. */ 6 71 6 72 dcl tv_offset fixed bin init (361) internal static; 6 73 /* (551) octal */ 6 74 6 75 6 76 /* The following constants are offsets within this transfer vector table. */ 6 77 6 78 dcl ( 6 79 call_offset fixed bin init (271), 6 80 push_offset fixed bin init (272), 6 81 return_offset fixed bin init (273), 6 82 return_no_pop_offset fixed bin init (274), 6 83 entry_offset fixed bin init (275) 6 84 ) internal static; 6 85 6 86 6 87 6 88 6 89 6 90 /* The following declaration is an overlay of the whole stack header. Procedures which 6 91* move the whole stack header should use this overlay. 6 92**/ 6 93 6 94 dcl stack_header_overlay (size (stack_header)) fixed bin based (sb); 6 95 6 96 6 97 6 98 /* END INCLUDE FILE ... stack_header.incl.pl1 */ 2087 2088 7 1 /* BEGIN INCLUDE FILE ... system_link_names.incl.pl1 */ 7 2 7 3 7 4 /****^ HISTORY COMMENTS: 7 5* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), audit(86-11-12,Zwick), 7 6* install(86-11-20,MR12.0-1222): 7 7* added the declaration of the heap_header. 7 8* 2) change(86-10-20,DGHowe), approve(86-10-20,MCR7420), audit(86-11-12,Zwick), 7 9* install(86-11-20,MR12.0-1222): 7 10* add the seg ptr to the variable node structure. 7 11* END HISTORY COMMENTS */ 7 12 7 13 7 14 /* created by M. Weaver 7/28/76 */ 7 15 /* Modified: 82-11-19 by T. Oke to add LIST_TEMPLATE_INIT. */ 7 16 /* Modified 02/11/83 by M. Weaver to add have_vla_variables flag */ 7 17 7 18 7 19 dcl 1 variable_table_header aligned based, /* header for name table */ 7 20 2 hash_table (0:63) ptr unaligned, /* hash table for variable nodes */ 7 21 2 total_search_time fixed bin (71), /* total time to search for variables */ 7 22 2 total_allocation_time fixed bin (71), /* total time spent allocating and initializing nodes and variables */ 7 23 2 number_of_searches fixed bin, /* number of times names were looked up */ 7 24 2 number_of_variables fixed bin (35), /* number of variables allocated by the linker, incl deletions */ 7 25 2 flags unaligned, 7 26 3 have_vla_variables bit (1) unaligned, /* on if some variables are > sys_info$max_seg_size */ 7 27 3 pad bit (11) unaligned, 7 28 2 cur_num_of_variables fixed bin (24) unal, /* current number of variables allocated */ 7 29 2 number_of_steps fixed bin, /* total number of nodes looked at */ 7 30 2 total_allocated_size fixed bin (35); /* current amount of storage in user area */ 7 31 7 32 7 33 dcl 1 variable_node aligned based, /* individual variable information */ 7 34 2 forward_thread ptr unaligned, /* thread to next node off same hash bucket */ 7 35 2 vbl_size fixed bin (24) unsigned unaligned, /* length in words of variable */ 7 36 2 init_type fixed bin (11) unaligned, /* 0=not init; 3=init template; 4=area 5=list_template*/ 7 37 2 time_allocated fixed bin (71), /* time when variable was allocated */ 7 38 2 vbl_ptr ptr, /* pointer to variable's storage */ 7 39 2 init_ptr ptr, /* pointer to original init info in object seg */ 7 40 2 name_size fixed bin(21) aligned, /* length of name in characters */ 7 41 2 name char (nchars refer (variable_node.name_size)), /* name of variable */ 7 42 2 seg_ptr pointer; 7 43 7 44 /* variable_node.seg_ptr 7 45* Is a pointer to the segment containing the initialization information 7 46* for this variable. It is used as a segment base pointer for external 7 47* pointer initialization via list_init_. 7 48* 7 49* The init_ptr can not be used as a reference to the defining segment 7 50* due to the possibility of set_fortran_common being used to initialize 7 51* the external variables. sfc will generate an initialization information 7 52* structure if multiple intialization sizes are found in the specified 7 53* segments. sfc stores the address of this structure in the init_ptr field. 7 54* This is one reason why sfc does not perform external pointer 7 55* initialization. 7 56* 7 57* The seg_ptr is set to point at the segment used to define the 7 58* initialization information. term_ sets this field to null on termination 7 59* due to the possiblity of executing a different segment which defines 7 60* initialization information. In this way the seg_ptr field will either 7 61* be valid or null. 7 62**/ 7 63 7 64 dcl 1 heap_header based, 7 65 2 version char(8), /* specifies the verison of the header */ 7 66 2 heap_name_list_ptr pointer, /* points to the variable_table_header for this heap */ 7 67 2 previous_heap_ptr pointer, /* points to the previous heap or is null */ 7 68 2 area_ptr pointer, /* points to the heap area */ 7 69 2 execution_level fixed bin (17); /* specifies the execution level this header deals with */ 7 70 7 71 dcl heap_header_version_1 char(8) static options (constant) 7 72 init ("Heap_v01"); 7 73 7 74 7 75 /* END INCLUDE FILE ... system_link_names.incl.pl1 */ 2089 2090 8 1 /* BEGIN INCLUDE FILE trace_types.incl.pl1 -- Last modified Jan 1982 */ 8 2 8 3 dcl (page_fault_type init (0), 8 4 seg_fault_start init (2), 8 5 seg_fault_end init (3), 8 6 linkage_fault_start init (4), 8 7 linkage_fault_end init (5), 8 8 boundfault_start init (6), 8 9 boundfault_end init (7), 8 10 signaller_type init (8), 8 11 restart_fault_type init (9), 8 12 reschedule_type init (10), 8 13 marker_type init (11), 8 14 interrupt_type init (12), 8 15 extended_page_fault_type init (15)) fixed bin int static options (constant); 8 16 8 17 8 18 /* END INCLUDE FILE trace_types.incl.pl1 */ 2091 2092 2093 end link_snap; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/11/89 0800.0 link_snap.pl1 >spec>install>1110>link_snap.pl1 2077 1 11/24/86 1226.9 definition_dcls.incl.pl1 >ldd>include>definition_dcls.incl.pl1 2079 2 11/26/79 1320.6 its.incl.pl1 >ldd>include>its.incl.pl1 2081 3 05/08/81 1853.7 link_meters.incl.pl1 >ldd>include>link_meters.incl.pl1 2083 4 12/15/83 1100.4 mc.incl.pl1 >ldd>include>mc.incl.pl1 2085 5 11/24/86 1226.9 object_link_dcls.incl.pl1 >ldd>include>object_link_dcls.incl.pl1 2087 6 11/07/86 1550.3 stack_header.incl.pl1 >ldd>include>stack_header.incl.pl1 2089 7 11/24/86 1226.9 system_link_names.incl.pl1 >ldd>include>system_link_names.incl.pl1 2091 8 03/29/82 1006.9 trace_types.incl.pl1 >ldd>include>trace_types.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. CLASS_HEAP constant fixed bin(3,0) initial unsigned dcl 1-25 ref 404 CLASS_LINKAGE constant fixed bin(3,0) initial unsigned dcl 1-25 ref 1207 1515 1543 1623 CLASS_STATIC constant fixed bin(3,0) initial unsigned dcl 1-25 ref 1209 1545 1625 CLASS_SYMBOL constant fixed bin(3,0) initial unsigned dcl 1-25 ref 1211 1547 1627 CLASS_SYSTEM constant fixed bin(3,0) initial unsigned dcl 1-25 ref 830 CLASS_TEXT constant fixed bin(3,0) initial unsigned dcl 1-25 ref 1205 1541 1621 FAULT_TAG_2 constant bit(6) initial packed unaligned dcl 5-101 ref 284 356 1147 FAULT_TAG_3 constant bit(6) initial packed unaligned dcl 5-102 ref 1529 INIT_DEFERRED constant fixed bin(17,0) initial dcl 1-194 ref 1126 ITS_MODIFIER constant bit(6) initial packed unaligned dcl 2-55 ref 369 677 1132 1139 1521 LINK_CREATE_IF_NOT_FOUND constant fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 ref 423 507 838 1321 1771 LINK_OBSOLETE_2 constant fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 ref 453 LINK_REFNAME_BASE constant fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 ref 456 705 715 1761 LINK_REFNAME_OFFSETNAME constant fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 ref 471 752 872 1761 LINK_SELF_BASE constant fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 ref 444 LINK_SELF_OFFSETNAME constant fixed bin(18,0) initial packed unsigned unaligned dcl 1-134 ref 404 491 830 Link_fault constant fixed bin(17,0) initial dcl 76 ref 260 1761 1837 2049 Link_force constant fixed bin(17,0) initial dcl 77 ref 322 356 1761 MSF_sw 000422 automatic bit(1) dcl 210 in procedure "link_snap" set ref 459* 461* 462* 474* 476* 477* 515* 517* 518* 671* 675* 677* 682* 684* 690* MSF_sw parameter bit(1) dcl 1246 in procedure "search_for_segment" set ref 1222 1266* Make_entry constant fixed bin(17,0) initial dcl 79 ref 624 1778 1842 2044 Make_ptr constant fixed bin(17,0) initial dcl 78 ref 590 705 1778 1840 2042 No_retry constant bit(1) initial packed unaligned dcl 81 set ref 483* 500* 545* 747 None constant fixed bin(18,0) initial packed unsigned unaligned dcl 86 ref 423 459 474 515 682 824 872 1034 1154 1314 1827 Will_retry constant bit(1) initial packed unaligned dcl 82 ref 745 a_code parameter fixed bin(35,0) dcl 94 set ref 294 329 562 599 655 667* 1837* 2055* a_condition_name parameter char packed unaligned dcl 1948 ref 1915 a_continue_flag parameter bit(1) packed unaligned dcl 1951 set ref 1915 1962* 1971* a_dummy parameter fixed bin(17,0) dcl 93 ref 294 a_infop parameter pointer dcl 1950 ref 1915 a_link_pairp parameter pointer dcl 92 ref 294 317 a_mcp parameter pointer dcl 1947 in procedure "connect_fail_handler_" ref 1915 1963 1977 a_mcp parameter pointer dcl 91 in procedure "link_snap" ref 239 257 a_offset_name parameter char packed unaligned dcl 97 ref 562 599 663 a_refp parameter pointer dcl 95 ref 562 599 661 a_seg_name parameter char packed unaligned dcl 96 ref 562 599 662 a_targete parameter entry variable dcl 99 set ref 599 628 629 1842 2044 a_targetp parameter pointer dcl 98 set ref 562 586* 1840* 2042* a_wcp parameter pointer dcl 1949 ref 1915 acc_string based structure level 1 dcl 1-327 addr builtin function dcl 214 ref 259 270 321 329 369 498 628 629 654 655 677 723 724 1139 1486 1486 1755 1842 1904 1905 1963 2044 addrel builtin function dcl 215 ref 363 380 381 458 473 514 532 817 818 826 880 881 881 881 881 889 1031 1036 1131 1146 1152 1153 1156 1320 1520 1541 1543 1545 1547 1621 1623 1625 1627 1673 address based bit(18) level 2 packed packed unaligned dcl 1889 set ref 1906* ahd$link_meters 000042 external static structure array level 1 dcl 127 set ref 1755 automatic_offsetname 000100 automatic structure level 1 dcl 172 set ref 724 729* automatic_segname 000201 automatic structure level 1 dcl 175 set ref 723 728* based_entry based structure level 1 dcl 154 based_ptr based pointer dcl 1106 in procedure "deferred_init" ref 1138 based_ptr based pointer dcl 799 in procedure "convert_trap_link" ref 897 based_ptr based pointer dcl 1442 in procedure "get_definition" ref 1523 1535 based_ptr based pointer dcl 1581 in procedure "snap_partial_link" set ref 1621* 1623* 1625* 1627* baseno builtin function dcl 216 ref 1965 baseptr builtin function dcl 217 ref 275 276 356 356 364 438 438 641 641 2061 2061 bin builtin function dcl 218 ref 271 271 275 276 1738 1739 1964 1965 bin_no 001014 automatic fixed bin(17,0) dcl 1729 set ref 1743* 1747 1747 1748 1748 1750 1750 1755 ca 5 based bit(18) level 2 packed packed unaligned dcl 4-56 ref 275 1906 call_info 000212 automatic structure level 1 dcl 178 set ref 259 321 654 call_infop 000244 automatic pointer dcl 188 set ref 259* 284* 321* 356* 359* 369* 375* 387* 395* 398* 399* 412* 414* 415* 438* 446* 449* 450* 453* 462* 464* 467* 468* 477* 479* 482* 483* 486* 487* 488* 493* 499* 500* 503* 504* 518* 526* 533* 536* 537* 541* 545* 550* 551* 552* 555* 654* 691* 705* 713* 715* 716* 718* 749* 752* 753* 754* 894* 1988* call_relp based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 806 ref 881 char builtin function dcl 219 ref 1597 class parameter fixed bin(18,0) unsigned dcl 1186 in procedure "self_reference" ref 1165 1205 1207 1209 1211 class 1(33) based fixed bin(3,0) level 2 in structure "def" packed packed unsigned unaligned dcl 1443 in procedure "get_definition" ref 1515 1541 1543 1545 1547 code parameter fixed bin(35,0) dcl 2032 in procedure "exit" ref 1996 2052 2055 2059 code 000630 automatic fixed bin(35,0) dcl 1192 in procedure "self_reference" set ref 1199* 1200 1200* code 000710 automatic fixed bin(35,0) dcl 1448 in procedure "get_definition" set ref 1471* 1480 1486* 1497 1497* code 000462 automatic fixed bin(35,0) dcl 950 in procedure "star_system" set ref 970* 973 973* code parameter fixed bin(35,0) dcl 1248 in procedure "search_for_segment" set ref 1222 1266* code 000246 automatic fixed bin(35,0) dcl 189 in procedure "link_snap" set ref 433* 438* 462* 464* 477* 479* 518* 674* 675 690* 691 691* 1051* 1053 1053* 1375* 1384 1384* 1602* 1612 1612* 1852* 1857* code 000442 automatic fixed bin(35,0) dcl 811 in procedure "convert_trap_link" set ref 893* 894 894* code_ptr based pointer level 2 dcl 154 set ref 628* 1842* 2044* codep 4 000212 automatic pointer level 2 in structure "call_info" dcl 178 in procedure "link_snap" set ref 266* 329* 433* 655* codep 4 based pointer level 2 in structure "info" dcl 1820 in procedure "trap" set ref 1852* component 0(03) based fixed bin(15,0) level 2 packed packed unsigned unaligned dcl 1583 ref 1597 condition_ 000010 constant entry external dcl 103 ref 481 540 696 connect_fail_code 000247 automatic fixed bin(35,0) dcl 190 set ref 1977* 1988* count based fixed bin(9,0) level 2 in structure "segname" packed packed unsigned unaligned dcl 162 in procedure "link_snap" ref 527 529 count based fixed bin(9,0) level 2 in structure "offsetname" packed packed unsigned unaligned dcl 1309 in procedure "get_offsetnamep" ref 1321 count based fixed bin(9,0) level 2 in structure "offsetname" packed packed unsigned unaligned dcl 1017 in procedure "star_heap" ref 1032 count based fixed bin(9,0) level 2 in structure "offsetname" packed packed unsigned unaligned dcl 159 in procedure "link_snap" ref 529 count based fixed bin(9,0) level 2 in structure "segname" packed packed unsigned unaligned dcl 1253 in procedure "search_for_segment" ref 1266 1266 count based fixed bin(9,0) level 2 in structure "acc_string" packed packed unsigned unaligned dcl 1-327 in procedure "link_snap" ref 881 count 000100 automatic fixed bin(9,0) level 2 in structure "automatic_offsetname" packed packed unsigned unaligned dcl 172 in procedure "link_snap" set ref 737* 738 738 count based fixed bin(9,0) level 2 in structure "segname" packed packed unsigned unaligned dcl 803 in procedure "convert_trap_link" ref 843 851 851 855 855 864 881 count based fixed bin(9,0) level 2 in structure "offsetname" packed packed unsigned unaligned dcl 800 in procedure "convert_trap_link" ref 823 851 866 count 000201 automatic fixed bin(9,0) level 2 in structure "automatic_segname" packed packed unsigned unaligned dcl 175 in procedure "link_snap" set ref 733* 734 734 def based structure level 1 dcl 1443 def_ptr based pointer level 2 in structure "lh" dcl 1105 in procedure "deferred_init" set ref 1139 1141 def_ptr based pointer level 2 in structure "linkage_header" dcl 5-50 in procedure "link_snap" set ref 369 371 677 681 1471* 1486* def_ptr 000424 automatic pointer dcl 1-71 in procedure "link_snap" set ref 970* def_search 26 000212 automatic structure level 2 in structure "call_info" dcl 178 in procedure "link_snap" def_search 26 based structure level 2 in structure "info" dcl 1444 in procedure "get_definition" def_search 26 based structure level 2 in structure "info" dcl 1722 in procedure "meter" definition based structure level 1 dcl 1-72 definition_flags based structure level 1 packed packed unaligned dcl 1-42 definition_header based structure level 1 dcl 1-58 defp 000250 automatic pointer dcl 191 in procedure "link_snap" set ref 371* 380 381 387* 395* 412* 433* 458 459 473 474 482* 499* 514 515 526* 532 533* 541* 681* 682 1141* 1152 1153 1156 defp 000712 automatic pointer dcl 1449 in procedure "get_definition" set ref 1471* 1486* 1502 1515 1520 1541 1541 1543 1543 1545 1545 1547 1547 defp parameter pointer dcl 937 in procedure "star_system" ref 909 defp parameter pointer dcl 1009 in procedure "star_heap" ref 987 1031 1036 defp parameter pointer dcl 1303 in procedure "get_offsetnamep" ref 1282 1320 defp parameter pointer dcl 791 in procedure "convert_trap_link" ref 761 817 818 826 880 881 881 881 defsearch_pf 7 based fixed bin(30,0) level 2 dcl 1723 set ref 1768* 1768 defsearch_time 10 based fixed bin(35,0) level 2 dcl 1723 set ref 1769* 1769 divide builtin function dcl 220 ref 1743 elapsed_pf 001013 automatic fixed bin(30,0) dcl 1728 set ref 1739* 1748 1758 1774 1781 elapsed_time 001012 automatic fixed bin(35,0) dcl 1727 set ref 1738* 1743 1750 1759 1775 1782 env_ptr 2 based pointer level 2 dcl 154 set ref 629* errcode 43 based fixed bin(35,0) level 2 in structure "exit_mc" packed packed unaligned dcl 2038 in procedure "exit" set ref 2052* errcode 43 based fixed bin(35,0) level 2 in structure "mc" packed packed unaligned dcl 4-12 in procedure "link_snap" ref 1977 error_table_$bad_class_def 000044 external static fixed bin(35,0) dcl 128 set ref 1549* error_table_$bad_deferred_init 000046 external static fixed bin(35,0) dcl 130 set ref 1132* 1147* error_table_$bad_indirect_def 000050 external static fixed bin(35,0) dcl 132 set ref 1515* 1529* 1629* error_table_$bad_link_type 000052 external static fixed bin(35,0) dcl 134 set ref 453* 555* error_table_$bad_self_ref 000054 external static fixed bin(35,0) dcl 136 set ref 1213* error_table_$first_reference_trap 000056 external static fixed bin(35,0) dcl 138 set ref 375* error_table_$illegal_ft2 000060 external static fixed bin(35,0) dcl 140 set ref 359* error_table_$no_defs 000062 external static fixed bin(35,0) dcl 142 set ref 369* 1139* error_table_$no_ext_sym 000064 external static fixed bin(35,0) dcl 143 ref 1480 error_table_$no_linkage 000066 external static fixed bin(35,0) dcl 144 set ref 1387* error_table_$unexpected_ft2 000070 external static fixed bin(35,0) dcl 145 set ref 284* even_inst 6 based bit(36) level 2 dcl 4-56 set ref 1905 exit_mc based structure level 1 dcl 2038 exp_word based structure level 1 dcl 1-129 expr based structure level 1 dcl 157 in procedure "link_snap" expr based structure level 1 dcl 1108 in procedure "deferred_init" expression 0(18) based fixed bin(17,0) level 2 in structure "expr" packed packed unaligned dcl 157 in procedure "link_snap" ref 397 413 448 466 485 502 535 549 expression parameter fixed bin(17,0) dcl 1657 in procedure "snap" ref 1638 1673 expression_relp 1 based fixed bin(18,0) level 2 in structure "link_pair" packed packed unsigned unaligned dcl 158 in procedure "link_snap" ref 380 expression_relp 1 based fixed bin(18,0) level 2 in structure "link_pair" packed packed unsigned unaligned dcl 1109 in procedure "deferred_init" ref 1152 expression_relp 1 based fixed bin(18,0) level 2 in structure "object_link" packed packed unsigned unaligned dcl 5-28 in procedure "link_snap" ref 881 exprp 000614 automatic pointer dcl 1117 in procedure "deferred_init" set ref 1152* 1153 exprp 000252 automatic pointer dcl 192 in procedure "link_snap" set ref 380* 381 397 413 448 466 485 502 535 549 false constant bit(1) initial packed unaligned dcl 72 ref 461 476 517 671 675 677 684 822 1962 faulted_segno 000100 automatic fixed bin(18,0) dcl 1955 set ref 1964* 1969 finish 000672 automatic structure level 1 dcl 1367 in procedure "combine_linkage" finish 000646 automatic structure level 1 dcl 1259 in procedure "search_for_segment" finish 000742 automatic structure level 1 dcl 1587 in procedure "snap_partial_link" finish 12 based structure level 2 in structure "info" dcl 1722 in procedure "meter" finish 000714 automatic structure level 1 dcl 1450 in procedure "get_definition" first_ref_relp 1(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 5-71 ref 375 1827 flags 1(18) based structure level 2 packed packed unaligned dcl 1443 fs_search 000012 constant entry external dcl 104 ref 690 1266 fs_search$same_directory 000014 constant entry external dcl 106 ref 1602 get_defptr_ 000016 constant entry external dcl 108 ref 1471 1486 get_linkage 22 based structure level 2 in structure "info" dcl 1722 in procedure "meter" get_linkage 22 000212 automatic structure level 2 in structure "call_info" dcl 178 in procedure "link_snap" get_linkage 22 based structure level 2 in structure "info" dcl 1363 in procedure "combine_linkage" get_linkage_pf 5 based fixed bin(30,0) level 2 dcl 1723 set ref 1766* 1766 get_linkage_time 6 based fixed bin(35,0) level 2 dcl 1723 set ref 1767* 1767 header based structure level 2 dcl 1110 header_relp based fixed bin(17,0) level 2 packed packed unaligned dcl 158 ref 363 ilc 4 based bit(18) level 2 packed packed unaligned dcl 4-56 ref 276 index builtin function dcl 221 ref 851 indirect 1(24) based bit(1) level 3 in structure "def" packed packed unaligned dcl 1443 in procedure "get_definition" ref 1502 indirect constant bit(6) initial packed unaligned dcl 74 in procedure "link_snap" ref 1907 info based structure level 1 dcl 1722 in procedure "meter" info based structure level 1 dcl 1016 in procedure "star_heap" info based structure level 1 dcl 1444 in procedure "get_definition" info based structure level 1 dcl 1582 in procedure "snap_partial_link" info based structure level 1 dcl 1252 in procedure "search_for_segment" info based structure level 1 dcl 1820 in procedure "trap" info based structure level 1 dcl 946 in procedure "star_system" info based structure level 1 dcl 2037 in procedure "exit" info based structure level 1 dcl 1363 in procedure "combine_linkage" info_relp 0(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 806 ref 889 infop parameter pointer dcl 1354 in procedure "combine_linkage" set ref 1332 1381 1381 1382 1382 1384* 1387* infop parameter pointer dcl 1185 in procedure "self_reference" set ref 1165 1200* 1213* infop parameter pointer dcl 789 in procedure "convert_trap_link" ref 761 infop parameter pointer dcl 935 in procedure "star_system" set ref 909 955 957 961* 970 973* infop parameter pointer dcl 1008 in procedure "star_heap" set ref 987 1040 1042 1046* 1053* infop parameter pointer dcl 1814 in procedure "trap" set ref 1792 1833 1837 1840 1842 1852 1852 1857 1857* infop parameter pointer dcl 1717 in procedure "meter" ref 1699 1734 1734 1738 1738 1739 1739 1761 1761 1764 1765 1766 1767 1768 1769 1778 1778 infop parameter pointer dcl 1432 in procedure "get_definition" set ref 1397 1464* 1477 1477 1478 1478 1492 1492 1493 1493 1497* 1515* 1529* 1534* 1549* infop parameter pointer dcl 1575 in procedure "snap_partial_link" set ref 1558 1607 1607 1608 1608 1612* 1617* 1629* infop parameter pointer dcl 1243 in procedure "search_for_segment" ref 1222 1272 1272 1273 1273 infop parameter pointer dcl 2031 in procedure "exit" ref 1996 2042 2044 2049 2051 2052 2053 infop parameter pointer dcl 1099 in procedure "deferred_init" set ref 1067 1132* 1139* 1147* infop parameter pointer dcl 1302 in procedure "get_offsetnamep" ref 1282 init_info based structure level 1 dcl 1110 init_infop 000254 automatic pointer dcl 193 in procedure "link_snap" set ref 387* 395* 530* 532* 533* init_infop parameter pointer dcl 1100 in procedure "deferred_init" set ref 1067 1123 1126 1131 1146 1154* 1156* init_infop parameter pointer dcl 941 in procedure "star_system" set ref 909 961* 970* 970 970 init_infop 000474 automatic pointer dcl 1024 in procedure "star_heap" set ref 1034* 1036* 1046* 1051* 1051 1051 init_infop parameter pointer dcl 794 in procedure "convert_trap_link" set ref 761 824* 826* 897* init_linkp 000444 automatic pointer dcl 812 set ref 889* 893* 897 instr based structure level 1 dcl 1889 instrp 000256 automatic pointer dcl 194 in procedure "link_snap" set ref 276* 280 284 instrp 001036 automatic pointer dcl 1897 in procedure "adjust_mc" set ref 1905* 1906 1907 its based structure level 1 dcl 2-5 its_mod 0(30) based bit(6) level 2 packed packed unaligned dcl 2-5 ref 284 369 677 1132 1139 1521 1529 length builtin function dcl 222 ref 698 733 737 level$get 000020 constant entry external dcl 109 ref 262 955 1040 1689 level$set 000022 constant entry external dcl 110 ref 271 2051 lh based structure level 1 dcl 1105 lhp 000612 automatic pointer dcl 1116 set ref 1138* 1139 1141 1146 link_as_its based structure level 1 dcl 1662 link_init based structure level 1 dcl 1-205 link_init_deferred based structure level 1 dcl 1-270 link_man$other_linkage 000024 constant entry external dcl 111 ref 1375 link_man$own_linkage 000026 constant entry external dcl 112 ref 674 1199 link_meters based structure array level 1 dcl 3-17 link_pair based structure level 1 dcl 1663 in procedure "snap" link_pair based structure level 1 dcl 158 in procedure "link_snap" link_pair based structure level 1 dcl 1583 in procedure "snap_partial_link" link_pair based structure level 1 dcl 1109 in procedure "deferred_init" link_pairp parameter pointer dcl 936 in procedure "star_system" set ref 909 970* link_pairp 000260 automatic pointer dcl 195 in procedure "link_snap" set ref 275* 317* 334 356 363 363 380 395* 397* 413* 433* 448* 466* 485* 502* 533* 535* 549* link_pairp parameter pointer dcl 1576 in procedure "snap_partial_link" ref 1558 1597 1621 1621 1621 1623 1623 1623 1625 1625 1625 1627 1627 1627 link_pairp 000620 automatic pointer dcl 1119 in procedure "deferred_init" set ref 1146* 1147 1152 link_pairp parameter pointer dcl 1658 in procedure "snap" ref 1638 1677 1681 1685 1690 link_ptr based pointer dcl 1664 set ref 1681* link_relp 2(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 1110 ref 1146 link_trap_pair based structure level 1 dcl 1-177 linkage_fault_end 000011 constant fixed bin(17,0) initial dcl 8-3 set ref 1848* 2059* 2061* linkage_fault_start 000015 constant fixed bin(17,0) initial dcl 8-3 set ref 280* 334* 641* linkage_header based structure level 1 dcl 5-50 linkp parameter pointer dcl 790 in procedure "convert_trap_link" ref 761 881 889 linkp parameter pointer dcl 1101 in procedure "deferred_init" ref 1067 1131 linkp 000262 automatic pointer dcl 196 in procedure "link_snap" set ref 363* 364 369 371 375 387* 395* 412* 433* 533* 674* 677 681 linkp parameter pointer dcl 938 in procedure "star_system" set ref 909 961* linkp parameter pointer dcl 1357 in procedure "combine_linkage" set ref 1332 1375* 1387 linkp parameter pointer dcl 1010 in procedure "star_heap" set ref 987 1046* linkp 000746 automatic pointer dcl 1588 in procedure "snap_partial_link" set ref 1617* 1623 linkp 000720 automatic pointer dcl 1451 in procedure "get_definition" set ref 1464* 1468 1471 1486 1520 1543 linkp 000632 automatic pointer dcl 1193 in procedure "self_reference" set ref 1199* 1207 lm based structure level 1 dcl 1723 lmp 001016 automatic pointer dcl 1730 set ref 1755* 1757 1757 1758 1758 1759 1759 1764 1764 1765 1765 1766 1766 1767 1767 1768 1768 1769 1769 1773 1773 1774 1774 1775 1775 1778 1778 1780 1780 1781 1781 1782 1782 ltrim builtin function dcl 223 ref 1597 main_acc 000000 constant structure level 1 dcl 1426 set ref 1486 1486 max builtin function dcl 224 ref 1743 mc based structure level 1 dcl 4-12 mcp 2 based pointer level 2 in structure "info" dcl 1016 in procedure "star_heap" ref 1040 1042 mcp 2 based pointer level 2 in structure "info" dcl 2037 in procedure "exit" set ref 2052 2053* mcp 2 based pointer level 2 in structure "info" dcl 1820 in procedure "trap" set ref 1833* 1852* 1857 mcp 2 000212 automatic pointer level 2 in structure "call_info" dcl 178 in procedure "link_snap" set ref 261* 323* 656* mcp 000426 automatic pointer dcl 4-10 in procedure "link_snap" set ref 257* 261 270 313* 432* 433* 656* mcp 2 based pointer level 2 in structure "info" dcl 946 in procedure "star_system" set ref 955 957 970* mcp parameter pointer dcl 1885 in procedure "adjust_mc" ref 1870 1901 1904 min builtin function dcl 225 ref 1743 mod 1(30) based bit(6) level 2 packed packed unaligned dcl 1662 set ref 1685* modifier 001000 automatic bit(6) packed unaligned dcl 1668 in procedure "snap" set ref 1677* 1685 modifier 1(30) based bit(6) level 2 in structure "link_pair" packed packed unaligned dcl 1663 in procedure "snap" ref 1677 modifier 0(30) based bit(6) level 2 in structure "instr" packed packed unaligned dcl 1889 in procedure "adjust_mc" set ref 1907* msf_map_relp 0(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 1-58 ref 459 474 515 682 nchars 000264 automatic fixed bin(17,0) dcl 197 set ref 698* 700 null builtin function dcl 226 ref 266 284 284 313 323 359 359 365 369 369 375 375 453 453 464 464 464 479 479 479 500 520 527 530 545 555 555 586 628 629 656 671 674 674 674 674 691 691 713 713 713 824 894 894 955 973 973 1034 1040 1053 1053 1123 1132 1132 1139 1139 1147 1147 1154 1200 1200 1213 1213 1314 1321 1384 1384 1387 1387 1387 1459 1497 1497 1515 1515 1529 1529 1549 1549 1612 1612 1629 1629 1825 1852 1852 1852 1852 1852 1852 1857 1857 1857 1901 1988 1988 object_link based structure level 1 dcl 5-28 offset 1 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 1583 ref 1621 1623 1625 1627 offset_name parameter char(256) packed unaligned dcl 940 in procedure "star_system" set ref 909 970* offset_name 000502 automatic char(256) packed unaligned dcl 1027 in procedure "star_heap" set ref 1032* 1051* offset_name 000265 automatic char(256) packed unaligned dcl 198 in procedure "link_snap" set ref 387* 395* 527* 529* 533* 663* 698 737 738 745 offset_name parameter char(256) packed unaligned dcl 793 in procedure "convert_trap_link" set ref 761 823* 855* 856 856* 866* offsetname based structure level 1 dcl 1309 in procedure "get_offsetnamep" offsetname based structure level 1 dcl 1017 in procedure "star_heap" offsetname based structure level 1 dcl 159 in procedure "link_snap" offsetname based structure level 1 dcl 800 in procedure "convert_trap_link" offsetname_relp 1(18) based fixed bin(18,0) level 2 in structure "type_pr" packed packed unsigned unaligned dcl 807 in procedure "convert_trap_link" ref 818 offsetname_relp 1(18) based fixed bin(18,0) level 2 in structure "type_pr" packed packed unsigned unaligned dcl 1312 in procedure "get_offsetnamep" ref 1314 1320 offsetname_relp 1(18) based fixed bin(18,0) level 2 in structure "type_pr" packed packed unsigned unaligned dcl 1020 in procedure "star_heap" ref 1031 offsetnamep parameter pointer dcl 1305 in procedure "get_offsetnamep" set ref 1282 1314* 1320* 1321 1321* offsetnamep 000366 automatic pointer dcl 199 in procedure "link_snap" set ref 482* 483* 499* 500* 526* 527 529 529 541* 545 545* 724* 749* offsetnamep parameter pointer dcl 1434 in procedure "get_definition" set ref 1397 1459 1471* offsetnamep 000476 automatic pointer dcl 1025 in procedure "star_heap" set ref 1031* 1032 1032 offsetnamep 000446 automatic pointer dcl 813 in procedure "convert_trap_link" set ref 818* 823 823 851 866 866 original_linkage_ptr 3 based pointer level 2 packed packed unaligned dcl 1105 ref 1146 others_pf 12 based fixed bin(30,0) level 2 dcl 1723 set ref 1781* 1781 others_time 13 based fixed bin(35,0) level 2 dcl 1723 set ref 1782* 1782 page$enter_data 000030 constant entry external dcl 113 ref 280 334 641 1848 2059 2061 partial_link based structure level 1 dcl 5-38 pds$link_meters_bins 000072 external static fixed bin(30,0) array dcl 147 set ref 1747* 1747 pds$link_meters_pgwaits 000074 external static fixed bin(30,0) array dcl 148 set ref 1748* 1748 pds$link_meters_times 000076 external static fixed bin(35,0) array dcl 149 set ref 1750* 1750 pds$stacks 000100 external static pointer array dcl 150 ref 955 1040 1689 pf 30 based fixed bin(30,0) level 3 in structure "info" dcl 1444 in procedure "get_definition" set ref 1477* 1477 1492* 1492 pf 1 based fixed bin(30,0) level 2 in structure "lm" dcl 1723 in procedure "meter" set ref 1758* 1758 pf 24 based fixed bin(30,0) level 3 in structure "info" dcl 1363 in procedure "combine_linkage" set ref 1381* 1381 pf 2 000672 automatic fixed bin(30,0) level 2 in structure "finish" dcl 1367 in procedure "combine_linkage" set ref 1377* 1381 pf 10 based fixed bin(30,0) level 3 in structure "info" dcl 1722 in procedure "meter" ref 1739 pf 14 based fixed bin(30,0) level 3 in structure "info" dcl 1722 in procedure "meter" set ref 1734* 1739 pf 2 000760 automatic fixed bin(30,0) level 2 in structure "start" dcl 1590 in procedure "snap_partial_link" set ref 1601* 1607 pf 20 000212 automatic fixed bin(30,0) level 3 in structure "call_info" dcl 178 in procedure "link_snap" set ref 346* 646* pf 20 based fixed bin(30,0) level 3 in structure "info" dcl 1252 in procedure "search_for_segment" set ref 1272* 1272 pf 30 000212 automatic fixed bin(30,0) level 3 in structure "call_info" dcl 178 in procedure "link_snap" set ref 350* 650* pf 24 000212 automatic fixed bin(30,0) level 3 in structure "call_info" dcl 178 in procedure "link_snap" set ref 348* 648* pf 10 000212 automatic fixed bin(30,0) level 3 in structure "call_info" dcl 178 in procedure "link_snap" set ref 354* 636* pf 20 based fixed bin(30,0) level 3 in structure "info" dcl 1582 in procedure "snap_partial_link" set ref 1607* 1607 pf 2 000646 automatic fixed bin(30,0) level 2 in structure "finish" dcl 1259 in procedure "search_for_segment" set ref 1268* 1272 pf 2 000714 automatic fixed bin(30,0) level 2 in structure "finish" dcl 1450 in procedure "get_definition" set ref 1473* 1477 1488* 1492 pf 2 000676 automatic fixed bin(30,0) level 2 in structure "start" dcl 1368 in procedure "combine_linkage" set ref 1372* 1381 pf 30 based fixed bin(30,0) level 3 in structure "info" dcl 1722 in procedure "meter" ref 1768 pf 2 000742 automatic fixed bin(30,0) level 2 in structure "finish" dcl 1587 in procedure "snap_partial_link" set ref 1603* 1607 pf 24 based fixed bin(30,0) level 3 in structure "info" dcl 1722 in procedure "meter" ref 1766 pf 20 based fixed bin(30,0) level 3 in structure "info" dcl 1722 in procedure "meter" ref 1764 pf 2 000722 automatic fixed bin(30,0) level 2 in structure "start" dcl 1452 in procedure "get_definition" set ref 1470* 1477 1485* 1492 ppr based structure level 2 packed packed unaligned dcl 4-56 prr based bit(3) level 3 packed packed unaligned dcl 4-56 ref 271 271 prs based pointer array level 2 dcl 4-12 ref 957 1042 psr 0(03) based bit(15) level 3 packed packed unaligned dcl 4-56 ref 276 ptr builtin function dcl 227 ref 275 276 674 674 957 970 970 1042 1051 1051 1374 refname 000750 automatic char(32) packed unaligned dcl 1589 set ref 1597* 1602* refp parameter pointer dcl 1245 in procedure "search_for_segment" set ref 1222 1266* refp 000370 automatic pointer dcl 200 in procedure "link_snap" set ref 661* 671 674 674 690* refp parameter pointer dcl 1577 in procedure "snap_partial_link" set ref 1558 1602* retry parameter bit(1) packed unaligned dcl 1435 ref 1397 1480 retry_sw 000372 automatic bit(1) packed unaligned dcl 201 set ref 745* 747* 749* rtrim builtin function dcl 228 ref 698 733 737 run_depth 0(27) based fixed bin(2,0) level 2 packed packed unaligned dcl 1663 set ref 1690* run_unit_depth 12(33) based fixed bin(2,0) level 2 packed packed unaligned dcl 6-26 ref 1690 save_ring 1 based fixed bin(17,0) level 2 in structure "info" dcl 2037 in procedure "exit" ref 2051 save_ring 1 000212 automatic fixed bin(17,0) level 2 in structure "call_info" dcl 178 in procedure "link_snap" set ref 262* 324* 657* sb 000500 automatic pointer dcl 1026 in procedure "star_heap" set ref 1040* 1042* 1051* sb 000464 automatic pointer dcl 951 in procedure "star_system" set ref 955* 957* 970* sb 001002 automatic pointer dcl 1669 in procedure "snap" set ref 1689* 1690 scu based structure level 1 dcl 4-56 in procedure "link_snap" scu 30 based bit(36) array level 2 in structure "mc" packed packed unaligned dcl 4-12 in procedure "link_snap" set ref 270 1904 1963 scup 000430 automatic pointer dcl 4-54 in procedure "link_snap" set ref 270* 271 271 275 275 276 276 scup 000102 automatic pointer dcl 1957 in procedure "connect_fail_handler_" set ref 1963* 1964 scup 001034 automatic pointer dcl 1896 in procedure "adjust_mc" set ref 1904* 1905 1906 search 16 based structure level 2 in structure "info" dcl 1252 in procedure "search_for_segment" search 16 000212 automatic structure level 2 in structure "call_info" dcl 178 in procedure "link_snap" search 16 based structure level 2 in structure "info" dcl 1582 in procedure "snap_partial_link" search 16 based structure level 2 in structure "info" dcl 1722 in procedure "meter" search_pf 3 based fixed bin(30,0) level 2 dcl 1723 set ref 1764* 1764 search_time 4 based fixed bin(35,0) level 2 dcl 1723 set ref 1765* 1765 seg_name 000373 automatic char(32) packed unaligned dcl 202 set ref 662* 690* 733 734 745 segment_number 7 based fixed bin(18,0) level 3 packed packed unsigned unaligned dcl 5-50 ref 364 segname based structure level 1 dcl 803 in procedure "convert_trap_link" segname based structure level 1 dcl 162 in procedure "link_snap" segname based structure level 1 dcl 1253 in procedure "search_for_segment" segname_relp 1 based fixed bin(18,0) level 2 in structure "type_pr" packed packed unsigned unaligned dcl 165 in procedure "link_snap" ref 404 446 458 473 493 514 segname_relp 1 based fixed bin(18,0) level 2 in structure "type_pair" packed packed unsigned unaligned dcl 1-160 in procedure "link_snap" ref 881 segname_relp 1 based fixed bin(18,0) level 2 in structure "type_pr" packed packed unsigned unaligned dcl 807 in procedure "convert_trap_link" ref 817 830 segnamep parameter pointer dcl 1433 in procedure "get_definition" set ref 1397 1471* 1486* segnamep 000404 automatic pointer dcl 203 in procedure "link_snap" set ref 458* 462* 473* 477* 483* 498* 500* 514* 518* 527 527 529 529 545* 723* 749* segnamep parameter pointer dcl 1244 in procedure "search_for_segment" ref 1222 1266 1266 1266 segnamep 000450 automatic pointer dcl 814 in procedure "convert_trap_link" set ref 817* 843 843 851 851 851 855 855 855 864 864 881 881 segno 000101 automatic fixed bin(18,0) dcl 1956 set ref 1965* 1969 segp 000406 automatic pointer dcl 204 in procedure "link_snap" set ref 462* 464 466* 468* 477* 479 483* 518* 520 545* 548 690* 713* 716* 718* 749* 1602* 1617* 1965 segp parameter pointer dcl 1247 in procedure "search_for_segment" set ref 1222 1266* segp parameter pointer dcl 1437 in procedure "get_definition" set ref 1397 1464* segp parameter pointer dcl 1355 in procedure "combine_linkage" ref 1332 1374 set_ext_variable_$for_linker 000032 constant entry external dcl 114 ref 970 set_ext_variable_$star_heap 000034 constant entry external dcl 117 ref 1051 stack_header based structure level 1 dcl 6-26 star_system_sw parameter bit(1) packed unaligned dcl 795 in procedure "convert_trap_link" set ref 761 822* 832* 845* 854* 867* 898* star_system_sw 000410 automatic bit(1) packed unaligned dcl 205 in procedure "link_snap" set ref 387* 390 start 6 000212 automatic structure level 2 in structure "call_info" dcl 178 in procedure "link_snap" start 000760 automatic structure level 1 dcl 1590 in procedure "snap_partial_link" start 000722 automatic structure level 1 dcl 1452 in procedure "get_definition" start 000676 automatic structure level 1 dcl 1368 in procedure "combine_linkage" start 6 based structure level 2 in structure "info" dcl 1722 in procedure "meter" start 000652 automatic structure level 1 dcl 1260 in procedure "search_for_segment" staticp 000634 automatic pointer dcl 1194 set ref 1199* 1209 statp 000726 automatic pointer dcl 1453 in procedure "get_definition" set ref 1464* 1545 statp 000764 automatic pointer dcl 1591 in procedure "snap_partial_link" set ref 1617* 1625 statp parameter pointer dcl 1358 in procedure "combine_linkage" set ref 1332 1375* stats 6 based structure level 2 dcl 5-50 string 0(09) based char level 2 in structure "segname" packed packed unaligned dcl 162 in procedure "link_snap" ref 527 529 string 0(09) 000100 automatic char(256) level 2 in structure "automatic_offsetname" packed packed unaligned dcl 172 in procedure "link_snap" set ref 738* string 0(09) based char level 2 in structure "offsetname" packed packed unaligned dcl 159 in procedure "link_snap" ref 529 string 0(09) based char level 2 in structure "offsetname" packed packed unaligned dcl 1017 in procedure "star_heap" ref 1032 string 0(09) based char level 2 in structure "segname" packed packed unaligned dcl 803 in procedure "convert_trap_link" ref 843 851 855 864 881 string 0(09) based char level 2 in structure "offsetname" packed packed unaligned dcl 800 in procedure "convert_trap_link" ref 823 866 string 0(09) based char level 2 in structure "acc_string" packed packed unaligned dcl 1-327 in procedure "link_snap" ref 881 string 0(09) based char level 2 in structure "segname" packed packed unaligned dcl 1253 in procedure "search_for_segment" set ref 1266* string 0(09) 000201 automatic char(32) level 2 in structure "automatic_segname" packed packed unaligned dcl 175 in procedure "link_snap" set ref 734* substr builtin function dcl 229 set ref 734* 734 738* 738 855 symbolp 000636 automatic pointer dcl 1195 set ref 1199* 1211 symbp 000766 automatic pointer dcl 1592 in procedure "snap_partial_link" set ref 1617* 1627 symbp 000730 automatic pointer dcl 1454 in procedure "get_definition" set ref 1464* 1547 symbp parameter pointer dcl 1359 in procedure "combine_linkage" set ref 1332 1375* tag 0(30) based bit(6) level 2 in structure "link_pair" packed packed unaligned dcl 158 in procedure "link_snap" ref 356 tag 0(30) based bit(6) level 2 in structure "link_pair" packed packed unaligned dcl 1109 in procedure "deferred_init" ref 1147 target_linkagep 000412 automatic pointer dcl 206 in procedure "link_snap" set ref 365* 483* 487* 545* 551* 713* 716* 749* 753* target_linkagep parameter pointer dcl 1815 in procedure "trap" set ref 1792 1825 1827 1852* target_linkagep parameter pointer dcl 1436 in procedure "get_definition" set ref 1397 1468* target_ptr_ptr 000610 automatic pointer dcl 1115 set ref 1131* 1132 1138 target_relp 2 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 1110 ref 1131 targetp parameter pointer dcl 1438 in procedure "get_definition" set ref 1397 1520* 1521 1523* 1523 1529 1534* 1535* 1535 1541* 1543* 1545* 1547* targetp parameter pointer dcl 1012 in procedure "star_heap" set ref 987 1051* 1058* 1058 targetp parameter pointer dcl 1656 in procedure "snap" set ref 1638 1673* 1673 1681 targetp parameter pointer dcl 942 in procedure "star_system" set ref 909 970* 978* 978 targetp parameter pointer dcl 1188 in procedure "self_reference" set ref 1165 1205* 1207* 1209* 1211* targetp 000414 automatic pointer dcl 207 in procedure "link_snap" set ref 395* 397* 399* 412* 413* 415* 446* 448* 450* 483* 485* 487* 488* 493* 500* 502* 504* 533* 535* 537* 545* 548* 549* 551* 552* 749* 753* 754* targetp parameter pointer dcl 1816 in procedure "trap" ref 1792 1840 1842 1848 targetp parameter pointer dcl 2033 in procedure "exit" ref 1996 2042 2044 2059 textp 000416 automatic pointer dcl 208 in procedure "link_snap" set ref 364* 446* 462* 477* 493* 500* 518* textp parameter pointer dcl 1187 in procedure "self_reference" set ref 1165 1199* 1205 textp 000770 automatic pointer dcl 1593 in procedure "snap_partial_link" set ref 1617* 1621 textp parameter pointer dcl 1356 in procedure "combine_linkage" set ref 1332 1374* 1375* textp 000732 automatic pointer dcl 1455 in procedure "get_definition" set ref 1464* 1534* 1541 thing_relp 1 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 1443 ref 1520 1541 1543 1545 1547 time 000714 automatic fixed bin(71,0) level 2 in structure "finish" dcl 1450 in procedure "get_definition" set ref 1473* 1478 1488* 1493 time 6 000212 automatic fixed bin(71,0) level 3 in structure "call_info" dcl 178 in procedure "link_snap" set ref 354* 636* time 22 000212 automatic fixed bin(71,0) level 3 in structure "call_info" dcl 178 in procedure "link_snap" set ref 347* 647* time 000722 automatic fixed bin(71,0) level 2 in structure "start" dcl 1452 in procedure "get_definition" set ref 1470* 1478 1485* 1493 time 000676 automatic fixed bin(71,0) level 2 in structure "start" dcl 1368 in procedure "combine_linkage" set ref 1372* 1382 time 26 based fixed bin(71,0) level 3 in structure "info" dcl 1722 in procedure "meter" ref 1769 time 16 based fixed bin(71,0) level 3 in structure "info" dcl 1252 in procedure "search_for_segment" set ref 1273* 1273 time 16 based fixed bin(71,0) level 3 in structure "info" dcl 1722 in procedure "meter" ref 1765 time 16 based fixed bin(71,0) level 3 in structure "info" dcl 1582 in procedure "snap_partial_link" set ref 1608* 1608 time 000742 automatic fixed bin(71,0) level 2 in structure "finish" dcl 1587 in procedure "snap_partial_link" set ref 1603* 1608 time 12 based fixed bin(71,0) level 3 in structure "info" dcl 1722 in procedure "meter" set ref 1734* 1738 time 26 based fixed bin(71,0) level 3 in structure "info" dcl 1444 in procedure "get_definition" set ref 1478* 1478 1493* 1493 time 26 000212 automatic fixed bin(71,0) level 3 in structure "call_info" dcl 178 in procedure "link_snap" set ref 349* 649* time 2 based fixed bin(35,0) level 2 in structure "lm" dcl 1723 in procedure "meter" set ref 1759* 1759 time 000760 automatic fixed bin(71,0) level 2 in structure "start" dcl 1590 in procedure "snap_partial_link" set ref 1601* 1608 time 6 based fixed bin(71,0) level 3 in structure "info" dcl 1722 in procedure "meter" ref 1738 time 000672 automatic fixed bin(71,0) level 2 in structure "finish" dcl 1367 in procedure "combine_linkage" set ref 1377* 1382 time 22 based fixed bin(71,0) level 3 in structure "info" dcl 1722 in procedure "meter" ref 1767 time 000646 automatic fixed bin(71,0) level 2 in structure "finish" dcl 1259 in procedure "search_for_segment" set ref 1268* 1273 time 16 000212 automatic fixed bin(71,0) level 3 in structure "call_info" dcl 178 in procedure "link_snap" set ref 341* 645* time 22 based fixed bin(71,0) level 3 in structure "info" dcl 1363 in procedure "combine_linkage" set ref 1382* 1382 tot_make_ptr 14 based fixed bin(30,0) level 2 dcl 1723 set ref 1778* 1778 total based fixed bin(35,0) level 2 dcl 1723 set ref 1757* 1757 total_others 11 based fixed bin(30,0) level 2 dcl 1723 set ref 1780* 1780 total_type_6 15 based fixed bin(30,0) level 2 dcl 1723 set ref 1773* 1773 tpr 2 based structure level 2 packed packed unaligned dcl 4-56 trap based structure level 1 dcl 806 trap_caller_caller_ 000036 constant entry external dcl 120 ref 433 1852 trap_relp 0(18) based fixed bin(18,0) level 2 in structure "type_pr" packed packed unsigned unaligned dcl 165 in procedure "link_snap" ref 423 530 532 trap_relp 0(18) based fixed bin(18,0) level 2 in structure "type_pr" packed packed unsigned unaligned dcl 807 in procedure "convert_trap_link" ref 824 826 872 880 trap_relp 0(18) based fixed bin(18,0) level 2 in structure "type_pr" packed packed unsigned unaligned dcl 1107 in procedure "deferred_init" ref 1154 1156 trap_relp 0(18) based fixed bin(18,0) level 2 in structure "type_pr" packed packed unsigned unaligned dcl 1020 in procedure "star_heap" ref 1034 1036 trapp 000452 automatic pointer dcl 815 set ref 880* 881 889 true constant bit(1) initial packed unaligned dcl 71 ref 459 474 515 682 832 845 854 867 898 1971 tsr 2(03) based bit(15) level 3 packed packed unaligned dcl 4-56 ref 275 1964 type based fixed bin(17,0) level 2 in structure "info" dcl 1820 in procedure "trap" ref 1837 1840 1842 type based fixed bin(18,0) level 2 in structure "type_pr" packed packed unsigned unaligned dcl 807 in procedure "convert_trap_link" ref 830 838 872 type based fixed bin(17,0) level 2 in structure "info" dcl 1722 in procedure "meter" ref 1761 1761 1778 1778 type parameter fixed bin(18,0) unsigned dcl 1718 in procedure "meter" ref 1699 1761 1761 1771 type based fixed bin(17,0) level 2 in structure "info" dcl 2037 in procedure "exit" ref 2042 2044 2049 type based fixed bin(3,0) level 2 in structure "link_pair" packed packed unsigned unaligned dcl 1583 in procedure "snap_partial_link" ref 1621 1623 1625 1627 type 1 based fixed bin(17,0) level 3 in structure "init_info" dcl 1110 in procedure "deferred_init" ref 1126 type based fixed bin(18,0) level 2 in structure "type_pr" packed packed unsigned unaligned dcl 165 in procedure "link_snap" ref 398 404 414 423 444 449 453 456 467 471 486 491 503 507 536 550 type based fixed bin(18,0) level 2 in structure "type_pr" packed packed unsigned unaligned dcl 1312 in procedure "get_offsetnamep" ref 1321 type 000212 automatic fixed bin(17,0) level 2 in structure "call_info" dcl 178 in procedure "link_snap" set ref 260* 322* 356 590* 624* 705 type_6_pf 20 based fixed bin(30,0) level 2 dcl 1723 set ref 1774* 1774 type_6_time 21 based fixed bin(35,0) level 2 dcl 1723 set ref 1775* 1775 type_pair based structure level 1 dcl 1-160 type_pr based structure level 1 dcl 807 in procedure "convert_trap_link" type_pr based structure level 1 dcl 1107 in procedure "deferred_init" type_pr based structure level 1 dcl 1020 in procedure "star_heap" type_pr based structure level 1 dcl 1312 in procedure "get_offsetnamep" type_pr based structure level 1 dcl 165 in procedure "link_snap" type_prp parameter pointer dcl 792 in procedure "convert_trap_link" ref 761 817 818 824 826 830 830 838 872 872 880 type_prp parameter pointer dcl 1304 in procedure "get_offsetnamep" ref 1282 1314 1320 1321 type_prp 000420 automatic pointer dcl 209 in procedure "link_snap" set ref 381* 387* 395* 398 404 404 412* 414 423 423 433* 444 446 449 453 456 458 467 471 473 482* 486 491 493 499* 503 507 514 526* 530 532 533* 536 541* 550 type_prp parameter pointer dcl 1011 in procedure "star_heap" ref 987 1031 1034 1036 type_prp parameter pointer dcl 939 in procedure "star_system" set ref 909 970* type_prp 000616 automatic pointer dcl 1118 in procedure "deferred_init" set ref 1153* 1154 1156 type_relp based fixed bin(18,0) level 2 in structure "expr" packed packed unsigned unaligned dcl 1108 in procedure "deferred_init" ref 1153 type_relp based fixed bin(18,0) level 2 in structure "expr" packed packed unsigned unaligned dcl 157 in procedure "link_snap" ref 381 type_relp based fixed bin(18,0) level 2 in structure "exp_word" packed packed unsigned unaligned dcl 1-129 in procedure "link_snap" ref 881 unspec builtin function dcl 230 set ref 728* 729* usage based structure level 1 dcl 166 usage_values 000040 constant entry external dcl 122 ref 354 636 1264 1268 1372 1377 1470 1473 1485 1488 1601 1603 1734 variable_node based structure level 1 dcl 7-33 vbl_ptr 4 based pointer level 2 dcl 7-33 ref 978 1058 virgin_linkage_header based structure level 1 dcl 5-71 zero_word 000030 constant bit(36) initial packed unaligned dcl 84 set ref 498 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. 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 FAULT_TAG_1 internal static bit(6) initial packed unaligned dcl 5-100 FR_TRAPS_VERSION_1 internal static fixed bin(17,0) initial dcl 5-99 INIT_COPY_INFO 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 2-56 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 abx internal static fixed bin(17,0) initial dcl 4-42 acc_string_length automatic fixed bin(21,0) dcl 1-334 acc_string_ptr automatic pointer dcl 1-326 apx internal static fixed bin(17,0) initial dcl 4-42 bbx internal static fixed bin(17,0) initial dcl 4-42 boundfault_end internal static fixed bin(17,0) initial dcl 8-3 boundfault_start internal static fixed bin(17,0) initial dcl 8-3 bpx internal static fixed bin(17,0) initial dcl 4-42 call_offset internal static fixed bin(17,0) initial dcl 6-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 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 6-78 exp_ptr automatic pointer dcl 1-128 extended_page_fault_type internal static fixed bin(17,0) initial dcl 8-3 fr_traps based structure level 1 dcl 5-90 heap_header based structure level 1 unaligned dcl 7-64 heap_header_version_1 internal static char(8) initial packed unaligned dcl 7-71 interrupt_type internal static fixed bin(17,0) initial dcl 8-3 itp based structure level 1 dcl 2-18 itp_unsigned based structure level 1 dcl 2-43 its_unsigned based structure level 1 dcl 2-30 lbx internal static fixed bin(17,0) initial dcl 4-42 link_init_copy_info based structure level 1 dcl 1-211 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_ptr automatic pointer dcl 1-176 linkage_header_flags based structure level 1 dcl 5-63 list_template_entry based structure level 1 dcl 1-239 lpx internal static fixed bin(17,0) initial dcl 4-42 marker_type internal static fixed bin(17,0) initial dcl 8-3 msf_map based structure level 1 dcl 1-318 msf_map_ptr automatic pointer dcl 1-317 msf_map_version_1 internal static char(8) initial packed unaligned dcl 1-323 page_fault_type internal static fixed bin(17,0) initial dcl 8-3 pointer_init_template based structure level 1 packed packed unaligned dcl 1-253 push_offset internal static fixed bin(17,0) initial dcl 6-78 reschedule_type internal static fixed bin(17,0) initial dcl 8-3 restart_fault_type internal static fixed bin(17,0) initial dcl 8-3 return_no_pop_offset internal static fixed bin(17,0) initial dcl 6-78 return_offset internal static fixed bin(17,0) initial dcl 6-78 sb automatic pointer dcl 6-24 sbx internal static fixed bin(17,0) initial dcl 4-42 scux based structure level 1 dcl 4-207 seg_fault_end internal static fixed bin(17,0) initial dcl 8-3 seg_fault_start internal static fixed bin(17,0) initial dcl 8-3 segname_definition based structure level 1 dcl 1-90 segname_ptr automatic pointer dcl 1-89 signaller_type internal static fixed bin(17,0) initial dcl 8-3 spx internal static fixed bin(17,0) initial dcl 4-42 stack_header_overlay based fixed bin(17,0) array dcl 6-94 tv_offset internal static fixed bin(17,0) initial dcl 6-72 type_ptr automatic pointer dcl 1-159 variable_table_header based structure level 1 dcl 7-19 NAMES DECLARED BY EXPLICIT CONTEXT. CONNECT_FAIL_EXIT 002026 constant label dcl 1988 ref 1984 EXIT 002032 constant label dcl 2069 set ref 2065 adjust_mc 004745 constant entry internal dcl 1870 ref 432 1833 2053 combine_linkage 003362 constant entry internal dcl 1332 ref 713 1464 1617 connect_fail_handler_ 004770 constant entry internal dcl 1915 ref 481 481 540 540 696 696 convert_trap_link 002033 constant entry internal dcl 761 ref 387 deferred_init 002733 constant entry internal dcl 1067 ref 961 1046 exit 005041 constant entry internal dcl 1996 ref 284 356 359 369 375 399 415 438 450 453 464 468 479 488 504 537 552 555 691 718 754 894 973 1053 1132 1139 1147 1200 1213 1384 1387 1497 1515 1529 1549 1612 1629 1857 1988 get_definition 003504 constant entry internal dcl 1397 ref 483 500 545 749 get_offsetnamep 003322 constant entry internal dcl 1282 ref 482 499 526 541 link_fault 000055 constant entry external dcl 239 link_force 000212 constant entry external dcl 294 ref 893 link_join 000254 constant label dcl 341 ref 287 link_snap 000044 constant entry external dcl 35 make_entry 001376 constant entry external dcl 599 make_join 001430 constant label dcl 636 ref 592 make_ptr 001340 constant entry external dcl 562 meter 004420 constant entry internal dcl 1699 ref 398 414 449 467 486 503 536 550 705 715 752 search_for_segment 003222 constant entry internal dcl 1222 ref 462 477 518 self_reference 003116 constant entry internal dcl 1165 ref 446 493 snap 004352 constant entry internal dcl 1638 ref 397 413 448 466 485 502 535 549 snap_partial_link 004111 constant entry internal dcl 1558 ref 1534 star_heap 002544 constant entry internal dcl 987 ref 412 star_system 002371 constant entry internal dcl 909 ref 395 533 trap 004602 constant entry internal dcl 1792 ref 487 551 716 753 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 6254 6356 5646 6264 Length 6776 5646 102 404 405 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME link_snap 942 external procedure is an external procedure. convert_trap_link internal procedure shares stack frame of external procedure link_snap. star_system internal procedure shares stack frame of external procedure link_snap. star_heap internal procedure shares stack frame of external procedure link_snap. deferred_init internal procedure shares stack frame of external procedure link_snap. self_reference internal procedure shares stack frame of external procedure link_snap. search_for_segment internal procedure shares stack frame of external procedure link_snap. get_offsetnamep internal procedure shares stack frame of external procedure link_snap. combine_linkage internal procedure shares stack frame of external procedure link_snap. get_definition internal procedure shares stack frame of external procedure link_snap. snap_partial_link internal procedure shares stack frame of external procedure link_snap. snap internal procedure shares stack frame of external procedure link_snap. meter internal procedure shares stack frame of external procedure link_snap. trap internal procedure shares stack frame of external procedure link_snap. adjust_mc internal procedure shares stack frame of external procedure link_snap. connect_fail_handler_ 69 internal procedure is assigned to an entry variable. exit internal procedure shares stack frame of external procedure link_snap. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME connect_fail_handler_ 000100 faulted_segno connect_fail_handler_ 000101 segno connect_fail_handler_ 000102 scup connect_fail_handler_ link_snap 000100 automatic_offsetname link_snap 000201 automatic_segname link_snap 000212 call_info link_snap 000244 call_infop link_snap 000246 code link_snap 000247 connect_fail_code link_snap 000250 defp link_snap 000252 exprp link_snap 000254 init_infop link_snap 000256 instrp link_snap 000260 link_pairp link_snap 000262 linkp link_snap 000264 nchars link_snap 000265 offset_name link_snap 000366 offsetnamep link_snap 000370 refp link_snap 000372 retry_sw link_snap 000373 seg_name link_snap 000404 segnamep link_snap 000406 segp link_snap 000410 star_system_sw link_snap 000412 target_linkagep link_snap 000414 targetp link_snap 000416 textp link_snap 000420 type_prp link_snap 000422 MSF_sw link_snap 000424 def_ptr link_snap 000426 mcp link_snap 000430 scup link_snap 000442 code convert_trap_link 000444 init_linkp convert_trap_link 000446 offsetnamep convert_trap_link 000450 segnamep convert_trap_link 000452 trapp convert_trap_link 000462 code star_system 000464 sb star_system 000474 init_infop star_heap 000476 offsetnamep star_heap 000500 sb star_heap 000502 offset_name star_heap 000610 target_ptr_ptr deferred_init 000612 lhp deferred_init 000614 exprp deferred_init 000616 type_prp deferred_init 000620 link_pairp deferred_init 000630 code self_reference 000632 linkp self_reference 000634 staticp self_reference 000636 symbolp self_reference 000646 finish search_for_segment 000652 start search_for_segment 000672 finish combine_linkage 000676 start combine_linkage 000710 code get_definition 000712 defp get_definition 000714 finish get_definition 000720 linkp get_definition 000722 start get_definition 000726 statp get_definition 000730 symbp get_definition 000732 textp get_definition 000742 finish snap_partial_link 000746 linkp snap_partial_link 000750 refname snap_partial_link 000760 start snap_partial_link 000764 statp snap_partial_link 000766 symbp snap_partial_link 000770 textp snap_partial_link 001000 modifier snap 001002 sb snap 001012 elapsed_time meter 001013 elapsed_pf meter 001014 bin_no meter 001016 lmp meter 001034 scup adjust_mc 001036 instrp adjust_mc THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_char_temp cat_realloc_chars call_ext_in call_ext_out_desc call_ext_out return_mac tra_ext_1 shorten_stack ext_entry ext_entry_desc int_entry_desc set_chars_eis index_chars_eis THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. condition_ fs_search fs_search$same_directory get_defptr_ level$get level$set link_man$other_linkage link_man$own_linkage page$enter_data set_ext_variable_$for_linker set_ext_variable_$star_heap trap_caller_caller_ usage_values THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. ahd$link_meters error_table_$bad_class_def error_table_$bad_deferred_init error_table_$bad_indirect_def error_table_$bad_link_type error_table_$bad_self_ref error_table_$first_reference_trap error_table_$illegal_ft2 error_table_$no_defs error_table_$no_ext_sym error_table_$no_linkage error_table_$unexpected_ft2 pds$link_meters_bins pds$link_meters_pgwaits pds$link_meters_times pds$stacks LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 35 000043 232 000051 239 000052 257 000062 259 000066 260 000070 261 000072 262 000073 266 000104 270 000106 271 000111 275 000123 276 000136 280 000150 284 000164 287 000205 294 000206 313 000222 317 000224 321 000230 322 000232 323 000234 324 000236 329 000240 334 000242 341 000254 346 000256 347 000257 348 000260 349 000261 350 000262 354 000263 356 000274 359 000313 363 000330 364 000335 365 000342 369 000344 371 000366 375 000370 380 000411 381 000417 387 000424 390 000426 395 000431 397 000433 398 000441 399 000446 404 000451 412 000465 413 000467 414 000475 415 000502 423 000505 432 000522 433 000524 438 000547 444 000555 446 000564 448 000572 449 000600 450 000605 451 000610 453 000611 456 000633 458 000637 459 000645 461 000656 462 000657 464 000661 466 000671 467 000677 468 000704 469 000707 471 000710 473 000714 474 000722 476 000733 477 000734 479 000736 481 000746 482 000774 483 000776 485 001000 486 001006 487 001013 488 001015 489 001020 491 001021 493 001025 498 001033 499 001035 500 001037 502 001043 503 001051 504 001056 505 001061 507 001062 514 001066 515 001074 517 001105 518 001106 520 001110 526 001114 527 001116 529 001142 530 001200 532 001210 533 001213 535 001215 536 001223 537 001230 540 001233 541 001261 545 001263 548 001272 549 001274 550 001302 551 001307 552 001311 553 001314 555 001315 562 001332 586 001363 590 001366 592 001370 599 001371 624 001421 628 001423 629 001426 636 001430 641 001441 645 001457 646 001461 647 001462 648 001463 649 001464 650 001465 654 001466 655 001470 656 001472 657 001475 661 001477 662 001503 663 001510 667 001515 671 001516 674 001524 675 001550 677 001554 681 001562 682 001565 684 001576 690 001577 691 001627 696 001635 698 001663 700 001675 705 001676 713 001707 715 001715 716 001722 718 001724 723 001727 724 001731 728 001733 729 001736 733 001741 734 001754 737 001761 738 001774 745 002001 747 002010 749 002012 752 002014 753 002021 754 002023 1988 002026 2069 002032 761 002033 817 002035 818 002045 822 002053 823 002057 824 002065 826 002101 830 002106 832 002123 833 002127 838 002130 843 002134 845 002146 846 002152 851 002153 854 002173 855 002200 856 002206 858 002215 860 002216 864 002217 866 002223 867 002240 868 002246 872 002247 880 002263 881 002270 889 002331 893 002337 894 002352 897 002360 898 002364 902 002370 909 002371 955 002373 957 002417 961 002422 970 002435 973 002517 978 002536 980 002543 987 002544 1031 002546 1032 002556 1034 002563 1036 002574 1040 002601 1042 002625 1046 002630 1051 002643 1053 002706 1058 002725 1060 002732 1067 002733 1123 002735 1126 002742 1131 002750 1132 002756 1138 002777 1139 003002 1141 003025 1146 003027 1147 003041 1152 003063 1153 003071 1154 003076 1156 003110 1158 003115 1165 003116 1199 003120 1200 003137 1205 003156 1207 003165 1209 003172 1211 003177 1213 003204 1215 003221 1222 003222 1264 003224 1266 003235 1268 003276 1272 003307 1273 003315 1275 003321 1282 003322 1314 003324 1320 003337 1321 003344 1325 003361 1332 003362 1372 003364 1374 003375 1375 003401 1377 003420 1381 003431 1382 003437 1384 003443 1387 003461 1390 003503 1397 003504 1459 003506 1464 003513 1468 003534 1470 003537 1471 003550 1473 003570 1477 003601 1478 003607 1480 003613 1485 003624 1486 003634 1488 003656 1492 003667 1493 003675 1497 003701 1502 003717 1515 003723 1520 003745 1521 003754 1523 003761 1524 003763 1529 003764 1534 004003 1535 004016 1536 004023 1541 004024 1543 004037 1545 004050 1547 004061 1549 004072 1551 004110 1558 004111 1597 004113 1601 004144 1602 004155 1603 004202 1607 004213 1608 004221 1612 004225 1617 004243 1621 004264 1623 004301 1625 004312 1627 004323 1629 004334 1631 004351 1638 004352 1673 004354 1677 004361 1681 004366 1685 004367 1689 004373 1690 004410 1692 004417 1699 004420 1734 004422 1738 004435 1739 004443 1743 004446 1747 004460 1748 004463 1750 004467 1755 004474 1757 004501 1758 004505 1759 004507 1761 004513 1764 004530 1765 004532 1766 004535 1767 004537 1768 004542 1769 004544 1770 004547 1771 004550 1773 004554 1774 004555 1775 004557 1776 004563 1778 004564 1780 004572 1781 004573 1782 004575 1785 004601 1792 004602 1825 004604 1827 004610 1833 004620 1837 004630 1840 004636 1842 004645 1848 004653 1852 004667 1857 004721 1863 004744 1870 004745 1901 004747 1904 004754 1905 004760 1906 004762 1907 004764 1909 004766 1915 004767 1962 005003 1963 005010 1964 005014 1965 005020 1969 005025 1971 005027 1972 005033 1977 005034 1984 005036 1996 005041 2042 005043 2044 005054 2049 005062 2051 005066 2052 005100 2053 005106 2054 005114 2055 005115 2059 005117 2061 005137 2065 005155 ----------------------------------------------------------- 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