THIS FILE IS DAMAGED COMPILATION LISTING OF SEGMENT le_make_link_tbl_ Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Multics Op. - System M Compiled on: 12/10/86 1256.9 mst Wed Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1986 * 4* * * 5* *********************************************************** */ 6 7 /****^ HISTORY COMMENTS: 8* 1) change(86-08-12,Elhard), approve(86-08-12,MCR7505), 9* audit(86-12-10,DGHowe), install(86-12-10,MR12.0-1241): 10* Originally written to create a link table for each component containing a 11* list of the links and the target that they resolve to (if they resolve 12* internally). 13* END HISTORY COMMENTS */ 14 15 /* format: style1,insnl,ifthendo,indthenelse,^indnoniterdo,^inditerdo,indcom,^indthenbegin,^indprocbody,ind2,ll78,initcol0,dclind4,idind24,struclvlind1,comcol41 */ 16 17 le_make_link_tbl_: 18 proc (lecp, /** component table ptr (i/o) */ 19 leshp, /** seg hashtable ptr (in ) */ 20 leap); /** le_area pointer (in ) */ 21 22 /*** ****************************************************************/ 23 /*** */ 24 /*** Name: le_make_link_tbl_ */ 25 /*** Input: lecp, leshp, leap */ 26 /*** Function: creates the link table from the input components. */ 27 /*** The link table contains pointers to each type-4 */ 28 /*** link in the input components and the index of the */ 29 /*** component containing the link. It is used when */ 30 /*** resolving links and to determine which library */ 31 /*** components are included in the eventual output. */ 32 /*** Output: lecp */ 33 /*** */ 34 /*** ****************************************************************/ 35 36 /* constants */ 37 38 dcl true bit (1) static options (constant) init ("1"b); 39 dcl false bit (1) static options (constant) init ("0"b); 40 dcl None fixed bin static options (constant) init (0); 41 42 /* parameters */ 43 44 dcl lecp ptr parameter; 45 dcl leshp ptr parameter; 46 dcl leap ptr parameter; 47 48 /* procedures */ 49 50 dcl hash_$search entry (ptr, char (*), bit (36) aligned, 51 fixed bin (35)); 52 dcl le_debug_ entry options (variable); 53 dcl le_error_ entry options (variable); 54 55 /* external */ 56 57 dcl error_table_$no_ext_sym external fixed bin (35); 58 dcl le_et_$not_linkfault external fixed bin (35); 59 60 /* based */ 61 62 dcl le_area area based (leap); 63 dcl 01 lec aligned based (lecp), 64 02 header aligned like le_components.header, 65 02 comp dim (0 refer (lec.n_components)) like le_comp; 66 67 /* static */ 68 69 dcl 01 default_init static aligned like link_init; 70 dcl setup bit (1) static init ("0"b); 71 72 /* automatic */ 73 74 dcl c fixed bin automatic; 75 dcl head fixed bin automatic; 76 dcl tail fixed bin automatic; 77 78 /* builtin */ 79 80 dcl addr builtin; 81 dcl addrel builtin; 82 dcl fixed builtin; 83 dcl null builtin; 84 dcl rel builtin; 85 dcl size builtin; 86 dcl unspec builtin; 87 88 if ^setup 89 then do; 90 default_init.type = INIT_NO_INIT; 91 default_init.n_words = 0; 92 setup = true; 93 end; 94 95 call le_debug_ ("Beginning link resolution."); 96 97 lec.comp (*).next_comp = None; 98 99 /* thread all of the PATH components into the processing list initially */ 100 101 head = 1; 102 tail = 1; 103 lec.comp (1).flags.include = true; 104 105 do c = 2 to lec.n_components while (^lec.comp (c).library); 106 lec.comp (c - 1).next_comp = c; 107 lec.comp (c).flags.include = true; 108 tail = c; 109 end; 110 111 lec.comp (tail).next_comp = None; 112 113 /* scan the processing list. Any time a link resolves to a */ 114 /* component that is not already in the list, add it to the end of */ 115 /* the list and continue. */ 116 117 do while (head ^= None); 118 119 /* process the links from this component and resolve the type-3 */ 120 /* and type-4 links that can be snapped internally. */ 121 122 call get_links (lecp, leshp, head, tail); 123 124 /* if there are components referenced by this one, then process */ 125 /* them as well before going on to the next input component. */ 126 127 head = lec.comp (head).next_comp; 128 129 end; 130 131 call le_debug_ ("Completed link resolution.^2/"); 132 133 return; 134 135 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 136 137 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 138 139 140 get_links: 141 proc (lecp, /** components pointer (i/o) */ 142 leshp, /** seg hashtable ptr (in ) */ 143 c, /** component index (in ) */ 144 tail); /** comp list tail (i/o) */ 145 146 /*** ****************************************************************/ 147 /*** */ 148 /*** Name: get_links */ 149 /*** Input: lecp, leshp, c, tail */ 150 /*** Function: extracts link information from the linkage */ 151 /*** section of an input component and attempts to */ 152 /*** determine the target of each link. When a link */ 153 /*** is chased to another component, that component */ 154 /*** is checked to see if it is to be included in the */ 155 /*** final output already. If not, it is appended */ 156 /*** to the list of components to be processed. */ 157 /*** Output: lecp, tail */ 158 /*** */ 159 /*** ****************************************************************/ 160 161 /* parameters */ 162 163 dcl lecp ptr parameter; 164 dcl leshp ptr parameter; 165 dcl c fixed bin parameter; 166 dcl tail fixed bin parameter; 167 168 /* based */ 169 170 dcl 01 lel aligned based (lelp), 171 02 header aligned like le_links.header, 172 02 link dim (link_count refer (lel.n_links)) 173 like le_link; 174 dcl 01 vlh aligned like virgin_linkage_header based (vlhp); 175 176 /* automatic */ 177 178 dcl dhp ptr automatic; 179 dcl end_offset fixed bin (18) unsigned automatic; 180 dcl found bit (1) automatic; 181 dcl index fixed bin automatic; 182 dcl lelp ptr automatic; 183 dcl linkp ptr automatic; 184 dcl offset fixed bin (18) unsigned automatic; 185 dcl start_offset fixed bin (18) unsigned automatic; 186 dcl t fixed bin automatic; 187 dcl vlhp ptr automatic; 188 189 /* get pointers to the definition and linkage sections */ 190 191 vlhp = lec.comp (c).orig.linkp; 192 dhp = lec.comp (c).orig.defnp; 193 194 /* find the end of the link array */ 195 196 end_offset = vlh.linkage_section_lng - size (object_link); 197 198 if vlh.first_ref_relp ^= 0 199 then end_offset = vlh.first_ref_relp - size (object_link); 200 201 start_offset = vlh.link_begin; 202 203 /* set the link start offset for this component */ 204 205 if start_offset > end_offset 206 then do; 207 link_count = 0; 208 allocate lel in (le_area) set (lec.comp (c).tables.lelp); 209 return; 210 end; 211 212 /* determine the number of links */ 213 214 link_count = (end_offset - start_offset) / size (object_link) + 1; 215 216 /* allocate the link table */ 217 218 allocate lel in (le_area) set (lelp); 219 lec.comp (c).tables.lelp = lelp; 220 221 lel.offset_adjustment = start_offset - size (object_link); 222 223 /* scan the link array and attempt to resolve each link */ 224 225 do index = 1 to link_count; 226 offset = lel.offset_adjustment + (index + index); 227 linkp = addrel (vlhp, offset); 228 call process_link (lecp, leshp, linkp, dhp, c, index, t, found); 229 230 /* if the link was resolved internally, see if the target */ 231 /* component is already included in the output */ 232 233 if found 234 then do; 235 236 /* if not already included, thread it into the processing */ 237 /* list and flag that it has been included. */ 238 239 if ^lec.comp (t).flags.include 240 then do; 241 242 call le_debug_ ("Including library component ""^a""", 243 lec.comp (t).name); 244 245 lec.comp (tail).next_comp = t; 246 tail = t; 247 lec.comp (t).flags.include = true; 248 lec.comp (t).next_comp = None; 249 end; 250 end; 251 end; 252 253 end get_links; 254 255 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 256 257 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 258 259 260 process_link: 261 proc (lecp, /** components pointer (in ) */ 262 leshp, /** seg hashtable ptr (in ) */ 263 linkp, /** link to resolve (in ) */ 264 dhp, /** def header pointer (in ) */ 265 c, /** component index (in ) */ 266 lx, /** index of link (in ) */ 267 t, /** target component (out) */ 268 found); /** found flag (out) */ 269 270 /*** ****************************************************************/ 271 /*** */ 272 /*** Name: process_link */ 273 /*** Input: lecp, leshp, linkp, dhp, c, lx */ 274 /*** Function: attempts to resolve a single link to a component */ 275 /*** in the component table. This involves identifying */ 276 /*** the component by searching the segname table and */ 277 /*** then searching the definitions for that component */ 278 /*** looking for a match. */ 279 /*** Output: t, found */ 280 /*** */ 281 /*** ****************************************************************/ 282 283 /* parameters */ 284 285 dcl lecp ptr parameter; 286 dcl leshp ptr parameter; 287 dcl linkp ptr parameter; 288 dcl dhp ptr parameter; 289 dcl c fixed bin parameter; 290 dcl lx fixed bin parameter; 291 dcl t fixed bin parameter; 292 dcl found bit (1) parameter; 293 294 /* based */ 295 296 dcl 01 exp aligned like exp_word based (expp); 297 dcl 01 init aligned like link_init based (initp); 298 dcl 01 lec aligned based (lecp), 299 02 header aligned like le_components.header, 300 02 comp dim (0 refer (lec.n_components)) like le_comp; 301 dcl 01 led aligned based (ledp), 302 02 header aligned like le_definitions.header, 303 02 def dim (0 refer (led.n_defs)) like le_definition; 304 dcl 01 lel aligned based (lelp), 305 02 header aligned like le_links.header, 306 02 link dim (0 refer (lel.n_links)) like le_link; 307 dcl 01 link aligned like object_link based (linkp); 308 dcl 01 lk aligned like le_link based (lkp); 309 dcl 01 offset_acc aligned based (offset_accp), 310 02 count fixed bin (9) unsigned unaligned, 311 02 string char (0 refer (offset_acc.count)) unaligned; 312 dcl 01 seg_acc aligned based (seg_accp), 313 02 count fixed bin (9) unsigned unaligned, 314 02 string char (0 refer (seg_acc.count)) unaligned; 315 dcl 01 seg_addr aligned based (addr (seg_bits)), 316 02 comp fixed bin (17) unaligned, 317 02 index fixed bin (17) unaligned; 318 dcl 01 tlel aligned based (tlelp), 319 02 header aligned like le_links.header, 320 02 link dim (0 refer (tlel.n_links)) like le_link; 321 dcl 01 tlk aligned like le_link based (tlkp); 322 dcl 01 type_pr aligned like type_pair based (type_prp); 323 324 /* automatic */ 325 326 dcl dx fixed bin automatic; 327 dcl ec fixed bin (35) automatic; 328 dcl expp ptr automatic; 329 dcl initp ptr automatic; 330 dcl ledp ptr automatic; 331 dcl lelp ptr automatic; 332 dcl lkp ptr automatic; 333 dcl offset fixed bin (18) unsigned automatic; 334 dcl offset_accp ptr automatic; 335 dcl seg_accp ptr automatic; 336 dcl seg_bits bit (36) aligned automatic; 337 dcl tc fixed bin automatic; 338 dcl tl fixed bin automatic; 339 dcl tlelp ptr automatic; 340 dcl tlkp ptr automatic; 341 dcl type_prp ptr automatic; 342 343 found = false; 344 t = None; 345 offset = fixed (rel (linkp), 18) - 346 fixed (rel (lec.comp (c).orig.linkp), 18); 347 348 /* make sure the link is actually an unsnapped link */ 349 350 if link.tag ^= FAULT_TAG_2 351 then do; 352 call le_error_ (LE_WARNING, le_et_$not_linkfault, "tag ^2o at link|^o", 353 link.tag, offset); 354 return; 355 end; 356 357 /* get the type_pair and expression word */ 358 359 expp = addrel (dhp, link.expression_relp); 360 type_prp = addrel (dhp, type_relp); 361 362 lelp = lec.comp (c).tables.lelp; 363 364 /* fill in the link table entry */ 365 366 lkp = addr (lel.link (lx)); 367 368 unspec (lk) = ""b; 369 370 lk.flags.used = false; 371 lk.type = type_pr.type; 372 if type_pr.type = LINK_SELF_BASE | type_pr.type = LINK_SELF_OFFSETNAME 373 then do; 374 lk.class = type_pr.segname_relp; 375 lk.segnamep = null; 376 end; 377 else do; 378 lk.class = None; 379 seg_accp, lk.segnamep = addrel (dhp, type_pr.segname_relp); 380 end; 381 if type_pr.type = LINK_SELF_BASE | type_pr.type = LINK_REFNAME_BASE 382 then lk.offsetp = null; 383 else offset_accp, lk.offsetp = addrel (dhp, type_pr.offsetname_relp); 384 lk.mod = link.modifier; 385 lk.exp = exp.expression; 386 lk.target = None; 387 lk.defx = None; 388 lk.relp = None; 389 lk.target_link = None; 390 lk.target_comp = None; 391 lk.extension = None; 392 if type_pr.type = LINK_SELF_OFFSETNAME & 393 (type_pr.segname_relp = CLASS_SYSTEM | 394 type_pr.segname_relp = CLASS_HEAP) 395 then if type_pr.trap_relp = 0 396 then lk.initp = addr (default_init); 397 else lk.initp = addrel (dhp, type_pr.trap_relp); 398 else lk.initp = null; 399 400 if type_pr.type = LINK_SELF_BASE 401 then return; 402 403 if type_pr.type = LINK_SELF_OFFSETNAME 404 then do; 405 406 /* we only deal with *system and *heap links */ 407 408 if type_pr.segname_relp < CLASS_SYSTEM 409 then return; 410 411 initp = lk.initp; 412 413 /* we have a valid initialization so continue */ 414 415 if init.type ^= INIT_NO_INIT 416 then do; 417 418 /* flag that the link has been processed and return */ 419 420 lk.flags.used = true; 421 return; 422 end; 423 424 do tc = 1 repeat lec.comp (tc).next_comp while (tc ^= None); 425 426 /* get the link table for the component */ 427 428 tlelp = lec.comp (tc).tables.lelp; 429 430 /* scan each link looking for a matching link */ 431 432 if tlelp ^= null 433 then 434 do tl = 1 to tlel.n_links; 435 tlkp = addr (tlel.link (tl)); 436 437 /* see if the link is to the same target */ 438 439 if tlk.type = LINK_SELF_OFFSETNAME & tlk.class = lk.class 440 then do; 441 442 if tlk.offsetp -> acc_string.string = offset_acc.string 443 then do; 444 445 /* if we find a valid init, we can return */ 446 447 initp = tlk.initp; 448 if init.type ^= INIT_NO_INIT | lk.flags.used 449 then do; 450 lk.flags.used = true; 451 return; 452 end; 453 end; 454 end; 455 end; 456 else do; 457 458 if has_init (lecp, tc, lk.class, offset_accp) 459 then do; 460 lk.flags.used = true; 461 return; 462 end; 463 end; 464 465 end; 466 467 /* if we get here, we have searched all of the linkage */ 468 /* sections for an init for this link and haven't found one, */ 469 /* so we now scan the unincluded components and include the */ 470 /* first component which has an initialization for this link */ 471 472 do tc = 1 to lec.n_components; 473 474 /* only process unincluded components */ 475 476 if ^lec.comp (tc).flags.include 477 then do; 478 479 if has_init (lecp, tc, lk.class, offset_accp) 480 then do; 481 482 t = tc; 483 found = true; 484 lk.flags.used = true; 485 return; 486 end; 487 end; 488 end; 489 490 /* there is no initialization info for this link anywhere */ 491 492 lk.flags.used = true; 493 return; 494 495 end; 496 497 /* if the link cannot be resolved to another component, just return */ 498 /* otherwise we search for a matching segname */ 499 500 call hash_$search (leshp, seg_acc.string, seg_bits, ec); 501 if ec ^= 0 502 then return; 503 504 /* if not found, the link remains external */ 505 506 if type_pr.type = LINK_REFNAME_BASE 507 then do; 508 509 /* type-3 links resolve to the base of the text for the target seg */ 510 511 call le_debug_ ( 512 "Resolved link ^a|0^/ in component ^a^/ to component ^a", 513 seg_acc.string, lec.comp (c).name, 514 lec.comp (seg_addr.comp).name); 515 516 t, lk.target = seg_addr.comp; 517 found = true; 518 return; 519 end; 520 521 /* if we found the segname, now look for the definition name */ 522 523 offset_accp = addrel (dhp, type_pr.offsetname_relp); 524 ledp = lec.comp (seg_addr.comp).tables.ledp; 525 526 do dx = 1 to led.n_defs while (^found); 527 if led.def (dx).str = offset_acc.string 528 then do; 529 530 /* found the definition, save the definition table index */ 531 532 call le_debug_ ( 533 "Resolved link ^a$^a^/ in component ^a^/ to component ^a", 534 seg_acc.string, offset_acc.string, lec.comp (c).name, 535 lec.comp (seg_addr.comp).name); 536 537 led.def (dx).flags.referenced = true; 538 539 /* reference the definition to force library retention but */ 540 /* actually snap the link */ 541 542 if led.def (dx).flags.no_link 543 then return; 544 545 t, lk.target = seg_addr.comp; 546 lk.defx = dx; 547 found = true; 548 end; 549 end; 550 551 if ^found 552 then call le_error_ (LE_WARNING, error_table_$no_ext_sym, 553 "^/Could not find definition ""^a"" in ""^a"";" || 554 " external link generated.", offset_acc.string, seg_acc.string); 555 556 return; 557 558 end process_link; 559 560 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 561 562 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 563 564 565 has_init: 566 proc (lecp, /** component info ptr (in ) */ 567 c, /** component index (in ) */ 568 class, /** link class (in ) */ 569 namep) /** name acc string ptr (in ) */ 570 returns (bit (1)); /** has init flag (out) */ 571 572 /*** ****************************************************************/ 573 /*** */ 574 /*** Name: has_init */ 575 /*** Input: lecp, c, class, namep */ 576 /*** Function: searches a linkage section for a particular */ 577 /*** *system or *heap link that has valid init info. */ 578 /*** (i.e. not INIT_NO_INIT) */ 579 /*** Output: init_found_sw */ 580 /*** */ 581 /*** ****************************************************************/ 582 583 /* parameters */ 584 585 dcl lecp ptr parameter; 586 dcl c fixed bin parameter; 587 dcl class fixed bin (6) unsigned unaligned parameter; 588 dcl namep ptr parameter; 589 590 /* based */ 591 592 dcl 01 exp aligned like exp_word based (expp); 593 dcl 01 init aligned like link_init based (initp); 594 dcl 01 lec aligned based (lecp), 595 02 header aligned like le_components.header, 596 02 comp dim (0 refer (lec.n_components)) like le_comp; 597 dcl 01 link aligned like object_link based (linkp); 598 dcl 01 name aligned based (namep), 599 02 count fixed bin (9) unsigned unaligned, 600 02 string char (0 refer (name.count)) unaligned; 601 dcl 01 offset_acc aligned based (offset_accp), 602 02 count fixed bin (9) unsigned unaligned, 603 02 string char (0 refer (offset_acc.count)) unaligned; 604 dcl 01 type_pr aligned like type_pair based (type_prp); 605 dcl 01 vlh aligned like virgin_linkage_header based (vlhp); 606 607 /* automatic */ 608 609 dcl dhp ptr automatic; 610 dcl end_offset fixed bin (18) unsigned automatic; 611 dcl expp ptr automatic; 612 dcl initp ptr automatic; 613 dcl linkp ptr automatic; 614 dcl offset fixed bin (18) unsigned automatic; 615 dcl offset_accp ptr automatic; 616 dcl start_offset fixed bin (18) unsigned automatic; 617 dcl type_prp ptr automatic; 618 dcl vlhp ptr automatic; 619 620 /* get pointers to the definition and linkage sections */ 621 622 vlhp = lec.comp (c).orig.linkp; 623 dhp = lec.comp (c).orig.defnp; 624 625 /* find the end of the link array */ 626 627 end_offset = vlh.linkage_section_lng - size (link); 628 629 if vlh.first_ref_relp ^= None 630 then end_offset = vlh.first_ref_relp - size (link); 631 632 start_offset = vlh.link_begin; 633 634 /* look at each link in the linkage section */ 635 636 do offset = start_offset to end_offset by size (link); 637 638 /* get the name, type, class, and init pointers */ 639 640 linkp = addrel (vlhp, offset); 641 expp = addrel (dhp, link.expression_relp); 642 type_prp = addrel (dhp, exp.type_relp); 643 644 /* if the type and class are the same. . . */ 645 646 if type_pr.type = LINK_SELF_OFFSETNAME & 647 type_pr.segname_relp = class & 648 type_pr.trap_relp ^= None 649 then do; 650 651 /* check out the names . . . */ 652 653 offset_accp = addrel (dhp, type_pr.offsetname_relp); 654 655 if name.string = offset_acc.string 656 then do; 657 658 /* OK, the target is the same, see if this */ 659 /* one has valid initialization. */ 660 661 initp = addrel (dhp, type_pr.trap_relp); 662 663 if init.type ^= INIT_NO_INIT 664 then return (true); 665 666 end; 667 end; 668 end; 669 670 return (false); 671 672 end has_init; 673 674 675 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 676 677 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 678 679 1 1 /**** START OF: le_data.incl.pl1 * * * * * */ 1 2 1 3 /****^ HISTORY COMMENTS: 1 4* 1) change(86-08-12,Elhard), approve(86-08-12,MCR7505), 1 5* audit(86-12-10,DGHowe), install(86-12-10,MR12.0-1241): 1 6* Originally written to define the structures used internally by le_. 1 7* END HISTORY COMMENTS */ 1 8 1 9 /*** ****************************************************************/ 1 10 /*** */ 1 11 /*** Name: le_data */ 1 12 /*** Function: This include file defines the data structures */ 1 13 /*** used internally by the linkage_editor subroutine. */ 1 14 /*** */ 1 15 /*** ****************************************************************/ 1 16 1 17 /* error severity constants */ 1 18 1 19 dcl LE_WARNING fixed bin static options (constant) init (1); 1 20 dcl LE_ERROR fixed bin static options (constant) init (2); 1 21 dcl LE_FATAL_ERROR fixed bin static options (constant) init (3); 1 22 dcl LE_ABORT_ERROR fixed bin static options (constant) init (4); 1 23 1 24 /* section identifier constants */ 1 25 1 26 dcl Text fixed bin (3) static options (constant) 1 27 init (0); 1 28 dcl Linkage fixed bin (3) static options (constant) 1 29 init (1); 1 30 dcl Symbol fixed bin (3) static options (constant) 1 31 init (2); 1 32 dcl Definition fixed bin (3) static options (constant) 1 33 init (3); 1 34 dcl Static fixed bin (3) static options (constant) 1 35 init (4); 1 36 dcl System fixed bin (3) static options (constant) 1 37 init (5); 1 38 dcl Heap fixed bin (3) static options (constant) 1 39 init (6); 1 40 1 41 dcl section_nm (0:6) char (16) static options (constant) 1 42 init ("text", "linkage", "symbol", "definition", 1 43 "static", "system", "heap"); 1 44 1 45 /* link type constants */ 1 46 1 47 dcl Self_Base fixed bin (3) static options (constant) 1 48 init (1); 1 49 dcl Refname_Base fixed bin (3) static options (constant) 1 50 init (3); 1 51 dcl Refname_Offsetname fixed bin (3) static options (constant) 1 52 init (4); 1 53 dcl Self_Offsetname fixed bin (3) static options (constant) 1 54 init (5); 1 55 1 56 /* backpatch type constants */ 1 57 1 58 dcl Patch_Link fixed bin static options (constant) init (1); 1 59 dcl Patch_Init fixed bin static options (constant) init (2); 1 60 dcl Patch_Symbol_Ref fixed bin static options (constant) init (3); 1 61 dcl Patch_Self_Init fixed bin static options (constant) init (4); 1 62 1 63 /*** ****************************************************************/ 1 64 /*** */ 1 65 /*** Name: le_components */ 1 66 /*** Function: the component table is used to keep information */ 1 67 /*** about the input components being used and their */ 1 68 /*** disposition in output components. */ 1 69 /*** */ 1 70 /*** ****************************************************************/ 1 71 1 72 dcl 01 le_components aligned based, 1 73 02 header aligned, 1 74 03 flags aligned, 1 75 04 separate_static bit (1) unaligned, 1 76 04 perprocess_static bit (1) unaligned, 1 77 04 mbz bit (34) unaligned, 1 78 03 n_components fixed bin, 1 79 02 comp (0 refer (le_components.n_components)) 1 80 like le_comp; 1 81 1 82 /*** ****************************************************************/ 1 83 /*** */ 1 84 /*** Name: le_comp */ 1 85 /*** Function: this is a single component table entry. */ 1 86 /*** */ 1 87 /*** ****************************************************************/ 1 88 1 89 dcl 01 le_comp aligned based, 1 90 02 segp ptr, 1 91 02 bc fixed bin (24), 1 92 02 uid bit (36) aligned, 1 93 02 dtcm fixed bin (71), 1 94 02 name char (32) varying, 1 95 02 path char (194) varying, 1 96 02 compiler char (8), 1 97 02 target fixed bin, 1 98 02 flags aligned, 1 99 03 library bit (1) unaligned, 1 100 03 include bit (1) unaligned, 1 101 03 delete_table bit (1) unaligned, 1 102 03 separate_static bit (1) unaligned, 1 103 03 io_table bit (1) unaligned, 1 104 03 unique_path bit (1) unaligned, 1 105 03 mbz bit (30) unaligned, 1 106 02 tables aligned, 1 107 03 lesp ptr, 1 108 03 ledp ptr, 1 109 03 lelp ptr, 1 110 02 orig aligned, 1 111 03 textp ptr, 1 112 03 defnp ptr, 1 113 03 linkp ptr, 1 114 03 statp ptr, 1 115 03 symbp ptr, 1 116 03 rel_textp ptr, 1 117 03 rel_symbp ptr, 1 118 03 rel_linkp ptr, 1 119 03 textl fixed bin (18) unsigned unaligned, 1 120 03 defnl fixed bin (18) unsigned unaligned, 1 121 03 linkl fixed bin (18) unsigned unaligned, 1 122 03 statl fixed bin (18) unsigned unaligned, 1 123 03 symbl fixed bin (18) unsigned unaligned, 1 124 03 symbl_no_rel fixed bin (18) unsigned unaligned, 1 125 03 symbl_no_table fixed bin (18) unsigned unaligned, 1 126 03 n_symb_blocks fixed bin (18) unsigned unaligned, 1 127 03 text_boundary fixed bin (9) unsigned unaligned, 1 128 03 static_boundary fixed bin (9) unsigned unaligned, 1 129 03 next_comp fixed bin (18) unsigned unaligned, 1 130 02 new aligned, 1 131 03 rel_text fixed bin (18) unsigned unaligned, 1 132 03 rel_symb fixed bin (18) unsigned unaligned, 1 133 03 rel_stat fixed bin (18) unsigned unaligned, 1 134 03 text_pad fixed bin (18) unsigned unaligned, 1 135 03 static_pad fixed bin (18) unsigned unaligned, 1 136 03 symbol_pad fixed bin (18) unsigned unaligned; 1 137 1 138 /*** ****************************************************************/ 1 139 /*** */ 1 140 /*** Name: le_segnames */ 1 141 /*** Function: the segname table is used for two purposes: */ 1 142 /*** - to determine the target components of links */ 1 143 /*** being resolved internally. */ 1 144 /*** - to determine the segname definitions to be */ 1 145 /*** emited for definitions being retained. */ 1 146 /*** */ 1 147 /*** ****************************************************************/ 1 148 1 149 dcl 01 le_segnames aligned based, 1 150 02 header aligned, 1 151 03 n_segnames fixed bin, 1 152 02 segname (segname_count refer (le_segnames.n_segnames)), 1 153 03 str char (32) varying, 1 154 03 relp fixed bin (18) unsigned unaligned, 1 155 03 pad bit (18) unaligned; 1 156 dcl segname_count fixed bin automatic; 1 157 1 158 /*** ****************************************************************/ 1 159 /*** */ 1 160 /*** Name: le_definitions */ 1 161 /*** Function: the definition table contains the definitions */ 1 162 /*** from the input components and is used to resolve */ 1 163 /*** link targets, and regenerate definition entries */ 1 164 /*** */ 1 165 /*** ****************************************************************/ 1 166 1 167 dcl 01 le_definitions aligned based, 1 168 02 header aligned, 1 169 03 n_defs fixed bin, 1 170 03 pad bit (36), 1 171 02 def (def_count refer (le_definitions.n_defs)) 1 172 like le_definition; 1 173 dcl def_count fixed bin automatic; 1 174 1 175 dcl 01 le_definition aligned based, 1 176 02 str char (256) varying, 1 177 02 type fixed bin (18) unsigned unaligned, 1 178 02 relp fixed bin (18) unsigned unaligned, 1 179 02 offset fixed bin (18) unsigned unaligned, 1 180 02 new_offset fixed bin (18) unsigned unaligned, 1 181 02 flags aligned, 1 182 03 force_retain bit (1) unaligned, 1 183 03 entrypoint bit (1) unaligned, 1 184 03 ignore bit (1) unaligned, 1 185 03 referenced bit (1) unaligned, 1 186 03 no_link bit (1) unaligned, 1 187 03 retain bit (1) unaligned, 1 188 03 delete bit (1) unaligned, 1 189 03 mbz bit (29) unaligned; 1 190 1 191 /*** ****************************************************************/ 1 192 /*** */ 1 193 /*** Name: le_options */ 1 194 /*** Function: the option table contains definition retention */ 1 195 /*** information. The input retentions options are */ 1 196 /*** ordered such that a linear search of the option */ 1 197 /*** table for the first matching starname will give */ 1 198 /*** the correct retention state. */ 1 199 /*** */ 1 200 /*** ****************************************************************/ 1 201 1 202 dcl 01 le_options aligned based, 1 203 02 header aligned, 1 204 03 n_opts fixed bin, 1 205 02 opt (0 refer (le_options.n_opts)), 1 206 03 type fixed bin (8) unaligned, 1 207 03 used bit (1) unaligned, 1 208 03 inhibit_error bit (1) unaligned, 1 209 03 class fixed bin (6) unaligned, 1 210 03 order fixed bin (17) unaligned, 1 211 03 segname char (32) unaligned, 1 212 03 ep_name char (256) unaligned; 1 213 1 214 /*** ****************************************************************/ 1 215 /*** */ 1 216 /*** Name: le_links */ 1 217 /*** Function: the link table contains information on all of the */ 1 218 /*** links in the input components. It is used to */ 1 219 /*** determine link targets, which library components */ 1 220 /*** will be included, and what init_info will be */ 1 221 /*** used, and where it will be placed. */ 1 222 /*** */ 1 223 /*** ****************************************************************/ 1 224 1 225 dcl 01 le_links aligned based, 1 226 02 header aligned, 1 227 03 offset_adjustment fixed bin (18), 1 228 03 n_links fixed bin, 1 229 02 link (link_count refer (le_links.n_links)) 1 230 like le_link; 1 231 dcl link_count fixed bin automatic; 1 232 1 233 dcl 01 le_link aligned based, 1 234 02 flags unaligned, 1 235 03 used bit (1), 1 236 03 mbx bit (35), 1 237 02 type fixed bin (6) unsigned unaligned, 1 238 02 class fixed bin (6) unsigned unaligned, 1 239 02 mod bit (6) unaligned, 1 240 02 exp fixed bin (17) unaligned, 1 241 02 target fixed bin (18) unsigned unaligned, 1 242 02 defx fixed bin (18) unsigned unaligned, 1 243 02 relp fixed bin (18) unsigned unaligned, 1 244 02 target_comp fixed bin (18) unsigned unaligned, 1 245 02 target_link fixed bin (18) unsigned unaligned, 1 246 02 extension fixed bin (18) unsigned unaligned, 1 247 02 initp ptr unaligned, 1 248 02 segnamep ptr unaligned, 1 249 02 offsetp ptr unaligned; 1 250 1 251 /*** ****************************************************************/ 1 252 /*** */ 1 253 /*** Name: le_binaries */ 1 254 /*** Function: This table contains information about the output */ 1 255 /*** binaries. It is primarily used for creation and */ 1 256 /*** backpatching of MSF output. */ 1 257 /*** */ 1 258 /*** ****************************************************************/ 1 259 1 260 dcl 01 le_binaries aligned based, 1 261 02 header aligned, 1 262 03 n_binaries fixed bin, 1 263 03 pad bit (36), 1 264 02 binary (0:0 refer (le_binaries.n_binaries)), 1 265 03 segp ptr, 1 266 03 bc fixed bin (24), 1 267 03 uid bit (36), 1 268 03 aclc fixed bin, 1 269 03 aclp ptr, 1 270 03 textp ptr, 1 271 03 defnp ptr, 1 272 03 linkp ptr, 1 273 03 symbp ptr, 1 274 03 statp ptr, 1 275 03 textl fixed bin (18) unsigned unaligned, 1 276 03 defnl fixed bin (18) unsigned unaligned, 1 277 03 linkl fixed bin (18) unsigned unaligned, 1 278 03 symbl fixed bin (18) unsigned unaligned, 1 279 03 statl fixed bin (18) unsigned unaligned, 1 280 03 mbz2 bit (18) unaligned; 1 281 1 282 /*** ****************************************************************/ 1 283 /*** */ 1 284 /*** Name: le_patches */ 1 285 /*** Function: This table contains the list of backpatches to be */ 1 286 /*** performed when the rest of the object creation is */ 1 287 /*** complete. Since le_backpatch_ is the only routine */ 1 288 /*** concerned with this, it is maintained completely */ 1 289 /*** internal to le_backpatch_. */ 1 290 /*** */ 1 291 /*** ****************************************************************/ 1 292 1 293 dcl 01 le_patches aligned based, 1 294 02 header aligned, 1 295 03 n_patches fixed bin, 1 296 02 patch (0 refer (le_patches.n_patches)) like le_patch; 1 297 1 298 dcl 01 le_patch aligned based, 1 299 02 type fixed bin, 1 300 02 comp fixed bin, 1 301 02 relp fixed bin (18) unsigned, 1 302 02 target fixed bin, 1 303 02 index fixed bin; 1 304 1 305 /**** END OF: le_data.incl.pl1 * * * * * */ 680 2 1 /* BEGIN INCLUDE FILE object_link_dcls.incl.pl1 BIM 1981 from linkdcl */ 2 2 2 3 2 4 /****^ HISTORY COMMENTS: 2 5* 1) change(86-05-02,Elhard), approve(86-05-02,MCR7391), 2 6* audit(86-11-18,Schroth), install(86-11-20,MR12.0-1222): 2 7* Modified to add partial_link structure for an object MSF partially snapped 2 8* link. 2 9* 2) change(86-11-13,DGHowe), approve(86-11-13,MCR7391), audit(86-11-13,Zwick), 2 10* install(86-11-20,MR12.0-1222): 2 11* Added a declaration of FAULT_TAG_1, FAULT_TAG_2 and FAULT_TAG_3. 2 12* END HISTORY COMMENTS */ 2 13 2 14 2 15 /* format: style3 */ 2 16 /* everything you ever wanted in a linkage section */ 2 17 2 18 /* 2 19* Last Modified (Date and Reason): 2 20* 15 Nov 1971 by C Garman 2 21* 6/75 by M.Weaver to add virgin_linkage_header declaration 2 22* 6/75 by S.Webber to comment existing structures better 2 23* 9/77 by M. Weaver to add run_depth to link 2 24* 7/81 by B. Margulies for firstref structure, unsigned fixed bins. 2 25* 3/83 by M. Weaver to add flags overlaying def_ptr 2 26**/ 2 27 2 28 declare 1 object_link based aligned, /* link pair in linkage section */ 2 29 2 header_relp fixed bin (17) unal, /* rel pointer to beginning of linkage, always negative */ 2 30 2 ringno fixed bin (3) unsigned unal, /* MBZ */ 2 31 2 mbz bit (6) unal, 2 32 2 run_depth fixed bin (2) unal, /* run unit depth, filled when link is snapped */ 2 33 2 tag bit (6) unal, /* fault tag. 46(8) if not snapped, 43(8) if snapped */ 2 34 2 expression_relp fixed bin (18) unsigned unal, /* pointer (rel to defs) of expression word */ 2 35 2 mbz2 bit (12) unal, 2 36 2 modifier bit (6) unal; /* modifier to be left in snapped link */ 2 37 2 38 declare 1 partial_link based aligned, /* partially snapped link */ 2 39 2 type fixed bin (3) unsigned unal, /* target section of link */ 2 40 2 component fixed bin (15) unsigned unal, /* target component index */ 2 41 2 mbz1 bit (12) unal, 2 42 2 tag bit (6) unal, /* fault tag 3 47(8), ITS 43(8) if snapped */ 2 43 2 44 2 offset fixed bin (18) unsigned unal, /* word offset of link */ 2 45 2 mbz2 bit (3) unal, 2 46 2 bit_offset fixed bin (6) unsigned unal, /* bit offset (in practice, always 0) */ 2 47 2 mbz3 bit (3) unal, 2 48 2 modifier bit (6) unal; /* modifier to be left in snapped link */ 2 49 2 50 declare 1 linkage_header based aligned, /* linkage block header */ 2 51 2 def_ptr ptr, /* pointer to definition section */ 2 52 2 symbol_ptr ptr unal, /* pointer to symbol section in object segment */ 2 53 2 original_linkage_ptr 2 54 ptr unal, /* pointer to linkage section in object segment */ 2 55 2 unused bit (72), 2 56 2 stats, 2 57 3 begin_links fixed bin (18) unsigned unal, /* offset (rel to this section) of first link */ 2 58 3 block_length fixed bin (18) unsigned unal, /* number of words in this linkage section */ 2 59 3 segment_number 2 60 fixed bin (18) unsigned unal, /* text segment number associated with this section */ 2 61 3 static_length fixed bin (18) unsigned unal; /* number of words of static for this segment */ 2 62 2 63 declare 1 linkage_header_flags 2 64 aligned based, /* overlay of def_ptr for flags */ 2 65 2 pad1 bit (28) unaligned, /* flags are in first word */ 2 66 2 static_vlas bit (1) unaligned, /* static section "owns" some LA/VLA segments */ 2 67 2 perprocess_static 2 68 bit (1) unaligned, /* 1 copy of static section is shared among all tasks/run units */ 2 69 2 pad2 bit (6) unaligned; 2 70 2 71 declare 1 virgin_linkage_header 2 72 aligned based, /* template for linkage header in object segment */ 2 73 2 pad bit (30) unaligned, /* is filled in by linker */ 2 74 2 defs_in_link bit (6) unaligned, /* =o20 if defs in linkage (nonstandard) */ 2 75 2 def_offset fixed bin (18) unsigned unaligned, 2 76 /* offset of definition section */ 2 77 2 first_ref_relp fixed bin (18) unsigned unaligned, 2 78 /* offset of trap-at-first-reference offset array */ 2 79 2 filled_in_later bit (144), 2 80 2 link_begin fixed bin (18) unsigned unaligned, 2 81 /* offset of first link */ 2 82 2 linkage_section_lng 2 83 fixed bin (18) unsigned unaligned, 2 84 /* length of linkage section */ 2 85 2 segno_pad fixed bin (18) unsigned unaligned, 2 86 /* will be segment number of copied linkage */ 2 87 2 static_length fixed bin (18) unsigned unaligned; 2 88 /* length of static section */ 2 89 2 90 declare 1 fr_traps based aligned, /* First Reference Trap Procedures */ 2 91 2 decl_vers fixed bin, /* version of this struc, value=1, ABS reloc */ 2 92 2 n_traps fixed bin, /* number of traps on this segment, ABS */ 2 93 2 trap_array (n_fr_traps refer (fr_traps.n_traps)) aligned, 2 94 3 call_relp fixed bin (18) unsigned unaligned, 2 95 /* LINK18, offset of link defining procedure to call */ 2 96 3 info_relp fixed bin (18) unsigned unaligned; 2 97 /* LINK18, offser of link defining argument list for trap proc */ 2 98 2 99 declare FR_TRAPS_VERSION_1 init (1) fixed bin internal static options (constant); 2 100 declare FAULT_TAG_1 bit(6) unaligned init ("40"b3) static options (constant); 2 101 declare FAULT_TAG_2 bit(6) unaligned init ("46"b3) static options (constant); 2 102 declare FAULT_TAG_3 bit(6) unaligned init ("47"b3) static options (constant); 2 103 2 104 /* END INCLUDE FILE object_link_dcls.incl.pl1 */ 681 3 1 /* Begin include file definition_dcls.incl.pl1 BIM 1981 */ 3 2 3 3 3 4 /****^ HISTORY COMMENTS: 3 5* 1) change(86-05-02,Elhard), approve(86-05-02,MCR7391), 3 6* audit(86-07-18,DGHowe), install(86-11-20,MR12.0-1222): 3 7* Modified to add indirect bit to definition flags, add msf_map_relp to the 3 8* definition header, declare the msf_map, and add structures and constants 3 9* for deferred initialization. 3 10* 2) change(86-06-24,DGHowe), approve(86-06-24,MCR7420), 3 11* audit(86-08-05,Schroth), install(86-11-20,MR12.0-1222): 3 12* added the structures for pointer initialization. pointer_init_template. 3 13* changed list_template_entry 3 14* END HISTORY COMMENTS */ 3 15 3 16 3 17 /* Modified: */ 3 18 /* 13 Dec 1982 by Lee A. Newcomb to put definition_header.hash_table_relp */ 3 19 /* after unused half-word instead of before it. */ 3 20 /* 1 March 1983 by M. Weaver to add list template init type */ 3 21 3 22 /* format: style3,idind25 */ 3 23 /* everything for the definition section */ 3 24 3 25 declare ( 3 26 CLASS_TEXT init (0), /* text section definition */ 3 27 CLASS_LINKAGE init (1), /* linkage section definition */ 3 28 CLASS_SYMBOL init (2), /* symbol section definition */ 3 29 CLASS_SEGNAME init (3), /* segment name definition */ 3 30 CLASS_STATIC init (4), /* static section definition */ 3 31 CLASS_SYSTEM init (5), /* valid only in self links, not def class */ 3 32 CLASS_HEAP init (6) /* valid only in self links, not def class */ 3 33 ) fixed bin (3) unsigned internal static options (constant); 3 34 3 35 declare CLASS_NAMES (0:6) character (12) internal static options (constant) 3 36 init ("text", "linkage", "symbol", "segname", "static", "system", "heap"); 3 37 3 38 declare SYMBOLIC_SECTION_NAMES (0:6) character (8) 3 39 init ("*text", "*link", "*symbol", *, "*static", "*system", "*heap") internal static 3 40 options (constant); 3 41 3 42 declare 1 definition_flags unaligned based, 3 43 2 new bit (1), /* should be "1"b */ 3 44 2 ignore bit (1), /* cannot snap link to this */ 3 45 2 entry bit (1), /* can tra here */ 3 46 2 retain bit (1), /* binder respects this */ 3 47 2 argcount bit (1), /* OBSOLETE */ 3 48 2 descriptors bit (1), /* OBSOLETE */ 3 49 2 indirect bit (1), /* target is a pointer to actual target */ 3 50 2 unused bit (8); /* Must be zero */ 3 51 3 52 3 53 3 54 3 55 /* Header of the definition section */ 3 56 3 57 declare def_header_ptr pointer; 3 58 declare 1 definition_header aligned based (def_header_ptr), 3 59 2 def_list_relp fixed bin (18) unsigned unaligned, 3 60 /* first definition, reloc def18 */ 3 61 2 msf_map_relp fixed bin (18) unsigned unaligned, 3 62 /* msf_map if any, or 0 if none. reloc def18 unless none */ 3 63 2 hash_table_relp fixed bin (18) unsigned unaligned, 3 64 /* def hash table, if any, or 0 if none. reloc def18 unless none */ 3 65 2 flags unaligned like definition_flags; 3 66 /* both new and ignore must be "1"b here */ 3 67 3 68 /* A non class=3 definition. See segname_definition below for class=3 */ 3 69 3 70 3 71 declare def_ptr pointer; 3 72 declare 1 definition aligned based (def_ptr), 3 73 2 forward_relp unal fixed bin (18) unsigned, 3 74 /* offset of next def */ 3 75 2 backward_relp unal fixed bin (18) unsigned, 3 76 /* offset of previous def */ 3 77 2 thing_relp unal fixed bin (18) unsigned, 3 78 /* offset in section specified by class of thing this defines */ 3 79 2 flags unaligned like definition_flags, 3 80 2 class unal fixed bin (3) unsigned, 3 81 /* Type of definition */ 3 82 2 name_relp unal fixed bin (18) unsigned, 3 83 /* offset of ACC for symbol */ 3 84 2 segname_relp unal fixed bin (18) unsigned; 3 85 /* offset of segname def to which this belongs */ 3 86 3 87 /* Class=3, segname definition */ 3 88 3 89 declare segname_ptr pointer; 3 90 declare 1 segname_definition aligned based (segname_ptr), 3 91 2 forward_relp unal fixed bin (18) unsigned, 3 92 /* offset of next def */ 3 93 2 backward_relp unal fixed bin (18) unsigned, 3 94 /* offset of previous def */ 3 95 2 next_segname_relp unal fixed bin (18) unsigned, 3 96 /* offset of next segname def */ 3 97 2 flags unaligned like definition_flags, 3 98 2 class unal fixed bin (3) unsigned, 3 99 /* 3 for segname */ 3 100 2 name_relp unal fixed bin (18) unsigned, 3 101 /* offset of ACC for symbol */ 3 102 2 first_relp unal fixed bin (18) unsigned; 3 103 /* see following : */ 3 104 3 105 /* Definition blocks are chained off of segname definitions. 3 106* segname_definition.first_relp is one of three things: 3 107* (1) the def section offset of thdcl 331 in procedure "process_link" set ref 362* 366 lelp 000122 automatic pointer dcl 182 in procedure "get_links" set ref 218* 219 221 226 lelp 114 based pointer array level 4 in structure "lec" dcl 63 in procedure "le_make_link_tbl_" set ref 208* 219* leshp parameter pointer dcl 164 in procedure "get_links" set ref 140 228* leshp parameter pointer dcl 45 in procedure "le_make_link_tbl_" set ref 17 122* leshp parameter pointer dcl 286 in procedure "process_link" set ref 260 500* library 106 based bit(1) array level 4 packed unaligned dcl 63 ref 105 link 2 based structure array level 2 in structure "tlel" dcl 318 in procedure "process_link" set ref 435 link based structure level 1 dcl 597 in procedure "has_init" ref 627 629 636 link 2 based structure array level 2 in structure "lel" dcl 304 in procedure "process_link" set ref 366 link based structure level 1 dcl 307 in procedure "process_link" link_begin 6 based fixed bin(18,0) level 2 in structure "vlh" packed unsigned unaligned dcl 605 in procedure "has_init" ref 632 link_begin 6 based fixed bin(18,0) level 2 in structure "vlh" packed unsigned unaligned dcl 174 in procedure "get_links" ref 201 link_count 000103 automatic fixed bin(17,0) dcl 1-231 set ref 207* 208 208 214* 218 218 225 link_init based structure level 1 dcl 3-205 linkage_section_lng 6(18) based fixed bin(18,0) level 2 in structure "vlh" packed unsigned unaligned dcl 174 in procedure "get_links" ref 196 linkage_section_lng 6(18) based fixed bin(18,0) level 2 in structure "vlh" packed unsigned unaligned dcl 605 in procedure "has_init" ref 627 linkp 122 based pointer array level 4 in structure "lec" dcl 63 in procedure "le_make_link_tbl_" ref 191 linkp 122 based pointer array level 4 in structure "lec" dcl 298 in procedure "process_link" ref 345 linkp 000124 automatic pointer dcl 183 in procedure "get_links" set ref 227* 228* linkp 122 based pointer array level 4 in structure "lec" dcl 594 in procedure "has_init" ref 622 linkp 000222 automatic pointer dcl 613 in procedure "has_init" set ref 627 629 636 640* 641 linkp parameter pointer dcl 287 in procedure "process_link" ref 260 345 350 352 359 384 lk based structure level 1 dcl 308 set ref 368* lkp 000156 automatic pointer dcl 332 set ref 366* 368 370 371 374 375 378 379 381 383 384 385 386 387 388 389 390 391 392 397 398 411 420 439 448 450 458 460 479 484 492 516 545 546 lx parameter fixed bin(17,0) dcl 290 ref 260 366 mod 1(12) based bit(6) level 2 packed unaligned dcl 308 set ref 384* modifier 1(30) based bit(6) level 2 packed unaligned dcl 307 ref 384 n_components 1 based fixed bin(17,0) level 3 in structure "lec" dcl 298 in procedure "process_link" ref 472 n_components 1 based fixed bin(17,0) level 3 in structure "lec" dcl 63 in procedure "le_make_link_tbl_" ref 97 105 n_defs based fixed bin(17,0) level 3 dcl 301 ref 526 n_links 1 based fixed bin(17,0) level 3 in structure "lel" dcl 170 in procedure "get_links" set ref 208* 218* n_links 1 based fixed bin(17,0) level 3 in structure "tlel" dcl 318 in procedure "process_link" ref 432 n_words 000010 internal static fixed bin(35,0) level 2 dcl 69 set ref 91* name 10 based varying char(32) array level 3 in structure "lec" dcl 63 in procedure "le_make_link_tbl_" set ref 242* name 10 based varying char(32) array level 3 in structure "lec" dcl 298 in procedure "process_link" set ref 511* 511* 532* 532* name based structure level 1 dcl 598 in procedure "has_init" namep parameter pointer dcl 588 ref 565 655 next_comp 142(18) based fixed bin(18,0) array level 4 in structure "lec" packed unsigned unaligned dcl 63 in procedure "le_make_link_tbl_" set ref 97* 106* 111* 127 245* 248* next_comp 142(18) based fixed bin(18,0) array level 4 in structure "lec" packed unsigned unaligned dcl 298 in procedure "process_link" ref 465 no_link 105(04) based bi structure "lec" dcl 63 in procedure "le_make_link_tbl_" tag 0(30) based bit(6) level 2 packed unaligned dcl 307 set ref 350 352* tail parameter fixed bin(17,0) dcl 166 in procedure "get_links" set ref 140 245 246* tail 000102 automatic fixed bin(17,0) dcl 76 in procedure "le_make_link_tbl_" set ref 102* 108* 111 122* target 2 based fixed bin(18,0) level 2 packed unsigned unaligned dcl 308 set ref 386* 516* 545* target_comp 3(18) based fixed bin(18,0) level 2 packed unsigned unaligned dcl 308 set ref 390* target_link 4 based fixed bin(18,0) level 2 packed unsigned unaligned dcl 308 set ref 389* tc 000167 automatic fixed bin(17,0) dcl 337 set ref 424* 424* 428 458* 465 472* 476 479* 482* tl 000170 automatic fixed bin(17,0) dcl 338 set ref 432* 435* tlel based structure level 1 dcl 318 tlelp 000172 automatic pointer dcl 339 set ref 428* 432 432 435 tlk based structure level 1 dcl 321 tlkp 000174 automatic pointer dcl 340 set ref 435* 439 439 442 447 trap_relp 0(18) based fixed bin(18,0) level 2 in structure "type_pr" packed unsigned unaligned dcl 604 in procedure "has_init" ref 646 661 trap_relp 0(18) based fixed bin(18,0) level 2 in structure "type_pr" packed unsigned unaligned dcl 322 in procedure "process_link" ref 392 397 true constant bit(1) initial unaligned dcl 38 ref 92 103 107 247 420 450 460 483 484 492 517 537 547 663 type 1 based fixed bin(6,0) level 2 in structure "tlk" packed unsigned unaligned dcl 321 in procedure "process_link" ref 439 type 1 based fixed bin(6,0) level 2 in structure "lk" packed unsigned unaligned dcl 308 in procedure "process_link" set ref 371* type 1 based fixed bin(17,0) level 2 in structure "init" dcl 297 in procedure "process_link" ref 415 448 type 1 000010 internal static fixed bin(17,0) level 2 in structure "default_init" dcl 69 in procedure "le_make_link_tbl_" set ref 90* type start_offset has_init 000232 type_prp has_init 000234 vlhp has_init THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as call_ext_out_desc return_mac ext_entry trunc_fx2 divide_fx1 op_alloc_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. hash_$search le_debug_ le_error_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$no_ext_sym le_et_$not_linkfault LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 17 000137 88 000150 90 000152 91 000154 92 000155 95 000157 97 000172 101 000213 102 000215 103 000216 105 000220 106 000236 107 000246 108 000250 109 000251 111 000253 117 000263 122 000266 127 000303 129 000313 131 000314 133 000330 140 000331 191 000333 192 000342 196 000344 198 000352 201 000360 205 000363 207 000365 208 000366 209 000405 214 000406 218 000422 219 000435 221 000444 225 000447 226 000457 227 000462 228 000465 233 000512 239 000515 242 000526 245 000551 246 000563 247 000564 248 000567 251 000572 253 000574 260 000575 343 000577 344 000603 345 000605 350 000623 352 000627 354 000670 359 000671 360 000677 362 000705 366 000710 368 000715 370 000720 371 000722 372 000727 374 000741 375 000744 376 000746 378 000747 379 000751 381 000761 383 000772 384 001003 385 001006 386 001010 387 001012 388 001014 389 001016 390 001017 391 001021 392 001022 397 001052 398 001057 400 001061 403 001066 408 001072 411 001076 415 001100 420 001102 421 001104 424 001105 428 001112 432 001120 435 001133 439 001137 442 001160 447 001173 448 001175 450 001202 451 001204 455 001205 458 001210 460 001234 461 001236 465 001237 472 001250 476 001263 479 001272 482 001316 483 001321 484 001325 485 001327 488 001330 492 001332 493 001334 500 001335 501 001371 506 001374 511 001403 516 001456 517 001465 518 001471 523 001472 524 001502 526 001511 527 001527 532 001544 537 001627 542 001633 545 001637 546 001646 547 001650 549 001654 551 001656 556 001735 565 001736 622 001740 623 001746 627 001750 629 001754 632 001762 636 001765 640 002006 641 002012 642 002017 646 002024 653 002054 655 002061 661 002074 663 002100 668 002107 670 002112 ----------------------------------------------------------- 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