COMPILATION LISTING OF SEGMENT le_create_list_ Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Multics Op. - System M Compiled on: 12/10/86 1253.5 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 generate a listing segment. 11* END HISTORY COMMENTS */ 12 13 /* format: style1,insnl,ifthendo,indthenelse,^indnoniterdo,^inditerdo,indcom,^indthenbegin,^indprocbody,ind2,ll78,initcol0,dclind4,idind24,struclvlind1,comcol41 */ 14 15 le_create_list_: 16 proc (lecp, /** components pointer (in ) */ 17 lebp, /** binaries pointer (in ) */ 18 dname, /** directory name (in ) */ 19 ename, /** entry name (in ) */ 20 list); /** map/list switch (in ) */ 21 22 /*** ****************************************************************/ 23 /*** */ 24 /*** Name: le_create_list_ */ 25 /*** Input: lecp, lebp, dname, ename, list */ 26 /*** Function: creates a listing segment detailing the inclusion */ 27 /*** and disposition of: input components, links, and */ 28 /*** definitions. Degree of detail is determined by */ 29 /*** the list switch. */ 30 /*** Output: none */ 31 /*** */ 32 /*** ****************************************************************/ 33 34 /* constants */ 35 36 dcl true bit (1) static options (constant) init ("1"b); 37 dcl false bit (1) static options (constant) init ("0"b); 38 39 dcl NL char (1) static options (constant) init (" 40 "); 41 dcl section_name (0:4) char (4) static options (constant) 42 init ("text", "link", "symb", "****", "stat"); 43 44 /* parameters */ 45 46 dcl lecp ptr parameter; 47 dcl lebp ptr parameter; 48 dcl dname char (*) parameter; 49 dcl ename char (*) parameter; 50 dcl list bit (1) parameter; 51 52 /* procedures */ 53 54 dcl date_time_$format entry (char (*), fixed bin (71), char (*), 55 char (*)) returns (char (250) var); 56 dcl get_shortest_path_ entry (char (*)) returns (char (168)); 57 dcl get_temp_segment_ entry (char (*), ptr, fixed bin (35)); 58 dcl hcs_$get_uid_seg entry (ptr, bit (36) aligned, fixed bin (35)); 59 dcl initiate_file_$create entry (char (*), char (*), bit (*), ptr, 60 bit (1) aligned, fixed bin (24), 61 fixed bin (35)); 62 dcl le_error_ entry options (variable); 63 dcl le_util_$check_uid entry (ptr, ptr, bit (36) aligned) 64 returns (bit (1)); 65 dcl le_util_$get_user_and_version 66 entry (char (*), char (*)); 67 dcl release_temp_segment_ entry (char (*), ptr, fixed bin (35)); 68 dcl terminate_file_ entry (ptr, fixed bin (24), bit (*), 69 fixed bin (35)); 70 dcl hcs_$fs_get_path_name entry (ptr, char (*), fixed bin, char (*), 71 fixed bin (35)); 72 dcl pathname_ entry (char (*), char (*)) returns (char (168)); 73 dcl expand_pathname_$add_suffix 74 entry (char (*), char (*), char (*), char (*), 75 fixed bin (35)); 76 77 /* external */ 78 79 dcl le_data_$caller external char (32) varying; 80 dcl le_et_$implementation_error 81 external fixed bin (35); 82 dcl le_et_$input_output_overlap 83 external fixed bin (35); 84 85 /* based */ 86 87 dcl 01 def_list based, 88 02 count fixed bin, 89 02 def (0 refer (def_list.count)) like dl_entry; 90 91 dcl 01 dl_entry aligned based, 92 02 name char (32), 93 02 offset fixed bin (18) unsigned unaligned, 94 02 comp fixed bin (9) unsigned unaligned, 95 02 section fixed bin (3) unsigned unaligned, 96 02 flags unaligned, 97 03 entrypoint bit (1), 98 03 indirect bit (1), 99 03 mbz bit (4); 100 101 dcl 01 link_list aligned based, 102 02 count fixed bin, 103 02 lk (0 refer (link_list.count)) like ll_entry; 104 105 dcl 01 ll_entry aligned based, 106 02 name char (64), 107 02 comp fixed bin (18) unsigned unaligned, 108 02 offset fixed bin (18) unsigned unaligned, 109 02 init_offset fixed bin (18) unsigned unaligned, 110 02 init_length fixed bin (18) unsigned unaligned; 111 112 /* automatic */ 113 114 dcl bc fixed bin (24) automatic; 115 dcl created bit (1) aligned automatic; 116 dcl ec fixed bin (35) automatic; 117 dcl listp ptr automatic; 118 dcl new_dname char (168) automatic; 119 dcl new_ename char (168) automatic; 120 dcl uid bit (36) aligned automatic; 121 122 /* conditions */ 123 124 dcl cleanup condition; 125 126 /* builtin */ 127 128 dcl addcharno builtin; 129 dcl addr builtin; 130 dcl addrel builtin; 131 dcl char builtin; 132 dcl clock builtin; 133 dcl copy builtin; 134 dcl divide builtin; 135 dcl fixed builtin; 136 dcl index builtin; 137 dcl length builtin; 138 dcl ltrim builtin; 139 dcl null builtin; 140 dcl rel builtin; 141 dcl reverse builtin; 142 dcl rtrim builtin; 143 dcl size builtin; 144 dcl string builtin; 145 dcl substr builtin; 146 dcl unspec builtin; 147 dcl verify builtin; 148 149 call expand_pathname_$add_suffix (ename, "list", new_dname, new_ename, ec); 150 call initiate_file_$create (new_dname, new_ename, RW_ACCESS, listp, 151 created, bc, ec); 152 if ec ^= 0 153 then do; 154 call le_error_ (LE_ERROR, ec, "^/While creating listing file ^a.", 155 new_ename); 156 return; 157 end; 158 159 call hcs_$get_uid_seg (listp, uid, ec); 160 if le_util_$check_uid (lecp, lebp, uid) 161 then call le_error_ (LE_ABORT_ERROR, le_et_$input_output_overlap, 162 "^/Listing file is the same as one of the input files," || 163 "^/or the executable output."); 164 165 bc = 0; 166 167 call generate_map (listp, bc, lecp, lebp); 168 if list 169 then call generate_list (listp, bc, lecp, lebp); 170 171 call terminate_file_ (listp, bc, TERM_FILE_TRUNC_BC_TERM, ec); 172 173 return; 174 175 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 176 177 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 178 179 180 generate_map: 181 proc (listp, /** listing segment ptr (i/o) */ 182 bc, /** segment bit count (i/o) */ 183 lecp, /** components pointer (in ) */ 184 lebp); /** binaries pointer (in ) */ 185 186 /*** ****************************************************************/ 187 /*** */ 188 /*** Name: generate_map */ 189 /*** Input: listp, bc, lecp, lebp */ 190 /*** Function: generates the map portion of the le_ listing from */ 191 /*** information contained in the component table and */ 192 /*** binaries table. */ 193 /*** Output: listp, bc */ 194 /*** */ 195 /*** ****************************************************************/ 196 197 /* parameters */ 198 199 dcl listp ptr parameter; 200 dcl bc fixed bin (24) parameter; 201 dcl lecp ptr parameter; 202 dcl lebp ptr parameter; 203 204 /* based */ 205 206 dcl 01 lec aligned based (lecp), 207 02 header aligned like le_components.header, 208 02 comp dim (0 refer (lec.n_components)) like le_comp; 209 dcl 01 leb aligned based (lebp), 210 02 header aligned like le_binaries.header, 211 02 binary dim (0:0 refer (leb.n_binaries)) 212 like le_binaries.binary; 213 dcl 01 comp aligned like le_comp based (compp); 214 215 /* automatic */ 216 217 dcl compp ptr automatic; 218 dcl pn char (168) automatic; 219 dcl strp ptr automatic; 220 dcl dn char (168) automatic; 221 dcl dnl fixed bin automatic; 222 dcl en char (32) automatic; 223 dcl ec fixed bin (35) automatic; 224 dcl user char (32) automatic; 225 dcl version char (128) automatic; 226 dcl value fixed bin (35) automatic; 227 dcl comp_pic pic "zz9" automatic; 228 dcl b fixed bin automatic; 229 dcl 01 comp_info aligned automatic, 230 02 name char (32) unaligned, 231 02 pad1 char (1) unaligned, 232 02 compiler char (8) unaligned, 233 02 pad2 char (2) unaligned, 234 02 target char (3) unaligned, 235 02 start char (7) unaligned, 236 02 text_start char (7) unaligned, 237 02 stat_start char (7) unaligned, 238 02 symb_start char (7) unaligned, 239 02 nl_1 char (1) unaligned, 240 02 pad3 char (10) unaligned, 241 02 dtcm char (36) unaligned, 242 02 length char (7) unaligned, 243 02 text_length char (7) unaligned, 244 02 stat_length char (7) unaligned, 245 02 symb_length char (7) unaligned, 246 02 nl_2 char (1) unaligned; 247 dcl c fixed bin automatic; 248 dcl col fixed bin automatic; 249 dcl symbolp ptr automatic; 250 dcl dtcm fixed bin (71) automatic; 251 252 strp = addcharno (listp, divide (bc, 9, 21, 0)); 253 col = 1; 254 255 /* generate the listing header */ 256 257 call append (strp, bc, col, "Listing for "); 258 259 call hcs_$fs_get_path_name (leb.binary (1).segp, dn, dnl, en, ec); 260 if leb.n_binaries = 1 261 then pn = pathname_ (substr (dn, 1, dnl), en); 262 else pn = substr (dn, 1, dnl); 263 264 call append (strp, bc, col, rtrim (pn) || NL); 265 call append (strp, bc, col, "Created on "); 266 call append (strp, bc, col, date_time_$format ("date_time", clock (), 267 "", "")); 268 call le_util_$get_user_and_version (user, version); 269 call append (strp, bc, col, ", by " || rtrim (user) || NL); 270 call append (strp, bc, col, "Using " || rtrim (version) || NL || NL); 271 272 /* create the source_map listing */ 273 274 do c = 1 to lec.n_components; 275 compp = addr (lec.comp (c)); 276 if comp.flags.include & comp.flags.unique_path 277 then call append (strp, bc, col, 278 rtrim (get_shortest_path_ ((comp.path))) || NL); 279 end; 280 281 /* create the length listings */ 282 283 if leb.n_binaries > 1 284 then call append (strp, bc, col, NL || "Comp "); 285 else call append (strp, bc, col, (NL)); 286 287 call append (strp, bc, col, 288 " Object Text Defs Link Symb Static" || NL); 289 290 do b = 1 to leb.n_binaries; 291 if leb.n_binaries > 1 292 then do; 293 comp_pic = b; 294 call append (strp, bc, col, char (comp_pic) || " "); 295 end; 296 call append (strp, bc, col, "Start 0 "); 297 value = fixed (rel (leb.binary (b).textp), 18); 298 call append (strp, bc, col, oct (value, 6, " ") || " "); 299 value = fixed (rel (leb.binary (b).defnp), 18); 300 call append (strp, bc, col, oct (value, 6, " ") || " "); 301 value = fixed (rel (leb.binary (b).linkp), 18); 302 call append (strp, bc, col, oct (value, 6, " ") || " "); 303 value = fixed (rel (leb.binary (b).symbp), 18); 304 call append (strp, bc, col, oct (value, 6, " ") || " "); 305 value = fixed (rel (leb.binary (b).statp), 18); 306 call append (strp, bc, col, oct (value, 6, " ") || NL); 307 308 if leb.n_binaries > 1 309 then call append (strp, bc, col, " Length "); 310 else call append (strp, bc, col, "Length "); 311 312 call append (strp, bc, col, 313 oct (divide (leb.binary (b).bc, 36, 18, 0), 6, " ") || " "); 314 call append (strp, bc, col, oct ((leb.binary (b).textl), 6, " ") || " "); 315 call append (strp, bc, col, oct ((leb.binary (b).defnl), 6, " ") || " "); 316 call append (strp, bc, col, oct ((leb.binary (b).linkl), 6, " ") || " "); 317 call append (strp, bc, col, oct ((leb.binary (b).symbl), 6, " ") || " "); 318 call append (strp, bc, col, oct ((leb.binary (b).statl), 6, " ") || NL); 319 end; 320 321 /* emit the per_component information */ 322 323 call append (strp, bc, col, 324 NL || "Name Language "); 325 if leb.n_binaries > 1 326 then call append (strp, bc, col, "Comp "); 327 else call append (strp, bc, col, " "); 328 call append (strp, bc, col, 329 " Text Static Symbol" || NL); 330 call append (strp, bc, col, 331 " Date Compiled" || NL); 332 333 string (comp_info) = ""; 334 comp_info.start = " start"; 335 comp_info.length = " length"; 336 comp_info.nl_1 = NL; 337 comp_info.nl_2 = NL; 338 339 do c = 1 to lec.n_components; 340 compp = addr (lec.comp (c)); 341 342 if comp.flags.include 343 then do; 344 345 comp_info.name = comp.name; 346 comp_info.compiler = comp.compiler; 347 348 /* insert the component number only if there was more than 1 */ 349 /* component */ 350 351 if leb.n_binaries > 1 352 then do; 353 comp_pic = comp.target; 354 comp_info.target = comp_pic; 355 end; 356 else comp_info.target = ""; 357 symbolp = addrel (leb.binary (comp.target).symbp, comp.new.rel_symb); 358 dtcm = symbolp -> std_symbol_header.object_created; 359 comp_info.dtcm = date_time_$format ("date_time", dtcm, "", ""); 360 comp_info.text_start = oct ((comp.new.rel_text), 7, " "); 361 comp_info.stat_start = oct ((comp.new.rel_stat), 7, " "); 362 comp_info.symb_start = oct ((comp.new.rel_symb), 7, " "); 363 comp_info.text_length = oct ((comp.orig.textl), 7, " "); 364 comp_info.stat_length = oct ((comp.orig.statl), 7, " "); 365 comp_info.symb_length = oct ((comp.orig.symbl), 7, " "); 366 call append (strp, bc, col, string (comp_info)); 367 end; 368 end; 369 370 end generate_map; 371 372 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 373 374 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 375 376 377 generate_list: 378 proc (listp, /** list segment ptr (i/o) */ 379 bc, /** segment bit count (i/o) */ 380 lecp, /** components pointer (in ) */ 381 lebp); /** binaries pointer (in ) */ 382 383 /*** ****************************************************************/ 384 /*** */ 385 /*** Name: generate_list */ 386 /*** Input: listp, bc, lecp, lebp */ 387 /*** Function: generates the extended listing. (after the basic */ 388 /*** map listing.) This includes the link resolution */ 389 /*** information and definition information. */ 390 /*** Output: listp, bc */ 391 /*** */ 392 /*** ****************************************************************/ 393 394 /* parameters */ 395 396 dcl listp ptr parameter; 397 dcl bc fixed bin (24) parameter; 398 dcl lecp ptr parameter; 399 dcl lebp ptr parameter; 400 401 /* based */ 402 403 dcl 01 acc aligned based (accp), 404 02 count fixed bin (9) unsigned unaligned, 405 02 string char (0 refer (acc.count)) unaligned; 406 dcl 01 dl aligned based (scratchp), 407 02 count fixed bin, 408 02 def dim (0 refer (dl.count)) like def_list.def; 409 dcl 01 def aligned like definition based (defp); 410 dcl 01 leb aligned based (lebp), 411 02 header aligned like le_binaries.header, 412 02 binary dim (0:0 refer (leb.n_binaries)) 413 like le_binaries.binary; 414 dcl 01 lk aligned like object_link based (lkp); 415 dcl 01 ll aligned based (scratchp), 416 02 count fixed bin, 417 02 lk dim (0 refer (ll.count)) like link_list.lk; 418 dcl 01 sn aligned like segname_definition based (defp); 419 dcl 01 vlh aligned like virgin_linkage_header based (vlhp); 420 dcl 01 plk aligned like partial_link based (plkp); 421 dcl word fixed bin (35) based; 422 423 /* automatic */ 424 425 dcl accp ptr automatic; 426 dcl col fixed bin automatic; 427 dcl defnp ptr automatic; 428 dcl linkp ptr automatic; 429 dcl defp ptr automatic; 430 dcl plkp ptr automatic; 431 dcl scratchp ptr automatic; 432 dcl strp ptr automatic; 433 dcl msf_sw bit (1) automatic; 434 dcl d fixed bin automatic; 435 dcl b fixed bin automatic; 436 dcl l fixed bin automatic; 437 dcl vlhp ptr automatic; 438 dcl dhp ptr automatic; 439 dcl lk_start fixed bin (18) unsigned automatic; 440 dcl lk_end fixed bin (18) unsigned automatic; 441 dcl offset fixed bin (18) unsigned automatic; 442 dcl lkp ptr automatic; 443 dcl count fixed bin automatic; 444 445 scratchp = null; 446 447 on cleanup 448 begin; 449 if scratchp ^= null 450 then call release_temp_segment_ ((le_data_$caller), scratchp, 0); 451 end; 452 453 call get_temp_segment_ ((le_data_$caller), scratchp, ec); 454 455 strp = addcharno (listp, divide (bc, 9, 21, 0)); 456 col = 1; 457 458 if leb.n_binaries > 1 459 then msf_sw = true; 460 else msf_sw = false; 461 462 /* emit the definition list */ 463 464 if msf_sw 465 then do; 466 defnp = leb.binary (0).defnp; 467 linkp = leb.binary (0).linkp; 468 end; 469 else defnp = leb.binary (1).defnp; 470 471 /* count the number of visible definitions */ 472 473 count = 0; 474 475 do defp = addrel (defnp, defnp -> definition_header.def_list_relp) 476 repeat addrel (defnp, def.forward_relp) 477 while (defp -> word ^= 0); 478 if ^def.flags.ignore 479 then count = count + 1; 480 end; 481 482 call append (strp, bc, col, NL || NL || ltrim (rtrim (char (count)))); 483 call append (strp, bc, col, " Definitions:" || NL); 484 485 dl.count = -1; 486 487 do defp = addrel (defnp, defnp -> definition_header.def_list_relp) 488 repeat addrel (defnp, def.forward_relp) 489 while (defp -> word ^= 0); 490 if def.class = 3 & ^def.flags.ignore 491 then do; 492 493 /* we have found a segname, so sort any pending definitions */ 494 /* and print them out, zero the count, and print the segname */ 495 496 if dl.count ^= 0 497 then do; 498 if dl.count > 0 499 then call print_defs (scratchp, msf_sw, strp, bc, col); 500 else dl.count = 0; 501 502 accp = addrel (defnp, def.name_relp); 503 504 if sn.first_relp ^= sn.forward_relp 505 then call append (strp, bc, col, NL || NL || "segnames: "); 506 else call append (strp, bc, col, NL || NL || "segname: "); 507 call append (strp, bc, col, acc.string || NL); 508 509 end; 510 else do; 511 512 /* another segname on a block, just indent and display */ 513 514 accp = addrel (defnp, def.name_relp); 515 call append (strp, bc, col, " " || acc.string || NL); 516 end; 517 end; 518 else if ^def.flags.ignore 519 then do; 520 521 /* a non-segname definition, so we add it to the table to be */ 522 /* sorted and printed. */ 523 524 d, dl.count = dl.count + 1; 525 accp = addrel (defnp, def.name_relp); 526 dl.def (d).name = acc.string; 527 528 if def.flags.indirect 529 then do; 530 531 /* for indirect definitions, we get the target info from */ 532 /* the partial link to the actual target in another */ 533 /* component */ 534 535 dl.def (d).flags.indirect = true; 536 plkp = addrel (linkp, def.thing_relp); 537 dl.def (d).comp = plk.component; 538 dl.def (d).offset = plk.offset; 539 dl.def (d).section = plk.type; 540 end; 541 else do; 542 543 /* for non-indirect definitions we get the info from the */ 544 /* definition itself. */ 545 546 dl.def (d).comp = 0; 547 dl.def (d).flags.indirect = false; 548 dl.def (d).offset = def.thing_relp; 549 dl.def (d).section = def.class; 550 end; 551 dl.def (d).flags.entrypoint = def.flags.entry; 552 end; 553 end; 554 555 /* now sort and print the definitions for the last block */ 556 557 if dl.count > 0 558 then call print_defs (scratchp, msf_sw, strp, bc, col); 559 560 ll.count = 0; 561 562 do b = 1 to leb.n_binaries; 563 vlhp = leb.binary (b).linkp; 564 dhp = leb.binary (b).defnp; 565 lk_start = vlh.link_begin; 566 if vlh.first_ref_relp ^= 0 567 then lk_end = vlh.first_ref_relp; 568 else lk_end = vlh.linkage_section_lng; 569 570 do offset = lk_start to lk_end; 571 lkp = addrel (vlhp, offset); 572 if lk.tag = FAULT_TAG_2 573 then do; 574 l, ll.count = ll.count + 1; 575 ll.lk (l).comp = b; 576 ll.lk (l).offset = offset; 577 call get_link_info (lkp, dhp, addr (ll.lk (l))); 578 end; 579 end; 580 581 end; 582 583 call print_links (scratchp, msf_sw, strp, bc, col); 584 585 call release_temp_segment_ ((le_data_$caller), scratchp, ec); 586 587 end generate_list; 588 589 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 590 591 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 592 593 594 print_defs: 595 proc (dlp, /** def list pointer (in ) */ 596 msf_sw, /** MSF swtich (in ) */ 597 strp, /** list file pointer (i/o) */ 598 bc, /** list file bit count (i/o) */ 599 col); /** display column (i/o) */ 600 601 /*** ****************************************************************/ 602 /*** */ 603 /*** Name: print_defs */ 604 /*** Input: dlp, msf_sw, strp, bc, col */ 605 /*** Function: sorts and prints out the definition list. */ 606 /*** Output: strp, bc */ 607 /*** */ 608 /*** ****************************************************************/ 609 610 /* parameters */ 611 612 dcl dlp ptr parameter; 613 dcl msf_sw bit (1) parameter; 614 dcl strp ptr parameter; 615 dcl bc fixed bin (24) parameter; 616 dcl col fixed bin parameter; 617 618 /* based */ 619 620 dcl 01 dl aligned based (dlp), 621 02 count fixed bin, 622 02 def dim (0 refer (dl.count)) like def_list.def; 623 624 /* automatic */ 625 626 dcl i fixed bin automatic; 627 dcl addr char (20) varying automatic; 628 dcl fixed_addr char (20) automatic; 629 dcl temp (1:size (dl_entry)) fixed bin (35) automatic; 630 631 /* perform a heapsort on the definition list before printing it */ 632 633 do i = divide (dl.count, 2, 17, 0) by -1 to 1; 634 call adjust_heap (dlp, i, dl.count, size (dl_entry)); 635 end; 636 637 do i = dl.count to 2 by -1; 638 unspec (temp) = unspec (dl.def (i)); 639 unspec (dl.def (i)) = unspec (dl.def (1)); 640 unspec (dl.def (1)) = unspec (temp); 641 call adjust_heap (dlp, 1, i - 1, size (dl_entry)); 642 end; 643 644 /* now scan the sorted list and print out the definition list */ 645 646 do i = 1 to dl.count; 647 648 /* print each definition entry */ 649 650 call append (strp, bc, col, (NL)); 651 652 /* we only print the component, if there is more than one */ 653 654 if msf_sw 655 then addr = "(" || ltrim (rtrim (char (dl.def (i).comp))) || ")"; 656 else addr = ""; 657 658 /* produce the rest of the address field */ 659 660 addr = addr || section_name (dl.def (i).section) || "|"; 661 addr = addr || oct ((dl.def (i).offset), -1, " "); 662 fixed_addr = addr; 663 664 /* display the address */ 665 666 call append (strp, bc, col, (fixed_addr)); 667 668 /* display the name */ 669 670 if dl.def (i).flags.indirect | dl.def (i).flags.entrypoint 671 then call append (strp, bc, col, (dl.def (i).name)); 672 else call append (strp, bc, col, rtrim (dl.def (i).name)); 673 674 /* display the flags (if any) */ 675 676 if dl.def (i).flags.indirect 677 then call append (strp, bc, col, " Indirect"); 678 if dl.def (i).flags.entrypoint 679 then call append (strp, bc, col, " Entrypoint"); 680 end; 681 682 dl.count = 0; 683 684 end print_defs; 685 686 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 687 688 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 689 690 691 get_link_info: 692 proc (lkp, /** link pointer (in ) */ 693 dhp, /** def header pointer (in ) */ 694 lep); /** link list entry ptr (i/o) */ 695 696 /*** ****************************************************************/ 697 /*** */ 698 /*** Name: get_link_info */ 699 /*** Input: lkp, dhp, lep */ 700 /*** Function: extracts information about a link and enters it */ 701 /*** into a link list entry. */ 702 /*** Output: lep */ 703 /*** */ 704 /*** ****************************************************************/ 705 706 /* parameters */ 707 708 dcl lkp ptr parameter; 709 dcl dhp ptr parameter; 710 dcl lep ptr parameter; 711 712 /* based */ 713 714 dcl 01 lk aligned like object_link based (lkp); 715 dcl 01 le aligned like ll_entry based (lep); 716 dcl 01 init aligned like link_init based (initp); 717 dcl 01 exp aligned like exp_word based (expp); 718 dcl 01 tp aligned like type_pair based (tpp); 719 dcl 01 segname aligned based (segnamep), 720 02 count fixed bin (9) unsigned unaligned, 721 02 string char (0 refer (segname.count)) unaligned; 722 dcl 01 offsetname aligned based (offsetnamep), 723 02 count fixed bin (9) unsigned unaligned, 724 02 string char (0 refer (offsetname.count)) unaligned; 725 726 /* automatic */ 727 728 dcl expp ptr automatic; 729 dcl tpp ptr automatic; 730 dcl segnamep ptr automatic; 731 dcl offsetnamep ptr automatic; 732 dcl initp ptr automatic; 733 dcl nm char (64) varying automatic; 734 735 expp = addrel (dhp, lk.expression_relp); 736 tpp = addrel (dhp, exp.type_relp); 737 segnamep = addrel (dhp, tp.segname_relp); 738 offsetnamep = addrel (dhp, tp.offsetname_relp); 739 initp = addrel (dhp, tp.trap_relp); 740 741 if tp.type = 1 742 then nm = rtrim (SYMBOLIC_SECTION_NAMES (tp.segname_relp)) || "|0"; 743 else if tp.type = 3 744 then nm = segname.string || "$"; 745 else if tp.type = 4 746 then do; 747 if segname.string = offsetname.string 748 then nm = segname.string; 749 else nm = segname.string || "$" || offsetname.string; 750 end; 751 else if tp.type = 5 752 then nm = rtrim (SYMBOLIC_SECTION_NAMES (tp.segname_relp)) || "$" || 753 offsetname.string; 754 else if tp.type = 6 755 then do; 756 if segname.string = offsetname.string 757 then nm = segname.string; 758 else nm = segname.string || "$" || offsetname.string; 759 end; 760 else call le_error_ (LE_ABORT_ERROR, le_et_$implementation_error, 761 "^/Invalid link type (^d) found at ^p.", tp.type, lkp); 762 763 if exp.expression > 0 764 then nm = nm || "+" || oct ((exp.expression), -1, " "); 765 if lk.modifier ^= ""b 766 then nm = nm || "," || modifier (fixed (lk.modifier, 6, 0)); 767 768 le.name = nm; 769 770 if (tp.type = 5 | tp.type = 6) & tp.trap_relp ^= 0 771 then do; 772 le.init_offset = tp.trap_relp; 773 le.init_length = init.n_words; 774 end; 775 else do; 776 le.init_offset = 0; 777 le.init_length = 0; 778 end; 779 1 1 /* BEGIN INCLUDE FILE ... op_mnemonic_format.incl.pl1 1 2* 1 3* James R. Davis 20 May 79 */ 1 4 1 5 dcl 1 op_mnemonic_$op_mnemonic (0:1023) external static aligned, 1 6 2 opcode char (6) unal, 1 7 2 dtype fixed bin (2) unal, /* 0 = alpha, 1 = bit, 2 = numeric */ 1 8 2 num_desc fixed bin (5) unal, 1 9 2 num_words fixed bin (8) unal; 1 10 1 11 dcl modifier (0:63) char (3) aligned int static options (constant) init ( 1 12 " ", "au", "qu", "du", "ic", "al", "ql", "dl", 1 13 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", 1 14 "*", "au*", "qu*", "...", "ic*", "al*", "ql*", "...", 1 15 "x0*", "x1*", "x2*", "x3*", "x4*", "x5*", "x6*", "x7*", 1 16 "f", "itp", "...", "its", "sd", "scr", "f2", "f3", 1 17 "ci", "i", "sc", "ad", "di", "dic", "id", "idc", 1 18 "*n", "*au", "*qu", "*du", "*ic", "*al", "*ql", "*dl", 1 19 "*x0", "*x1", "*x2", "*x3", "*x4", "*x5", "*x6", "*x7"); 1 20 1 21 /* Note: if num_words = 1, then num_desc is a flag 1 22* if non0, the tag field of the instruction is to be interpreted specially 1 23* for example, stba or stca 1 24**/ 1 25 /* END INCLUDE FILE op_mnemonic_format.incl.pl1 */ 780 781 782 end get_link_info; 783 784 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 785 786 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 787 788 789 print_links: 790 proc (llp, /** link list pointer (in ) */ 791 msf_sw, /** MSF switch (in ) */ 792 strp, /** list seg pointer (i/o) */ 793 bc, /** list seg bit count (i/o) */ 794 col); /** display column (i/o) */ 795 796 /*** ****************************************************************/ 797 /*** */ 798 /*** Name: print_links */ 799 /*** Input: llp, msf_sw, strp, bc, col */ 800 /*** Function: sorts and prints out the list of retained links. */ 801 /*** Output: strp, bc, col */ 802 /*** */ 803 /*** ****************************************************************/ 804 805 /* parameters */ 806 807 dcl llp ptr parameter; 808 dcl msf_sw bit (1) parameter; 809 dcl strp ptr parameter; 810 dcl bc fixed bin (24) parameter; 811 dcl col fixed bin parameter; 812 813 /* based */ 814 815 dcl 01 ll aligned based (llp), 816 02 count fixed bin, 817 02 lk dim (0 refer (ll.count)) like link_list.lk; 818 819 /* automatic */ 820 821 dcl temp (1:size (ll_entry)) fixed bin (35) automatic; 822 dcl i fixed bin automatic; 823 dcl comp char (5) varying automatic; 824 dcl fixed_comp char (5) automatic; 825 dcl addr char (12) varying automatic; 826 dcl fixed_addr char (12) automatic; 827 dcl init char (64) varying automatic; 828 829 call append (strp, bc, col, NL || NL); 830 831 do i = divide (ll.count, 2, 17, 0) by -1 to 1; 832 call adjust_heap (llp, i, ll.count, size (ll_entry)); 833 end; 834 835 do i = ll.count by -1 to 2; 836 unspec (temp) = unspec (ll.lk (i)); 837 unspec (ll.lk (i)) = unspec (ll.lk (1)); 838 unspec (ll.lk (1)) = unspec (temp); 839 call adjust_heap (llp, 1, i - 1, size (ll_entry)); 840 end; 841 842 call append (strp, bc, col, NL || ltrim (rtrim (char (ll.count)))); 843 call append (strp, bc, col, " Links:" || NL || NL); 844 845 do i = 1 to ll.count; 846 if msf_sw 847 then do; 848 comp = "(" || rtrim (ltrim (char (ll.lk (i).comp))) || ")"; 849 fixed_comp = copy (" ", length (fixed_comp) - length (comp)) || comp; 850 call append (strp, bc, col, (fixed_comp)); 851 end; 852 addr = "link|" || oct ((ll.lk (i).offset), -1, " "); 853 fixed_addr = addr; 854 call append (strp, bc, col, fixed_addr || rtrim (ll.lk (i).name)); 855 856 if ll.lk (i).init_offset ^= 0 857 then do; 858 init = " Init -> def|" || oct ((ll.lk (i).init_offset), -1, " "); 859 init = init || ", length = "; 860 init = init || ltrim (rtrim (char (ll.lk (i).init_length))); 861 call append (strp, bc, col, init); 862 end; 863 864 call append (strp, bc, col, (NL)); 865 end; 866 867 end print_links; 868 869 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 870 871 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 872 873 874 adjust_heap: 875 proc (heapp, /** heap pointer (i/o) */ 876 top, /** top node index (in ) */ 877 last, /** end node index (in ) */ 878 n_words); /** size of entry (in ) */ 879 880 /*** ****************************************************************/ 881 /*** */ 882 /*** Name: adjust_heap */ 883 /*** Input: heapp, top, last, n_words */ 884 /*** Function: adjusts a heap structure so that a given node is */ 885 /*** always greater than both its children. */ 886 /*** Output: heapp */ 887 /*** */ 888 /*** ****************************************************************/ 889 890 /* parameters */ 891 892 dcl heapp ptr parameter; 893 dcl top fixed bin parameter; 894 dcl last fixed bin parameter; 895 dcl n_words fixed bin parameter; 896 897 /* based */ 898 899 dcl 01 heap aligned based (heapp), 900 02 count fixed bin, 901 02 entry (0 refer (heap.count)) bit (n_words * 36); 902 903 /* automatic */ 904 905 dcl l fixed bin automatic; 906 dcl r fixed bin automatic; 907 dcl side fixed bin automatic; 908 dcl temp bit (n_words * 36) automatic; 909 910 l = top * 2; 911 r = l + 1; 912 913 if l > last 914 then return; 915 916 if r > last 917 then do; 918 if heap.entry (top) < heap.entry (l) 919 then do; 920 temp = heap.entry (l); 921 heap.entry (l) = heap.entry (top); 922 heap.entry (top) = temp; 923 end; 924 return; 925 end; 926 927 if heap.entry (top) > heap.entry (l) & heap.entry (top) > heap.entry (r) 928 then return; 929 930 if heap.entry (l) > heap.entry (r) 931 then side = l; 932 else side = r; 933 934 temp = heap.entry (side); 935 heap.entry (side) = heap.entry (top); 936 heap.entry (top) = temp; 937 call adjust_heap (heapp, side, last, n_words); 938 939 return; 940 941 end adjust_heap; 942 943 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 944 945 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 946 947 948 append: 949 proc (strp, /** string pointer (i/o) */ 950 bc, /** bit count (i/o) */ 951 col, /** current column (i/o) */ 952 text); /** text to append (in ) */ 953 954 /*** ****************************************************************/ 955 /*** */ 956 /*** Name: append */ 957 /*** Input: strp, bc, col, text */ 958 /*** Function: appends the text given to to the segment pointed */ 959 /*** to by strp, and adjusts strp and bc appropriately */ 960 /*** Output: strp, bc */ 961 /*** */ 962 /*** ****************************************************************/ 963 964 /* parameters */ 965 966 dcl strp ptr parameter; 967 dcl bc fixed bin (24) parameter; 968 dcl col fixed bin parameter; 969 dcl text char (*) varying parameter; 970 971 /* based */ 972 973 dcl str char (strl) unaligned based (strp); 974 975 /* automatic */ 976 977 dcl strl fixed bin (21) automatic; 978 dcl new char (512) varying automatic; 979 980 call tabin (text, col, new); 981 982 strl = length (new); 983 str = new; 984 985 strp = addcharno (strp, strl); 986 bc = bc + strl * 9; 987 988 end append; 989 990 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 991 992 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 993 994 995 tabin: 996 proc (old, /** old text (in ) */ 997 col, /** start column (i/o) */ 998 new); /** new text (out) */ 999 1000 /*** ****************************************************************/ 1001 /*** */ 1002 /*** Name: tabin */ 1003 /*** Input: old, col */ 1004 /*** Function: replaces spaces with tabs in the output listing */ 1005 /*** Output: col, new */ 1006 /*** */ 1007 /*** ****************************************************************/ 1008 1009 /* parameters */ 1010 1011 dcl old char (*) varying parameter; 1012 dcl col fixed bin parameter; 1013 dcl new char (*) varying parameter; 1014 1015 /* automatic */ 1016 1017 dcl start fixed bin automatic; 1018 dcl left fixed bin automatic; 1019 dcl first fixed bin automatic; 1020 dcl tab_col fixed bin automatic; 1021 dcl nlx fixed bin automatic; 1022 1023 new = ""; 1024 1025 start = 1; 1026 left = length (old); 1027 1028 do while (left > 0); 1029 first = index (substr (old, start, left), " "); 1030 if first = 0 1031 then first = left; 1032 else first = first - 1; 1033 1034 if first > 0 1035 then do; 1036 nlx = index (reverse (substr (old, start, first)), NL); 1037 if nlx > 0 1038 then col = nlx; 1039 else col = col + first; 1040 1041 new = new || substr (old, start, first); 1042 start = start + first; 1043 left = left - first; 1044 end; 1045 1046 if left > 0 1047 then do; 1048 first = verify (substr (old, start, left), " "); 1049 if first = 0 1050 then first = left; 1051 else first = first - 1; 1052 1053 tab_col = divide (col + 9, 10, 17, 0) * 10 + 1; 1054 col = col + first; 1055 left = left - first; 1056 start = start + first; 1057 1058 if col >= tab_col 1059 then do; 1060 do while (tab_col <= col); 1061 new = new || " "; 1062 tab_col = tab_col + 10; 1063 end; 1064 1065 tab_col = tab_col - 10; 1066 1067 if col ^= tab_col 1068 then new = new || copy (" ", col - tab_col); 1069 end; 1070 else new = new || copy (" ", first); 1071 end; 1072 end; 1073 1074 end tabin; 1075 1076 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1077 1078 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1079 1080 1081 oct: 1082 proc (value, /** value to convert (in ) */ 1083 size, /** field length (in ) */ 1084 pad) /** pad character (in ) */ 1085 returns (char (32) varying); /** octal string (out) */ 1086 1087 /*** ****************************************************************/ 1088 /*** */ 1089 /*** Name: oct */ 1090 /*** Input: value, size, pad */ 1091 /*** Function: converts a number to a string of octal digits of */ 1092 /*** a given length, padded with a given character. */ 1093 /*** Output: octal_string */ 1094 /*** */ 1095 /*** ****************************************************************/ 1096 1097 /* constants */ 1098 1099 dcl octal (0:7) char (1) static options (constant) 1100 init ("0", "1", "2", "3", "4", "5", "6", "7"); 1101 1102 /* parameters */ 1103 1104 dcl value fixed bin (35) parameter; 1105 dcl size fixed bin parameter; 1106 dcl pad char (1) parameter; 1107 1108 /* based */ 1109 1110 dcl digit (1:12) fixed bin (3) unsigned unaligned 1111 based (addr (value)); 1112 1113 /* automatic */ 1114 1115 dcl string char (32) varying automatic; 1116 dcl overflow bit (1) automatic; 1117 dcl padding bit (1) automatic; 1118 dcl d fixed bin automatic; 1119 1120 string = ""; 1121 overflow = false; 1122 padding = true; 1123 1124 if size > 12 1125 then string = copy (pad, size - 12); 1126 1127 do d = 1 to 12; 1128 if d = 12 1129 then padding = false; 1130 if 13 - d > size & size > 0 1131 then do; 1132 if digit (d) ^= 0 1133 then overflow = true; 1134 else ; 1135 end; 1136 else do; 1137 if overflow 1138 then string = string || "*"; 1139 else if padding & digit (d) = 0 1140 then do; 1141 if size > 0 1142 then string = string || pad; 1143 else ; 1144 end; 1145 else do; 1146 string = string || octal (digit (d)); 1147 if digit (d) ^= 0 1148 then padding = false; 1149 end; 1150 end; 1151 end; 1152 1153 return (string); 1154 1155 end oct; 1156 1157 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1158 1159 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1160 1161 2 1 /* BEGIN INCLUDE FILE ... access_mode_values.incl.pl1 2 2* 2 3* Values for the "access mode" argument so often used in hardcore 2 4* James R. Davis 26 Jan 81 MCR 4844 2 5* Added constants for SM access 4/28/82 Jay Pattin 2 6* Added text strings 03/19/85 Chris Jones 2 7**/ 2 8 2 9 2 10 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 2 11 dcl ( 2 12 N_ACCESS init ("000"b), 2 13 R_ACCESS init ("100"b), 2 14 E_ACCESS init ("010"b), 2 15 W_ACCESS init ("001"b), 2 16 RE_ACCESS init ("110"b), 2 17 REW_ACCESS init ("111"b), 2 18 RW_ACCESS init ("101"b), 2 19 S_ACCESS init ("100"b), 2 20 M_ACCESS init ("010"b), 2 21 A_ACCESS init ("001"b), 2 22 SA_ACCESS init ("101"b), 2 23 SM_ACCESS init ("110"b), 2 24 SMA_ACCESS init ("111"b) 2 25 ) bit (3) internal static options (constant); 2 26 2 27 /* The following arrays are meant to be accessed by doing either 1) bin (bit_value) or 2 28* 2) divide (bin_value, 2) to come up with an index into the array. */ 2 29 2 30 dcl SEG_ACCESS_MODE_NAMES (0:7) init ("null", "W", "E", "EW", "R", "RW", "RE", "REW") char (4) internal 2 31 static options (constant); 2 32 2 33 dcl DIR_ACCESS_MODE_NAMES (0:7) init ("null", "A", "M", "MA", "S", "SA", "SM", "SMA") char (4) internal 2 34 static options (constant); 2 35 2 36 dcl ( 2 37 N_ACCESS_BIN init (00000b), 2 38 R_ACCESS_BIN init (01000b), 2 39 E_ACCESS_BIN init (00100b), 2 40 W_ACCESS_BIN init (00010b), 2 41 RW_ACCESS_BIN init (01010b), 2 42 RE_ACCESS_BIN init (01100b), 2 43 REW_ACCESS_BIN init (01110b), 2 44 S_ACCESS_BIN init (01000b), 2 45 M_ACCESS_BIN init (00010b), 2 46 A_ACCESS_BIN init (00001b), 2 47 SA_ACCESS_BIN init (01001b), 2 48 SM_ACCESS_BIN init (01010b), 2 49 SMA_ACCESS_BIN init (01011b) 2 50 ) fixed bin (5) internal static options (constant); 2 51 2 52 /* END INCLUDE FILE ... access_mode_values.incl.pl1 */ 1162 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 the first ordinary (class^=3) definition 3 108* belonging to this segname block. In the case where there are more than 3 109* one segname's on a block, all their first_relp will point 3 110* to the same place. 3 111* 3 112* (2) if there are no ordinary definitions associated with this segname, 3 113* then it is the def section offset of the next segname. 3 114* 3 115* (3) if there are no ordinary definitions in the block, and it 3 116* is the last block, then it points to a word containing 0. 3 117* 3 118* Thus the end of a list of synonym segnames can be detected by forward_relp 3 119* pointing to a class=3 definition whose first_relp is not the same as 3 120* the current definitions first_relp. 3 121**/ 3 122 3 123 /* All the definitions are linked through the forward and 3 124* backward thread variables. The end of the chain can is indicated 3 125* by forward pointing to a zero word. */ 3 126 3 127 3 128 declare exp_ptr pointer; 3 129 declare 1 exp_word based (exp_ptr) aligned, /* expression word in link definition */ 3 130 2 type_relp fixed bin (18) unsigned unal, 3 131 /* pointer (rel to defs) of type pair structure */ 3 132 2 expression fixed bin (17) unal; /* constant expression to be added in when snapping link */ 3 133 3 134 declare ( 3 135 LINK_SELF_BASE init (1), /* *section|0+expression,modifier */ 3 136 /* which section determined by segname_relp */ 3 137 LINK_OBSOLETE_2 init (2), /* not used */ 3 138 LINK_REFNAME_BASE init (3), /* refname|0+expression,modifier */ 3 139 LINK_REFNAME_OFFSETNAME init (4), /* refname|offsetname+expression,modifier */ 3 140 LINK_SELF_OFFSETNAME init (5), /* *section|offsetname+expression,modifier */ 3 141 LINK_CREATE_IF_NOT_FOUND init (6), /* OBSOLETE: like LINK_REFNAME_OFFSETNAME except that it will create instead of taking linkage_error */ 3 142 SECTION_TEXT init (0), /* *text */ 3 143 SECTION_LINK init (1), /* *link */ 3 144 SECTION_SYMBOL init (2), /* *symbol */ 3 145 SECTION_UNUSED init (3), /* reserved */ 3 146 SECTION_STATIC init (4), /* *static */ 3 147 SECTION_SYSTEM init (5), /* *system */ 3 148 SECTION_HEAP init (6) /* *heap */ 3 149 ) fixed bin (18) unsigned unaligned internal static options (constant); 3 150 3 151 /* use CLASS_NAMES for section names */ 3 152 3 153 declare LINK_TYPE_NAMES (1:6) 3 154 init ("absolute in section", "unused", "absolute off of refname", 3 155 "symbolic off of refname", "symbolic in section", "symbolic off of refname; create") 3 156 character (32) varying internal static options (constant); 3 157 3 158 3 159 declare type_ptr pointer; 3 160 declare 1 type_pair based (type_ptr) aligned,/* type pair in link definition */ 3 161 2 type fixed bin (18) unsigned unal, 3 162 /* see above */ 3 163 2 trap_relp fixed bin (18) unsigned unal, 3 164 /* pointer (rel to defs) to the trap word */ 3 165 /* unless LINK_SELF_OFFSETNAME off of *system or create link */ 3 166 2 segname_relp fixed bin (18) unsigned unal, 3 167 /* pointer (rel to defs) to ACC reference name for segment referenced, 3 168* /*or section code for SELF links */ 3 169 2 offsetname_relp fixed bin (18) unsigned unal; 3 170 /* for OFFSETNAME links, ACC string of name of location. */ 3 171 /* for others, must be ZERO */ 3 172 3 173 3 174 /* Link Trap Pair */ 3 175 3 176 declare link_trap_ptr pointer; 3 177 declare 1 link_trap_pair aligned based (link_trap_ptr), 3 178 2 call_relp fixed bin (18) unsigned unaligned, 3 179 /* LINK18, link to thing to call */ 3 180 2 info_relp fixed bin (18) unsigned unaligned; 3 181 /* LINK18, link to argument list */ 3 182 3 183 3 184 /* initialization info for *system or *heap link */ 3 185 3 186 3 187 /* NOTE -------------------------------------------------- 3 188* the following structures defining initialization information are also 3 189* defined in fortran_storage.incl.pl1 system_link_init_info.incl.pl1 3 190* and should be kept equivalent 3 191* ------------------------------------------------------- 3 192**/ 3 193 3 194 declare ( 3 195 INIT_NO_INIT init (0), 3 196 INIT_COPY_INFO init (3), 3 197 INIT_DEFINE_AREA init (4), 3 198 INIT_LIST_TEMPLATE init (5), 3 199 INIT_DEFERRED init (6) 3 200 ) fixed bin internal static options (constant); 3 201 3 202 /* for type = 0 or 4 */ 3 203 3 204 declare link_init_ptr pointer; 3 205 declare 1 link_init aligned based (link_init_ptr), 3 206 2 n_words fixed bin (35), /* number to invent */ 3 207 2 type fixed bin; /* see types above */ 3 208 3 209 /* for type=3, there is data to copy */ 3 210 3 211 declare 1 link_init_copy_info aligned based (link_init_ptr), 3 212 2 header aligned like link_init, 3 213 2 initial_data (link_init_n_words refer (link_init_copy_info.header.n_words)) bit (36) aligned; 3 214 3 215 declare link_init_n_words fixed bin; 3 216 3 217 /* for type = 5, there is a list template to copy */ 3 218 3 219 declare 1 link_init_list_template 3 220 aligned based (link_init_ptr), 3 221 2 header aligned like link_init, 3 222 2 pad bit (18) unaligned, 3 223 2 n_words_in_list fixed bin (18) unsigned unaligned, 3 224 2 template (link_init_n_words_in_list refer (link_init_list_template.n_words_in_list)); 3 225 3 226 declare link_init_n_words_in_list 3 227 fixed bin; 3 228 3 229 /* A list template consists of a series of entries with the following 3 230* description, concatenated together. n_bits and datum are bit items, 3 231* to permit a wide range of inputs. 3 232* 3 233* 1. A 'repeat' of '0' signifies skipping of 'n_bits' bits. 3 234* 2. A 'n_bits' of '0' signifies the last item of the list. 3 235* 3 236* COMMON, VLA's, and LA's are presumed to start at the base pointer 3 237* of their particular storage section. */ 3 238 3 239 declare 1 list_template_entry aligned based, 3 240 2 n_bits fixed bin (35) aligned, /* size of datum */ 3 241 2 mbz bit (3) unaligned, /* future expansion */ 3 242 2 init_type fixed bin (3) unsigned unaligned, /* 0 normal init, 1 ptr init, 2 packed ptr init */ 3 243 2 repeat fixed bin (30) unsigned unaligned, 3 244 /* number of times to repeat datum */ 3 245 2 datum bit (link_init_n_bits_in_datum refer (list_template_entry.n_bits)); 3 246 3 247 3 248 /* the pointer_init_template represents the initialization information 3 249* for ITS and packed pointers. Both pointer types require the entire 3 250* 72 bit structure. 3 251**/ 3 252 3 253 dcl 1 pointer_init_template based, 3 254 2 ptr_type fixed bin (18) unsigned unaligned, /* 0 text section, 1 linkage section, 2 static section */ 3 255 2 section_offset fixed bin (18) unsigned unaligned, /* offset to item in specified section */ 3 256 2 word_offset fixed bin (18) unsigned unaligned, /* offset from section item to target in words */ 3 257 2 mbz bit (12) unaligned, 3 258 2 bit_offset fixed bin (6) unsigned unaligned; /* offset from section item|word offset to target in bits */ 3 259 3 260 3 261 declare link_init_n_bits_in_datum 3 262 fixed bin (35); 3 263 3 264 /* for type = 6, the init_info resides in another MSF component */ 3 265 /* target_relp is a linkage section offset to a partial link to */ 3 266 /* the base of the linkage section of the component containing */ 3 267 /* the actual init_info. link_relp is the offset of the actual */ 3 268 /* link within that linkage section. */ 3 269 3 270 declare 1 link_init_deferred aligned based (link_init_ptr), 3 271 2 header aligned like link_init, 3 272 2 target_relp fixed bin (18) unsigned unaligned, 3 273 2 link_relp fixed bin (18) unsigned unaligned; 3 274 3 275 /* Definition section hash table */ 3 276 3 277 declare def_ht_ptr pointer; 3 278 declare 1 definition_ht aligned based (def_ht_ptr), 3 279 2 n_entries fixed bin, 3 280 2 table (def_ht_n_entries refer (definition_ht.n_entries)) aligned, 3 281 3 def_relp fixed bin (18) unsigned unaligned, 3 282 3 unused bit (18) unaligned; 3 283 3 284 declare def_ht_n_entries fixed bin; 3 285 3 286 3 287 /* Component name ht */ 3 288 declare comp_ht_ptr pointer; 3 289 declare 1 component_ht aligned based (comp_ht_ptr), 3 290 2 n_entries fixed bin, 3 291 2 table (comp_ht_n_entries refer (component_ht.n_entries)) aligned, 3 292 3 def_relp fixed bin (18) unsigned unaligned, 3 293 /* hashed segname */ 3 294 3 block_hdr_relp fixed bin (18) unsigned unaligned; 3 295 /* first segname def of block containing def_relp */ 3 296 3 297 declare comp_ht_n_entries fixed bin; 3 298 3 299 /* Duplicate name table */ 3 300 3 301 declare dup_table_ptr pointer; 3 302 declare 1 duplicate_table aligned based (dup_table_ptr), 3 303 2 mbz bit (18) unaligned, /* to tell it from a definition */ 3 304 2 n_names fixed bin (18) unsigned unaligned, 3 305 /* n in table */ 3 306 2 table (dup_table_n_names refer (duplicate_table.n_names)) aligned, 3 307 3 def_relp fixed bin (18) unsigned unaligned, 3 308 3 block_hdr_relp fixed bin (18) unsigned unaligned; 3 309 3 310 declare dup_table_n_names fixed bin; 3 311 3 312 /* The msf_map is found in the definition section of an */ 3 313 /* object MSF component. It is used by the linker to */ 3 314 /* determine whether a segment is a component of an object */ 3 315 /* MSF or a standard single-segment object. */ 3 316 3 317 dcl msf_map_ptr ptr; 3 318 dcl 01 msf_map aligned based (msf_map_ptr), 3 319 02 version char (8), 3 320 02 component_count fixed bin (15) unsigned, 3 321 02 my_component fixed bin (15) unsigned; 3 322 3 323 dcl msf_map_version_1 char (8) static options (constant) 3 324 init ("msfmp1.0"); 3 325 3 326 declare acc_string_ptr pointer; 3 327 declare 1 acc_string aligned based (acc_string_ptr), 3 328 2 count fixed bin (9) unsigned unaligned, 3 329 2 string character (max (3, acc_string_length) refer (acc_string.count)) unaligned, 3 330 2 mbz bit (0) aligned; /* this causes the statement */ 3 331 /* unspec (acc_string) = ""b to zero out */ 3 332 /* the last word, if the string is not of length 0mod4 */ 3 333 3 334 declare acc_string_length fixed bin (21); 3 335 3 336 3 337 /* end include file definitions_dcls.incl.pl1 */ 1163 4 1 /**** START OF: le_data.incl.pl1 * * * * * */ 4 2 4 3 /****^ HISTORY COMMENTS: 4 4* 1) change(86-08-12,Elhard), approve(86-08-12,MCR7505), 4 5* audit(86-12-10,DGHowe), install(86-12-10,MR12.0-1241): 4 6* Originally written to define the structures used internally by le_. 4 7* END HISTORY COMMENTS */ 4 8 4 9 /*** ****************************************************************/ 4 10 /*** */ 4 11 /*** Name: le_data */ 4 12 /*** Function: This include file defines the data structures */ 4 13 /*** used internally by the linkage_editor subroutine. */ 4 14 /*** */ 4 15 /*** ****************************************************************/ 4 16 4 17 /* error severity constants */ 4 18 4 19 dcl LE_WARNING fixed bin static options (constant) init (1); 4 20 dcl LE_ERROR fixed bin static options (constant) init (2); 4 21 dcl LE_FATAL_ERROR fixed bin static options (constant) init (3); 4 22 dcl LE_ABORT_ERROR fixed bin static options (constant) init (4); 4 23 4 24 /* section identifier constants */ 4 25 4 26 dcl Text fixed bin (3) static options (constant) 4 27 init (0); 4 28 dcl Linkage fixed bin (3) static options (constant) 4 29 init (1); 4 30 dcl Symbol fixed bin (3) static options (constant) 4 31 init (2); 4 32 dcl Definition fixed bin (3) static options (constant) 4 33 init (3); 4 34 dcl Static fixed bin (3) static options (constant) 4 35 init (4); 4 36 dcl System fixed bin (3) static options (constant) 4 37 init (5); 4 38 dcl Heap fixed bin (3) static options (constant) 4 39 init (6); 4 40 4 41 dcl section_nm (0:6) char (16) static options (constant) 4 42 init ("text", "linkage", "symbol", "definition", 4 43 "static", "system", "heap"); 4 44 4 45 /* link type constants */ 4 46 4 47 dcl Self_Base fixed bin (3) static options (constant) 4 48 init (1); 4 49 dcl Refname_Base fixed bin (3) static options (constant) 4 50 init (3); 4 51 dcl Refname_Offsetname fixed bin (3) static options (constant) 4 52 init (4); 4 53 dcl Self_Offsetname fixed bin (3) static options (constant) 4 54 init (5); 4 55 4 56 /* backpatch type constants */ 4 57 4 58 dcl Patch_Link fixed bin static options (constant) init (1); 4 59 dcl Patch_Init fixed bin static options (constant) init (2); 4 60 dcl Patch_Symbol_Ref fixed bin static options (constant) init (3); 4 61 dcl Patch_Self_Init fixed bin static options (constant) init (4); 4 62 4 63 /*** ****************************************************************/ 4 64 /*** */ 4 65 /*** Name: le_components */ 4 66 /*** Function: the component table is used to keep information */ 4 67 /*** about the input components being used and their */ 4 68 /*** disposition in output components. */ 4 69 /*** */ 4 70 /*** ****************************************************************/ 4 71 4 72 dcl 01 le_components aligned based, 4 73 02 header aligned, 4 74 03 flags aligned, 4 75 04 separate_static bit (1) unaligned, 4 76 04 perprocess_static bit (1) unaligned, 4 77 04 mbz bit (34) unaligned, 4 78 03 n_components fixed bin, 4 79 02 comp (0 refer (le_components.n_components)) 4 80 like le_comp; 4 81 4 82 /*** ****************************************************************/ 4 83 /*** */ 4 84 /*** Name: le_comp */ 4 85 /*** Function: this is a single component table entry. */ 4 86 /*** */ 4 87 /*** ****************************************************************/ 4 88 4 89 dcl 01 le_comp aligned based, 4 90 02 segp ptr, 4 91 02 bc fixed bin (24), 4 92 02 uid bit (36) aligned, 4 93 02 dtcm fixed bin (71), 4 94 02 name char (32) varying, 4 95 02 path char (194) varying, 4 96 02 compiler char (8), 4 97 02 target fixed bin, 4 98 02 flags aligned, 4 99 03 library bit (1) unaligned, 4 100 03 include bit (1) unaligned, 4 101 03 delete_table bit (1) unaligned, 4 102 03 separate_static bit (1) unaligned, 4 103 03 io_table bit (1) unaligned, 4 104 03 unique_path bit (1) unaligned, 4 105 03 mbz bit (30) unaligned, 4 106 02 tables aligned, 4 107 03 lesp ptr, 4 108 03 ledp ptr, 4 109 03 lelp ptr, 4 110 02 orig aligned, 4 111 03 textp ptr, 4 112 03 defnp ptr, 4 113 03 linkp ptr, 4 114 03 statp ptr, 4 115 03 symbp ptr, 4 116 03 rel_textp ptr, 4 117 03 rel_symbp ptr, 4 118 03 rel_linkp ptr, 4 119 03 textl fixed bin (18) unsigned unaligned, 4 120 03 defnl fixed bin (18) unsigned unaligned, 4 121 03 linkl fixed bin (18) unsigned unaligned, 4 122 03 statl fixed bin (18) unsigned unaligned, 4 123 03 symbl fixed bin (18) unsigned unaligned, 4 124 03 symbl_no_rel fixed bin (18) unsigned unaligned, 4 125 03 symbl_no_table fixed bin (18) unsigned unaligned, 4 126 03 n_symb_blocks fixed bin (18) unsigned unaligned, 4 127 03 text_boundary fixed bin (9) unsigned unaligned, 4 128 03 static_boundary fixed bin (9) unsigned unaligned, 4 129 03 next_comp fixed bin (18) unsigned unaligned, 4 130 02 new aligned, 4 131 03 rel_text fixed bin (18) unsigned unaligned, 4 132 03 rel_symb fixed bin (18) unsigned unaligned, 4 133 03 rel_stat fixed bin (18) unsigned unaligned, 4 134 03 text_pad fixed bin (18) unsigned unaligned, 4 135 03 static_pad fixed bin (18) unsigned unaligned, 4 136 03 symbol_pad fixed bin (18) unsigned unaligned; 4 137 4 138 /*** ****************************************************************/ 4 139 /*** */ 4 140 /*** Name: le_segnames */ 4 141 /*** Function: the segname table is used for two purposes: */ 4 142 /*** - to determine the target components of links */ 4 143 /*** being resolved internally. */ 4 144 /*** - to determine the segname definitions to be */ 4 145 /*** emited for definitions being retained. */ 4 146 /*** */ 4 147 /*** ****************************************************************/ 4 148 4 149 dcl 01 le_segnames aligned based, 4 150 02 header aligned, 4 151 03 n_segnames fixed bin, 4 152 02 segname (segname_count refer (le_segnames.n_segnames)), 4 153 03 str char (32) varying, 4 154 03 relp fixed bin (18) unsigned unaligned, 4 155 03 pad bit (18) unaligned; 4 156 dcl segname_count fixed bin automatic; 4 157 4 158 /*** ****************************************************************/ 4 159 /*** */ 4 160 /*** Name: le_definitions */ 4 161 /*** Function: the definition table contains the definitions */ 4 162 /*** from the input components and is used to resolve */ 4 163 /*** link targets, and regenerate definition entries */ 4 164 /*** */ 4 165 /*** ****************************************************************/ 4 166 4 167 dcl 01 le_definitions aligned based, 4 168 02 header aligned, 4 169 03 n_defs fixed bin, 4 170 03 pad bit (36), 4 171 02 def (def_count refer (le_definitions.n_defs)) 4 172 like le_definition; 4 173 dcl def_count fixed bin automatic; 4 174 4 175 dcl 01 le_definition aligned based, 4 176 02 str char (256) varying, 4 177 02 type fixed bin (18) unsigned unaligned, 4 178 02 relp fixed bin (18) unsigned unaligned, 4 179 02 offset fixed bin (18) unsigned unaligned, 4 180 02 new_offset fixed bin (18) unsigned unaligned, 4 181 02 flags aligned, 4 182 03 force_retain bit (1) unaligned, 4 183 03 entrypoint bit (1) unaligned, 4 184 03 ignore bit (1) unaligned, 4 185 03 referenced bit (1) unaligned, 4 186 03 no_link bit (1) unaligned, 4 187 03 retain bit (1) unaligned, 4 188 03 delete bit (1) unaligned, 4 189 03 mbz bit (29) unaligned; 4 190 4 191 /*** ****************************************************************/ 4 192 /*** */ 4 193 /*** Name: le_options */ 4 194 /*** Function: the option table contains definition retention */ 4 195 /*** information. The input retentions options are */ 4 196 /*** ordered such that a linear search of the option */ 4 197 /*** table for the first matching starname will give */ 4 198 /*** the correct retention state. */ 4 199 /*** */ 4 200 /*** ****************************************************************/ 4 201 4 202 dcl 01 le_options aligned based, 4 203 02 header aligned, 4 204 03 n_opts fixed bin, 4 205 02 opt (0 refer (le_options.n_opts)), 4 206 03 type fixed bin (8) unaligned, 4 207 03 used bit (1) unaligned, 4 208 03 inhibit_error bit (1) unaligned, 4 209 03 class fixed bin (6) unaligned, 4 210 03 order fixed bin (17) unaligned, 4 211 03 segname char (32) unaligned, 4 212 03 ep_name char (256) unaligned; 4 213 4 214 /*** ****************************************************************/ 4 215 /*** */ 4 216 /*** Name: le_links */ 4 217 /*** Function: the link table contains information on all of the */ 4 218 /*** links in the input components. It is used to */ 4 219 /*** determine link targets, which library components */ 4 220 /*** will be included, and what init_info will be */ 4 221 /*** used, and where it will be placed. */ 4 222 /*** */ 4 223 /*** ****************************************************************/ 4 224 4 225 dcl 01 le_links aligned based, 4 226 02 header aligned, 4 227 03 offset_adjustment fixed bin (18), 4 228 03 n_links fixed bin, 4 229 02 link (link_count refer (le_links.n_links)) 4 230 like le_link; 4 231 dcl link_count fixed bin automatic; 4 232 4 233 dcl 01 le_link aligned based, 4 234 02 flags unaligned, 4 235 03 used bit (1), 4 236 03 mbx bit (35), 4 237 02 type fixed bin (6) unsigned unaligned, 4 238 02 class fixed bin (6) unsigned unaligned, 4 239 02 mod bit (6) unaligned, 4 240 02 exp fixed bin (17) unaligned, 4 241 02 target fixed bin (18) unsigned unaligned, 4 242 02 defx fixed bin (18) unsigned unaligned, 4 243 02 relp fixed bin (18) unsigned unaligned, 4 244 02 target_comp fixed bin (18) unsigned unaligned, 4 245 02 target_link fixed bin (18) unsigned unaligned, 4 246 02 extension fixed bin (18) unsigned unaligned, 4 247 02 initp ptr unaligned, 4 248 02 segnamep ptr unaligned, 4 249 02 offsetp ptr unaligned; 4 250 4 251 /*** ****************************************************************/ 4 252 /*** */ 4 253 /*** Name: le_binaries */ 4 254 /*** Function: This table contains information about the output */ 4 255 /*** binaries. It is primarily used for creation and */ 4 256 /*** backpatching of MSF output. */ 4 257 /*** */ 4 258 /*** ****************************************************************/ 4 259 4 260 dcl 01 le_binaries aligned based, 4 261 02 header aligned, 4 262 03 n_binaries fixed bin, 4 263 03 pad bit (36), 4 264 02 binary (0:0 refer (le_binaries.n_binaries)), 4 265 03 segp ptr, 4 266 03 bc fixed bin (24), 4 267 03 uid bit (36), 4 268 03 aclc fixed bin, 4 269 03 aclp ptr, 4 270 03 textp ptr, 4 271 03 defnp ptr, 4 272 03 linkp ptr, 4 273 03 symbp ptr, 4 274 03 statp ptr, 4 275 03 textl fixed bin (18) unsigned unaligned, 4 276 03 defnl fixed bin (18) unsigned unaligned, 4 277 03 linkl fixed bin (18) unsigned unaligned, 4 278 03 symbl fixed bin (18) unsigned unaligned, 4 279 03 statl fixed bin (18) unsigned unaligned, 4 280 03 mbz2 bit (18) unaligned; 4 281 4 282 /*** ****************************************************************/ 4 283 /*** */ 4 284 /*** Name: le_patches */ 4 285 /*** Function: This table contains the list of backpatches to be */ 4 286 /*** performed when the rest of the object creation is */ 4 287 /*** complete. Since le_backpatch_ is the only routine */ 4 288 /*** concerned with this, it is maintained completely */ 4 289 /*** internal to le_backpatch_. */ 4 290 /*** */ 4 291 /*** ****************************************************************/ 4 292 4 293 dcl 01 le_patches aligned based, 4 294 02 header aligned, 4 295 03 n_patches fixed bin, 4 296 02 patch (0 refer (le_patches.n_patches)) like le_patch; 4 297 4 298 dcl 01 le_patch aligned based, 4 299 02 type fixed bin, 4 300 02 comp fixed bin, 4 301 02 relp fixed bin (18) unsigned, 4 302 02 target fixed bin, 4 303 02 index fixed bin; 4 304 4 305 /**** END OF: le_data.incl.pl1 * * * * * */ 1164 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 */ 1165 6 1 dcl 1 std_symbol_header based aligned, 6 2 2 dcl_version fixed bin, 6 3 2 identifier char(8), 6 4 2 gen_number fixed bin, 6 5 2 gen_created fixed bin(71), 6 6 2 object_created fixed bin(71), 6 7 2 generator char(8), 6 8 2 gen_version unaligned, 6 9 3 offset bit(18), 6 10 3 size bit(18), 6 11 2 userid unaligned, 6 12 3 offset bit(18), 6 13 3 size bit(18), 6 14 2 comment unaligned, 6 15 3 offset bit(18), 6 16 3 size bit(18), 6 17 2 text_boundary bit(18) unaligned, 6 18 2 stat_boundary bit(18) unaligned, 6 19 2 source_map bit(18) unaligned, 6 20 2 area_pointer bit(18) unaligned, 6 21 2 backpointer bit(18) unaligned, 6 22 2 block_size bit(18) unaligned, 6 23 2 next_block bit(18) unaligned, 6 24 2 rel_text bit(18) unaligned, 6 25 2 rel_def bit(18) unaligned, 6 26 2 rel_link bit(18) unaligned, 6 27 2 rel_symbol bit(18) unaligned, 6 28 2 mini_truncate bit(18) unaligned, 6 29 2 maxi_truncate bit(18) unaligned; 1166 7 1 /* BEGIN INCLUDE FILE ... terminate_file.incl.pl1 */ 7 2 /* format: style2,^inddcls,idind32 */ 7 3 7 4 declare 1 terminate_file_switches based, 7 5 2 truncate bit (1) unaligned, 7 6 2 set_bc bit (1) unaligned, 7 7 2 terminate bit (1) unaligned, 7 8 2 force_write bit (1) unaligned, 7 9 2 delete bit (1) unaligned; 7 10 7 11 declare TERM_FILE_TRUNC bit (1) internal static options (constant) initial ("1"b); 7 12 declare TERM_FILE_BC bit (2) internal static options (constant) initial ("01"b); 7 13 declare TERM_FILE_TRUNC_BC bit (2) internal static options (constant) initial ("11"b); 7 14 declare TERM_FILE_TERM bit (3) internal static options (constant) initial ("001"b); 7 15 declare TERM_FILE_TRUNC_BC_TERM bit (3) internal static options (constant) initial ("111"b); 7 16 declare TERM_FILE_FORCE_WRITE bit (4) internal static options (constant) initial ("0001"b); 7 17 declare TERM_FILE_DELETE bit (5) internal static options (constant) initial ("00001"b); 7 18 7 19 /* END INCLUDE FILE ... terminate_file.incl.pl1 */ 1167 1168 1169 end le_create_list_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 12/10/86 1251.4 le_create_list_.pl1 >special_ldd>install>MR12.0-1241>le_create_list_.pl1 780 1 11/26/79 1320.6 op_mnemonic_format.incl.pl1 >ldd>include>op_mnemonic_format.incl.pl1 1162 2 04/11/85 1452.6 access_mode_values.incl.pl1 >ldd>include>access_mode_values.incl.pl1 1163 3 11/24/86 1226.9 definition_dcls.incl.pl1 >ldd>include>definition_dcls.incl.pl1 1164 4 12/10/86 1248.4 le_data.incl.pl1 >special_ldd>install>MR12.0-1241>le_data.incl.pl1 1165 5 11/24/86 1226.9 object_link_dcls.incl.pl1 >ldd>include>object_link_dcls.incl.pl1 1166 6 05/06/74 1751.6 std_symbol_header.incl.pl1 >ldd>include>std_symbol_header.incl.pl1 1167 7 04/06/83 1239.4 terminate_file.incl.pl1 >ldd>include>terminate_file.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. FAULT_TAG_2 constant bit(6) initial unaligned dcl 5-101 ref 572 LE_ABORT_ERROR 000202 constant fixed bin(17,0) initial dcl 4-22 set ref 160* 760* LE_ERROR 000204 constant fixed bin(17,0) initial dcl 4-20 set ref 154* NL 011405 constant char(1) initial unaligned dcl 39 ref 264 269 270 270 276 283 285 287 306 318 323 328 330 336 337 482 482 483 504 504 506 506 507 515 650 829 829 842 843 843 864 1036 RW_ACCESS 000121 constant bit(3) initial unaligned dcl 2-11 set ref 150* SYMBOLIC_SECTION_NAMES 000103 constant char(8) initial array unaligned dcl 3-38 ref 741 751 TERM_FILE_TRUNC_BC_TERM 000102 constant bit(3) initial unaligned dcl 7-15 set ref 171* acc based structure level 1 dcl 403 accp 000100 automatic pointer dcl 425 set ref 502* 507 514* 515 525* 526 addcharno builtin function dcl 128 ref 252 455 985 addr 000106 automatic varying char(12) dcl 825 in procedure "print_links" set ref 852* 853 addr builtin function dcl 129 in procedure "le_create_list_" ref 275 340 577 577 1132 1139 1146 1147 addr 000101 automatic varying char(20) dcl 627 in procedure "print_defs" set ref 654* 656* 660* 660 661* 661 662 addrel builtin function dcl 130 ref 357 475 480 487 502 514 525 536 553 571 735 736 737 738 739 b 000456 automatic fixed bin(17,0) dcl 228 in procedure "generate_map" set ref 290* 293 297 299 301 303 305 312 312 314 315 316 317 318* b 000122 automatic fixed bin(17,0) dcl 435 in procedure "generate_list" set ref 562* 563 564 575* bc 4 based fixed bin(24,0) array level 3 in structure "leb" dcl 209 in procedure "generate_map" ref 312 312 bc parameter fixed bin(24,0) dcl 967 in procedure "append" set ref 948 986* 986 bc parameter fixed bin(24,0) dcl 200 in procedure "generate_map" set ref 180 252 257* 264* 265* 266* 269* 270* 276* 283* 285* 287* 294* 296* 298* 300* 302* 304* 306* 308* 310* 312* 314* 315* 316* 317* 318* 323* 325* 327* 328* 330* 366* bc parameter fixed bin(24,0) dcl 615 in procedure "print_defs" set ref 594 650* 666* 670* 672* 676* 678* bc parameter fixed bin(24,0) dcl 810 in procedure "print_links" set ref 789 829* 842* 843* 850* 854* 861* 864* bc 000100 automatic fixed bin(24,0) dcl 114 in procedure "le_create_list_" set ref 150* 165* 167* 168* 171* bc parameter fixed bin(24,0) dcl 397 in procedure "generate_list" set ref 377 455 482* 483* 498* 504* 506* 507* 515* 557* 583* binary 2 based structure array level 2 in structure "leb" dcl 209 in procedure "generate_map" binary 2 based structure array level 2 in structure "leb" dcl 410 in procedure "generate_list" binary 2 based structure array level 2 in structure "le_binaries" dcl 4-260 in procedure "le_create_list_" c 000525 automatic fixed bin(17,0) dcl 247 set ref 274* 275* 339* 340* char builtin function dcl 131 ref 294 482 654 842 848 860 class 1(33) based fixed bin(3,0) level 2 packed unsigned unaligned dcl 409 ref 490 549 cleanup 000000 stack reference condition dcl 124 ref 447 clock builtin function dcl 132 ref 266 266 col parameter fixed bin(17,0) dcl 968 in procedure "append" set ref 948 980* col 000102 automatic fixed bin(17,0) dcl 426 in procedure "generate_list" set ref 456* 482* 483* 498* 504* 506* 507* 515* 557* 583* col parameter fixed bin(17,0) dcl 616 in procedure "print_defs" set ref 594 650* 666* 670* 672* 676* 678* col parameter fixed bin(17,0) dcl 811 in procedure "print_links" set ref 789 829* 842* 843* 850* 854* 861* 864* col 000526 automatic fixed bin(17,0) dcl 248 in procedure "generate_map" set ref 253* 257* 264* 265* 266* 269* 270* 276* 283* 285* 287* 294* 296* 298* 300* 302* 304* 306* 308* 310* 312* 314* 315* 316* 317* 318* 323* 325* 327* 328* 330* 366* col parameter fixed bin(17,0) dcl 1012 in procedure "tabin" set ref 995 1037* 1039* 1039 1053 1054* 1054 1058 1060 1067 1067 comp 21 based fixed bin(18,0) array level 3 in structure "ll" packed unsigned unaligned dcl 415 in procedure "generate_list" set ref 575* comp based structure level 1 dcl 213 in procedure "generate_map" comp 21 based fixed bin(18,0) array level 3 in structure "ll" packed unsigned unaligned dcl 815 in procedure "print_links" set ref 848 comp 11(18) based fixed bin(9,0) array level 3 in structure "dl" packed unsigned unaligned dcl 620 in procedure "print_defs" set ref 654 comp 2 based structure array level 2 in structure "lec" dcl 206 in procedure "generate_map" set ref 275 340 comp 11(18) based fixed bin(9,0) array level 3 in structure "dl" packed unsigned unaligned dcl 406 in procedure "generate_list" set ref 537* 546* comp 000101 automatic varying char(5) dcl 823 in procedure "print_links" set ref 848* 849 849 comp_info 000457 automatic structure level 1 dcl 229 set ref 333* 366 366 comp_pic 000455 automatic picture(3) unaligned dcl 227 set ref 293* 294 353* 354 compiler 101 based char(8) level 2 in structure "comp" dcl 213 in procedure "generate_map" ref 346 compiler 10(09) 000457 automatic char(8) level 2 in structure "comp_info" packed unaligned dcl 229 in procedure "generate_map" set ref 346* component 0(03) based fixed bin(15,0) level 2 packed unsigned unaligned dcl 420 ref 537 compp 000242 automatic pointOp.forum NUZ&,cFI[,,ra$CADAM.mls ,cFI:GQ$JRra9Rr*@,cFJ*@,cF$&I bbraZTIMESHEETS I Ÿzra~2r9r**Z&I raIRIS_TeleUse.forum )>udd>m>Flegel>meetings>IRIS_TeleUse.forum9teleuse.forum X&BPd$rats11/15/92 BPyGLA$ra9*@Br*@B0&FI?"raCAD.mls FI?>sG$ (ra9(r*@F *@FH~ IH<%8xrax0brational_system_support.forum ~ ->site>forum_dir>rational_system_support.forum980rational.forum ~ p&KD2raVclassdesc.mail KFGQ$ra ^9r*@*@  &LCrass09/30/93 LG l$ 0 (rag9r*@3**@3*(0&Irapsecret.mail I:GL2$ raE9 r*@*@^&`IgG00ra(train_ssdrs.mail `IgtiGw&$NVra 9Vr*@`N*@`(&-Iu~ffra^iTrain.mail -Iw4G`H$ra9r*@-*@-^&FIra2ts11/30/92 FI1GL$ra&89*@Fr*@F&FIra6ss11/30/92 FI1G`H$raOo9*@Fr*@F&LI3ranaming.mail LIGO$.&ra'9.*@L&r*@L:l&}qJe>>ra6Dsei_training.trans }qJG$d\ra 9d*@}q\r*@}q6&}JTttralss03/31/93 }JG`H$raY}9*@}r*@}H&Jrrats02/15/93 JrZGQ$ra9*@r*@&_Iprastats1 _IGw$ra @9ay level 2 in structure "dl" dcl 620 in procedure "print_defs" set ref 638 639* 639 640* def_list based structure level 1 unaligned dcl 87 def_list_relp based fixed bin(18,0) level 2 packed unsigned unaligned dcl 3-58 ref 475 487 definition based structure level 1 dcl 3-72 definition_flags based structure level 1 packed unaligned dcl 3-42 definition_header based structure level 1 dcl 3-58 defnl 24(18) based fixed bin(18,0) array level 3 packed unsigned unaligned dcl 209 ref 315 defnp 14 based pointer array level 3 in structure "leb" dcl 209 in procedure "generate_map" ref 299 defnp 14 based pointer array level 3 in structure "leb" dcl 410 in procedure "generate_list" ref 466 469 564 defnp 000104 automatic pointer dcl 427 in procedure "generate_list" set ref 466* 469* 475 475 480 487 487 502 514 525 553 defp 000110 automatic pointer dcl 429 set ref 475* 475* 478* 480 487* 487* 490 490 502 504 504 514 518 525 528 536 548 549 551* 553 dhp parameter pointer dcl 709 in procedure "get_link_info" ref 691 735 736 737 738 739 dhp 000126 automatic pointer dcl 438 in procedure "generate_list" set ref 564* 577* digit based fixed bin(3,0) array unsigned unaligned dcl 1110 ref 1132 1139 1146 1147 divide builtin function dcl 134 ref 252 312 312 455 633 831 1053 dl based structure level 1 dcl 620 in procedure "print_defs" dl based structure level 1 dcl 406 in procedure "generate_list" dl_entry based structure level 1 dcl 91 ref 629 634 634 641 641 dlp parameter pointer dcl 612 set ref 594 633 634* 634 637 638 639 639 640 641* 646 654 660 661 670 670 670 672 672 676 678 682 dn 000320 automatic char(168) unaligned dcl 220 set ref 259* 260 260 262 dname parameter char unaligned dcl 48 ref 15 dnl 000372 automatic fixed bin(17,0) dcl 221 set ref 259* 260 260 262 dtcm 000532 automatic fixed bin(71,0) dcl 250 in procedure "generate_map" set ref 358* 359* dtcm 25(09) 000457 automatic char(36) level 2 in structure "comp_info" packed unaligned dcl 229 in procedure "generate_map" set ref 359* ec 000403 automatic fixed bin(35,0) dcl 223 in procedure "generate_map" set ref 259* ec 000102 automatic fixed bin(35,0) dcl 116 in procedure "le_create_list_" set ref 149* 150* 152 154* 159* 171* 453* 585* en 000373 automatic char(32) unaligned dcl 222 set ref 259* 260* ename parameter char unaligned dcl 49 set ref 15 149* entry 1(20) based bit(1) level 3 in structure "def" packed unaligned dcl 409 in procedure "generate_list" ref 551 entry 1 based bit array level 2 in structure "heap" dcl 899 in procedure "adjust_heap" set ref 918 918 920 921* 921 922* 927 927 927 927 930 930 934 935* 935 936* entrypoint 11(30) based bit(1) array level 4 in structure "dl" packed unaligned dcl 406 in procedure "generate_list" set ref 551* entrypoint 11(30) based bit(1) array level 4 in structure "dl" packed unaligned dcl 620 in procedure "print_defs" set ref 670 678 exp based structure level 1 dcl 717 exp_word based structure level 1 dcl 3-129 expand_pathname_$add_suffix 000040 constant entry external dcl 73 ref 149 expp 000156 automatic pointer dcl 728 set ref 735* 736 763 763 expression 0(18) based fixed bin(17,0) level 2 packed unaligned dcl 717 ref 763 763 expression_relp 1 based fixed bin(18,0) level 2 packed unsigned unaligned dcl 714 ref 735 false constant bit(1) initial unaligned dcl 37 ref 460 547 1121 1128 1147 first 000312 automatic fixed bin(17,0) dcl 1019 set ref 1029* 1030 1030* 1032* 1032 1034 1036 1039 1041 1042 1043 1048* 1049 1049* 1051* 1051 1054 1055 1056 1070 first_ref_relp 1(18) based fixed bin(18,0) level 2 packed unsigned unaligned dcl 419 ref 566 566 first_relp 2(18) based fixed bin(18,0) level 2 packed unsigned unaligned dcl 418 ref 504 fixed builtin function dcl 135 ref 297 299 301 303 305 765 fixed_addr 000112 automatic char(12) unaligned dcl 826 in procedure "print_links" set ref 853* 854 fixed_addr 000107 automatic char(20) unaligned dcl 628 in procedure "print_defs" set ref 662* 666 fixed_comp 000104 automatic char(5) unaligned dcl 824 set ref 849* 849 850 flags 11(30) based structure array level 3 in structure "dl" packed unaligned dcl 406 in procedure "generate_list" flags 11(30) based structure array level 3 in structure "dl" packed unaligned dcl 620 in procedure "print_defs" flags 1(18) based structure level 2 in structure "def" packed unaligned dcl 409 in procedure "generate_list" flags 104 based structure level 2 in structure "comp" dcl 213 in procedure "generate_map" forward_relp based fixed bin(18,0) level 2 in structure "def" packed unsigned unaligned dcl 409 in procedure "generate_list" ref 480 553 forward_relp based fixed bin(18,0) level 2 in structure "sn" packed unsigned unaligned dcl 418 in procedure "generate_list" ref 504 get_shortest_path_ 000012 constant entry external dcl 56 ref 276 get_temp_segment_ 000014 constant entry external dcl 57 ref 453 hcs_$fs_get_path_name 000034 constant entry external dcl 70 ref 259 hcs_$get_uid_seg 000016 constant entry external dcl 58 ref 159 header based structure level 2 in structure "le_components" dcl 4-72 in procedure "le_create_list_" header based structure level 2 in structure "le_binaries" dcl 4-260 in procedure "le_create_list_" header based structure level 2 in structure "lec" dcl 206 in procedure "generate_map" header based structure level 2 in structure "leb" dcl 410 in procedure "generate_list" header based structure level 2 in structure "leb" dcl 209 in procedure "generate_map" heap based structure level 1 dcl 899 heapp parameter pointer dcl 892 set ref 874 918 918 920 921 921 922 927 927 927 927 930 930 934 935 935 936 937* i 000100 automatic fixed bin(17,0) dcl 626 in procedure "print_defs" set ref 633* 634* 637* 638 639 641* 646* 654 660 661 670 670 670 672 672 676 678* i 000100 automatic fixed bin(17,0) dcl 822 in procedure "print_links" set ref 831* 832* 835* 836 837 839* 845* 848 852 854 856 858 860* ignore 1(19) based bit(1) level 3 packed unaligned dcl 409 ref 478 490 518 include 104(01) based bit(1) level 3 packed unaligned dcl 213 ref 276 342 index builtin function dcl 136 ref 1029 1036 indirect 11(31) based bit(1) array level 4 in structure "dl" packed unaligned dcl 620 in procedure "print_defs" set ref 670 676 indirect 11(31) based bit(1) array level 4 in structure "dl" packed unaligned dcl 406 in procedure "generate_list" set ref 535* 547* indirect 1(24) based bit(1) level 3 in structure "def" packed unaligned dcl 409 in procedure "generate_list" ref 528 init 000115 automatic varying char(64) dcl 827 in procedure "print_links" set ref 858* 859* 859 860* 860 861* init based structure level 1 dcl 716 in procedure "get_link_info" init_length 22(18) based fixed bin(18,0) array level 3 in structure "ll" packed unsigned unaligned dcl 815 in procedure "print_links" set ref 860 init_length 21(18) based fixed bin(18,0) level 2 in structure "le" packed unsigned unaligned dcl 715 in procedure "get_link_info" set ref 773* 777* init_offset 22 based fixed bin(18,0) array level 3 in structure "ll" packed unsigned unaligned dcl 815 in procedure "print_links" set ref 856 858 init_offset 21 based fixed bin(18,0) level 2 in structure "le" packed unsigned unaligned dcl 715 in procedure "get_link_info" set ref 772* 776* initiate_file_$create 000020 constant entry external dcl 59 ref 150 initp 000166 automatic pointer dcl 732 set ref 739* 773 l 000100 automatic fixed bin(17,0) dcl 905 in procedure "adjust_heap" set ref 910* 911 913 918 920 921 927 930 930 l 000123 automatic fixed bin(17,0) dcl 436 in procedure "generate_list" set ref 574* 575 576 577 577 last parameter fixed bin(17,0) dcl 894 set ref 874 913 916 937* le based structure level 1 dcl 715 le_binaries based structure level 1 dcl 4-260 le_comp based structure level 1 dcl 4-89 le_components based structure level 1 dcl 4-72 le_data_$caller 000042 external static varying char(32) dcl 79 ref 449 453 585 le_definition based structure level 1 dcl 4-175 le_error_ 000022 constant entry external dcl 62 ref 154 160 760 le_et_$implementation_error 000044 external static fixed bin(35,0) dcl 80 set ref 760* le_et_$input_output_overlap 000046 external static fixed bin(35,0) dcl 82 set ref 160* le_link based structure level 1 dcl 4-233 le_patch based structure level 1 dcl 4-298 le_util_$check_uid 000024 constant entry external dcl 63 ref 160 le_util_$get_user_and_version 000026 constant entry external dcl 65 ref 268 leb based structure level 1 dcl 209 in procedure "generate_map" leb based structure level 1 dcl 410 in procedure "generate_list" lebp parameter pointer dcl 47 in procedure "le_create_list_" set ref 15 160* 167* 168* lebp parameter pointer dcl 399 in procedure "generate_list" ref 377 458 466 467 469 562 563 564 lebp parameter pointer dcl 202 in procedure "generate_map" ref 180 259 260 283 290 291 297 299 301 303 305 308 312 312 314 315 316 317 318 325 351 357 lec based structure level 1 dcl 206 lecp parameter pointer dcl 398 in procedure "generate_list" ref 377 lecp parameter pointer dcl 46 in procedure "le_create_list_" set ref 15 160* 167* 168* lecp parameter pointer dcl 201 in procedure "generate_map" ref 180 274 275 339 340 left 000311 automatic fixed bin(17,0) dcl 1018 set ref 1026* 1028 1029 1030 1043* 1043 1046 1048 1049 1055* 1055 length 36(09) 000457 automatic char(7) level 2 in structure "comp_info" packed unaligned dcl 229 in procedure "generate_map" set ref 335* length builtin function dcl 137 in procedure "le_create_list_" ref 849 849 982 1026 lep parameter pointer dcl 710 ref 691 768 772 773 776 777 link_begin 6 based fixed bin(18,0) level 2 packed unsigned unaligned dcl 419 ref 565 link_init based structure level 1 dcl 3-205 link_list based structure level 1 dcl 101 linkage_section_lng 6(18) based fixed bin(18,0) level 2 packed unsigned unaligned dcl 419 ref 568 linkl 25 based fixed bin(18,0) array level 3 packed unsigned unaligned dcl 209 ref 316 linkp 16 based pointer array level 3 in structure "leb" dcl 410 in procedure "generate_list" ref 467 563 linkp 16 based pointer array level 3 in structure "leb" dcl 209 in procedure "generate_map" ref 301 linkp 000106 automatic pointer dcl 428 in procedure "generate_list" set ref 467* 536 list parameter bit(1) unaligned dcl 50 ref 15 168 listp parameter pointer dcl 396 in procedure "generate_list" ref 377 455 listp parameter pointer dcl 199 in procedure "generate_map" ref 180 252 listp 000104 automatic pointer dcl 117 in procedure "le_create_list_" set ref 150* 159* 167* 168* 171* lk 1 based structure array level 2 in structure "ll" dcl 415 in procedure "generate_list" set ref 577 577 lk based structure level 1 dcl 414 in procedure "generate_list" lk based structure level 1 dcl 714 in procedure "get_link_info" lk 1 based structure array level 2 in structure "ll" dcl 815 in procedure "print_links" set ref 836 837* 837 838* lk 1 based structure array level 2 in structure "link_list" dcl 101 in procedure "le_create_list_" lk_end 000131 automatic fixed bin(18,0) unsigned dcl 440 set ref 566* 568* 570 lk_start 000130 automatic fixed bin(18,0) unsigned dcl 439 set ref 565* 570 lkp 000134 automatic pointer dcl 442 in procedure "generate_list" set ref 571* 572 577* lkp parameter pointer dcl 708 in procedure "get_link_info" set ref 691 735 760* 765 765 ll based structure level 1 dcl 815 in procedure "print_links" ll based structure level 1 dcl 415 in procedure "generate_list" ll_entry based structure level 1 dcl 105 ref 821 832 832 839 839 llp parameter pointer dcl 807 set ref 789 831 832* 832 835 836 837 837 838 839* 842 845 848 852 854 856 858 860 ltrim builtin function dcl 138 ref 482 654 842 848 860 modifier 1(30) based bit(6) level 2 in structure "lk" packed unaligned dcl 714 in procedure "get_link_info" ref 765 765 modifier 000002 constant char(3) initial array dcl 1-11 in procedure "get_link_info" ref 765 msf_sw parameter bit(1) unaligned dcl 808 in procedure "print_links" ref 789 846 msf_sw parameter bit(1) unaligned dcl 613 in procedure "print_defs" ref 594 654 msf_sw 000120 automatic bit(1) unaligned dcl 433 in procedure "generate_list" set ref 458* 460* 464 498* 557* 583* n_binaries based fixed bin(17,0) level 3 in structure "leb" dcl 410 in procedure "generate_list" ref 458 562 n_binaries based fixed bin(17,0) level 3 in structure "leb" dcl 209 in procedure "generate_map" ref 260 283 290 291 308 325 351 n_components 1 based fixed bin(17,0) level 3 dcl 206 ref 274 339 n_words based fixed bin(35,0) level 2 in structure "init" dcl 716 in procedure "get_link_info" ref 773 n_words parameter fixed bin(17,0) dcl 895 in procedure "adjust_heap" set ref 874 908 918 918 918 918 918 918 920 920 920 921 921 921 921 921 921 922 922 922 927 927 927 927 927 927 927 927 927 927 927 927 930 930 930 930 930 930 934 934 934 935 935 935 935 935 935 936 936 936 937* name 000457 automatic char(32) level 2 in structure "comp_info" packed unaligned dcl 229 in procedure "generate_map" set ref 345* name 1 based char(64) array level 3 in structure "ll" dcl 815 in procedure "print_links" set ref 854 name based char(64) level 2 in structure "le" dcl 715 in procedure "get_link_info" set ref 768* name 1 based char(32) array level 3 in structure "dl" dcl 620 in procedure "print_defs" set ref 670 672 672 name 1 based char(32) array level 3 in structure "dl" dcl 406 in procedure "generate_list" set ref 526* name 6 based varying char(32) level 2 in structure "comp" dcl 213 in procedure "generate_map" ref 345 name_relp 2 based fixed bin(18,0) level 2 packed unsigned unaligned dcl 409 ref 502 514 525 new 141 based structure level 2 in structure "comp" dcl 213 in procedure "generate_map" new 000101 automatic varying char(512) dcl 978 in procedure "append" set ref 980* 982 983 new parameter varying char dcl 1013 in procedure "tabin" set ref 995 1023* 1041* 1041 1061* 1061 1067* 1067 1070* 1070 new_dname 000106 automatic char(168) unaligned dcl 118 set ref 149* 150* new_ename 000160 automatic char(168) unaligned dcl 119 set ref 149* 150* 154* nl_1 22(18) 000457 automatic char(1) level 2 packed unaligned dcl 229 set ref 336* nl_2 45(09) 000457 automatic char(1) level 2 packed unaligned dcl 229 set ref 337* nlx 000314 automatic fixed bin(17,0) dcl 1021 set ref 1036* 1037 1037 nm 000170 automatic varying char(64) dcl 733 set ref 741* 743* 747* 749* 751* 756* 758* 763* 763 765* 765 768 null builtin function dcl 139 ref 445 449 object_created 6 based fixed bin(71,0) level 2 dcl 6-1 ref 358 object_link based structure level 1 dcl 5-28 octal 000000 constant char(1) initial array unaligned dcl 1099 ref 1146 offset 000132 automatic fixed bin(18,0) unsigned dcl 441 in procedure "generate_list" set ref 570* 571 576* offset 21(18) based fixed bin(18,0) array level 3 in structure "ll" packed unsigned unaligned dcl 415 in procedure "generate_list" set ref 576* offset 1 based fixed bin(18,0) level 2 in structure "plk" packed unsigned unaligned dcl 420 in procedure "generate_list" ref 538 offset 11 based fixed bin(18,0) array level 3 in structure "dl" packed unsigned unaligned dcl 406 in procedure "generate_list" set ref 538* 548* offset 21(18) based fixed bin(18,0) array level 3 in structure "ll" packed unsigned unaligned dcl 815 in procedure "print_links" set ref 852 offset 11 based fixed bin(18,0) array level 3 in structure "dl" packed unsigned unaligned dcl 620 in procedure "print_defs" set ref 661 offsetname based structure level 1 dcl 722 offsetname_relp 1(18) based fixed bin(18,0) level 2 packed unsigned unaligned dcl 718 ref 738 offsetnamep 000164 automatic pointer dcl 731 set ref 738* 747 749 751 756 758 old parameter varying char dcl 1011 ref 995 1026 1029 1036 1041 1048 orig 114 based structure level 2 dcl 213 overflow 000111 automatic bit(1) unaligned dcl 1116 set ref 1121* 1132* 1137 pad parameter char(1) unaligned dcl 1106 ref 1081 1124 1141 padding 000112 automatic bit(1) unaligned dcl 1117 set ref 1122* 1128* 1139 1147* partial_link based structure level 1 dcl 5-38 path 17 based varying char(194) level 2 dcl 213 ref 276 pathname_ 000036 constant entry external dcl 72 ref 260 plk based structure level 1 dcl 420 plkp 000112 automatic pointer dcl 430 set ref 536* 537 538 539 pn 000244 automatic char(168) unaligned dcl 218 set ref 260* 262* 264 r 000101 automatic fixed bin(17,0) dcl 906 set ref 911* 916 927 930 932 rel builtin function dcl 140 ref 297 299 301 303 305 rel_stat 142 based fixed bin(18,0) level 3 packed unsigned unaligned dcl 213 ref 361 rel_symb 141(18) based fixed bin(18,0) level 3 packed unsigned unaligned dcl 213 ref 357 362 rel_text 141 based fixed bin(18,0) level 3 packed unsigned unaligned dcl 213 ref 360 release_temp_segment_ 000030 constant entry external dcl 67 ref 449 585 reverse builtin function dcl 141 ref 1036 rtrim builtin function dcl 142 ref 264 269 270 276 482 654 672 672 741 751 842 848 854 860 scratchp 000114 automatic pointer dcl 431 set ref 445* 449 449* 453* 485 496 498 498* 500 524 524 526 535 537 538 539 546 547 548 549 551 557 557* 560 574 574 575 576 577 577 583* 585* section 11(27) based fixed bin(3,0) array level 3 in structure "dl" packed unsigned unaligned dcl 620 in procedure "print_defs" set ref 660 section 11(27) based fixed bin(3,0) array level 3 in structure "dl" packed unsigned unaligned dcl 406 in procedure "generate_list" set ref 539* 549* section_name 000122 constant char(4) initial array unaligned dcl 41 ref 660 segname based structure level 1 dcl 719 segname_definition based structure level 1 dcl 3-90 segname_relp 1 based fixed bin(18,0) level 2 packed unsigned unaligned dcl 718 ref 737 741 751 segnamep 000162 automatic pointer dcl 730 set ref 737* 743 747 747 749 756 756 758 segp 2 based pointer array level 3 dcl 209 set ref 259* side 000102 automatic fixed bin(17,0) dcl 907 set ref 930* 932* 934 935 937* size builtin function dcl 143 in procedure "le_create_list_" ref 629 634 634 641 641 821 832 832 839 839 size parameter fixed bin(17,0) dcl 1105 in procedure "oct" ref 1081 1124 1124 1130 1130 1141 sn based structure level 1 dcl 418 start 000310 automatic fixed bin(17,0) dcl 1017 in procedure "tabin" set ref 1025* 1029 1036 1041 1042* 1042 1048 1056* 1056 start 13(18) 000457 automatic char(7) level 2 in structure "comp_info" packed unaligned dcl 229 in procedure "generate_map" set ref 334* stat_length 41(27) 000457 automatic char(7) level 2 packed unaligned dcl 229 set ref 364* stat_start 17 000457 automatic char(7) level 2 packed unaligned dcl 229 set ref 361* statl 26 based fixed bin(18,0) array level 3 in structure "leb" packed unsigned unaligned dcl 209 in procedure "generate_map" ref 318 statl 135(18) based fixed bin(18,0) level 3 in structure "comp" packed unsigned unaligned dcl 213 in procedure "generate_map" ref 364 statp 22 based pointer array level 3 dcl 209 ref 305 std_symbol_header based structure level 1 dcl 6-1 str based char unaligned dcl 973 set ref 983* string 0(09) based char level 2 in structure "offsetname" packed unaligned dcl 722 in procedure "get_link_info" ref 747 749 751 756 758 string 0(09) based char level 2 in structure "acc" packed unaligned dcl 403 in procedure "generate_list" ref 507 515 526 string 0(09) based char level 2 in structure "segname" packed unaligned dcl 719 in procedure "get_link_info" ref 743 747 747 749 756 756 758 string 000100 automatic varying char(32) dcl 1115 in procedure "oct" set ref 1120* 1124* 1137* 1137 1141* 1141 1146* 1146 1153 string builtin function dcl 144 in procedure "le_create_list_" set ref 333* 366 366 strl 000100 automatic fixed bin(21,0) dcl 977 set ref 982* 983 985 986 strp parameter pointer dcl 809 in procedure "print_links" set ref 789 829* 842* 843* 850* 854* 861* 864* strp parameter pointer dcl 966 in procedure "append" set ref 948 983 985* 985 strp 000116 automatic pointer dcl 432 in procedure "generate_list" set ref 455* 482* 483* 498* 504* 506* 507* 515* 557* 583* strp 000316 automatic pointer dcl 219 in procedure "generate_map" set ref 252* 257* 264* 265* 266* 269* 270* 276* 283* 285* 287* 294* 296* 298* 300* 302* 304* 306* 308* 310* 312* 314* 315* 316* 317* 318* 323* 325* 327* 328* 330* 366* strp parameter pointer dcl 614 in procedure "print_defs" set ref 594 650* 666* 670* 672* 676* 678* substr builtin function dcl 145 ref 260 260 262 1029 1036 1041 1048 symb_length 43(18) 000457 automatic char(7) level 2 packed unaligned dcl 229 set ref 365* symb_start 20(27) 000457 automatic char(7) level 2 packed unaligned dcl 229 set ref 362* symbl 25(18) based fixed bin(18,0) array level 3 in structure "leb" packed unsigned unaligned dcl 209 in procedure "generate_map" ref 317 symbl 136 based fixed bin(18,0) level 3 in structure "comp" packed unsigned unaligned dcl 213 in procedure "generate_map" ref 365 symbolp 000530 automatic pointer dcl 249 set ref 357* 358 symbp 20 based pointer array level 3 dcl 209 ref 303 357 tab_col 000313 automatic fixed bin(17,0) dcl 1020 set ref 1053* 1058 1060 1062* 1062 1065* 1065 1067 1067 tag 0(30) based bit(6) level 2 packed unaligned dcl 414 ref 572 target 103 based fixed bin(17,0) level 2 in structure "comp" dcl 213 in procedure "generate_map" ref 353 357 target 12(27) 000457 automatic char(3) level 2 in structure "comp_info" packed unaligned dcl 229 in procedure "generate_map" set ref 354* 356* temp 000100 automatic fixed bin(35,0) array dcl 821 in procedure "print_links" set ref 836* 838 temp 000114 automatic fixed bin(35,0) array dcl 629 in procedure "print_defs" set ref 638* 640 temp 000103 automatic bit unaligned dcl 908 in procedure "adjust_heap" set ref 920* 922 934* 936 terminate_file_ 000032 constant entry external dcl 68 ref 171 text parameter varying char dcl 969 set ref 948 980* text_length 40 000457 automatic char(7) level 2 packed unaligned dcl 229 set ref 363* text_start 15(09) 000457 automatic char(7) level 2 packed unaligned dcl 229 set ref 360* textl 134 based fixed bin(18,0) level 3 in structure "comp" packed unsigned unaligned dcl 213 in procedure "generate_map" ref 363 textl 24 based fixed bin(18,0) array level 3 in structure "leb" packed unsigned unaligned dcl 209 in procedure "generate_map" ref 314 textp 12 based pointer array level 3 dcl 209 ref 297 thing_relp 1 based fixed bin(18,0) level 2 packed unsigned unaligned dcl 409 ref 536 548 top parameter fixed bin(17,0) dcl 893 ref 874 910 918 921 922 927 927 935 936 tp based structure level 1 dcl 718 tpp 000160 automatic pointer dcl 729 set ref 736* 737 738 739 741 741 743 745 751 751 754 760 770 770 770 772 trap_relp 0(18) based fixed bin(18,0) level 2 packed unsigned unaligned dcl 718 ref 739 770 772 true constant bit(1) initial unaligned dcl 36 ref 458 535 1122 1132 type based fixed bin(18,0) level 2 in structure "tp" packed unsigned unaligned dcl 718 in procedure "get_link_info" set ref 741 743 745 751 754 760* 770 770 type based fixed bin(3,0) level 2 in structure "plk" packed unsigned unaligned dcl 420 in procedure "generate_list" ref 539 type_pair based structure level 1 dcl 3-160 type_relp based fixed bin(18,0) level 2 packed unsigned unaligned dcl 717 ref 736 uid 000232 automatic bit(36) dcl 120 set ref 159* 160* unique_path 104(05) based bit(1) level 3 packed unaligned dcl 213 ref 276 unspec builtin function dcl 146 set ref 638* 638 639* 639 640* 640 836* 836 837* 837 838* 838 user 000404 automatic char(32) unaligned dcl 224 set ref 268* 269 value 000454 automatic fixed bin(35,0) dcl 226 in procedure "generate_map" set ref 297* 298* 299* 300* 301* 302* 303* 304* 305* 306* value parameter fixed bin(35,0) dcl 1104 in procedure "oct" set ref 1081 1132 1139 1146 1147 verify builtin function dcl 147 ref 1048 version 000414 automatic char(128) unaligned dcl 225 set ref 268* 270 virgin_linkage_header based structure level 1 dcl 5-71 vlh based structure level 1 dcl 419 vlhp 000124 automatic pointer dcl 437 set ref 563* 565 566 566 568 571 word based fixed bin(35,0) dcl 421 ref 475 487 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. A_ACCESS internal static bit(3) initial unaligned dcl 2-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 CLASS_HEAP internal static fixed bin(3,0) initial unsigned dcl 3-25 CLASS_LINKAGE internal static fixed bin(3,0) initial unsigned dcl 3-25 CLASS_NAMES internal static char(12) initial array unaligned dcl 3-35 CLASS_SEGNAME internal static fixed bin(3,0) initial unsigned dcl 3-25 CLASS_STATIC internal static fixed bin(3,0) initial unsigned dcl 3-25 CLASS_SYMBOL internal static fixed bin(3,0) initial unsigned dcl 3-25 CLASS_SYSTEM internal static fixed bin(3,0) initial unsigned dcl 3-25 CLASS_TEXT internal static fixed bin(3,0) initial unsigned dcl 3-25 DIR_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 2-33 Definition internal static fixed bin(3,0) initial dcl 4-32 E_ACCESS internal static bit(3) initial unaligned dcl 2-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 FAULT_TAG_1 internal static bit(6) initial unaligned dcl 5-100 FAULT_TAG_3 internal static bit(6) initial unaligned dcl 5-102 FR_TRAPS_VERSION_1 internal static fixed bin(17,0) initial dcl 5-99 Heap internal static fixed bin(3,0) initial dcl 4-38 INIT_COPY_INFO internal static fixed bin(17,0) initial dcl 3-194 INIT_DEFERRED internal static fixed bin(17,0) initial dcl 3-194 INIT_DEFINE_AREA internal static fixed bin(17,0) initial dcl 3-194 INIT_LIST_TEMPLATE internal static fixed bin(17,0) initial dcl 3-194 INIT_NO_INIT internal static fixed bin(17,0) initial dcl 3-194 LE_FATAL_ERROR internal static fixed bin(17,0) initial dcl 4-21 LE_WARNING internal static fixed bin(17,0) initial dcl 4-19 LINK_CREATE_IF_NOT_FOUND internal static fixed bin(18,0) initial unsigned unaligned dcl 3-134 LINK_OBSOLETE_2 internal static fixed bin(18,0) initial unsigned unaligned dcl 3-134 LINK_REFNAME_BASE internal static fixed bin(18,0) initial unsigned unaligned dcl 3-134 LINK_REFNAME_OFFSETNAME internal static fixed bin(18,0) initial unsigned unaligned dcl 3-134 LINK_SELF_BASE internal static fixed bin(18,0) initial unsigned unaligned dcl 3-134 LINK_SELF_OFFSETNAME internal static fixed bin(18,0) initial unsigned unaligned dcl 3-134 LINK_TYPE_NAMES internal static varying char(32) initial array dcl 3-153 Linkage internal static fixed bin(3,0) initial dcl 4-28 M_ACCESS internal static bit(3) initial unaligned dcl 2-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 N_ACCESS internal static bit(3) initial unaligned dcl 2-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 Patch_Init internal static fixed bin(17,0) initial dcl 4-59 Patch_Link internal static fixed bin(17,0) initial dcl 4-58 Patch_Self_Init internal static fixed bin(17,0) initial dcl 4-61 Patch_Symbol_Ref internal static fixed bin(17,0) initial dcl 4-60 REW_ACCESS internal static bit(3) initial unaligned dcl 2-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 RE_ACCESS internal static bit(3) initial unaligned dcl 2-11 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 RW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 R_ACCESS internal static bit(3) initial unaligned dcl 2-11 R_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 Refname_Base internal static fixed bin(3,0) initial dcl 4-49 Refname_Offsetname internal static fixed bin(3,0) initial dcl 4-51 SA_ACCESS internal static bit(3) initial unaligned dcl 2-11 SA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 SECTION_HEAP internal static fixed bin(18,0) initial unsigned unaligned dcl 3-134 SECTION_LINK internal static fixed bin(18,0) initial unsigned unaligned dcl 3-134 SECTION_STATIC internal static fixed bin(18,0) initial unsigned unaligned dcl 3-134 SECTION_SYMBOL internal static fixed bin(18,0) initial unsigned unaligned dcl 3-134 SECTION_SYSTEM internal static fixed bin(18,0) initial unsigned unaligned dcl 3-134 SECTION_TEXT internal static fixed bin(18,0) initial unsigned unaligned dcl 3-134 SECTION_UNUSED internal static fixed bin(18,0) initial unsigned unaligned dcl 3-134 SEG_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 2-30 SMA_ACCESS internal static bit(3) initial unaligned dcl 2-11 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 SM_ACCESS internal static bit(3) initial unaligned dcl 2-11 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 S_ACCESS internal static bit(3) initial unaligned dcl 2-11 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 Self_Base internal static fixed bin(3,0) initial dcl 4-47 Self_Offsetname internal static fixed bin(3,0) initial dcl 4-53 Static internal static fixed bin(3,0) initial dcl 4-34 Symbol internal static fixed bin(3,0) initial dcl 4-30 System internal static fixed bin(3,0) initial dcl 4-36 TERM_FILE_BC internal static bit(2) initial unaligned dcl 7-12 TERM_FILE_DELETE internal static bit(5) initial unaligned dcl 7-17 TERM_FILE_FORCE_WRITE internal static bit(4) initial unaligned dcl 7-16 TERM_FILE_TERM internal static bit(3) initial unaligned dcl 7-14 TERM_FILE_TRUNC internal static bit(1) initial unaligned dcl 7-11 TERM_FILE_TRUNC_BC internal static bit(2) initial unaligned dcl 7-13 Text internal static fixed bin(3,0) initial dcl 4-26 W_ACCESS internal static bit(3) initial unaligned dcl 2-11 W_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 acc_string based structure level 1 dcl 3-327 acc_string_length automatic fixed bin(21,0) dcl 3-334 acc_string_ptr automatic pointer dcl 3-326 comp_ht_n_entries automatic fixed bin(17,0) dcl 3-297 comp_ht_ptr automatic pointer dcl 3-288 component_ht based structure level 1 dcl 3-289 def_count automatic fixed bin(17,0) dcl 4-173 def_header_ptr automatic pointer dcl 3-57 def_ht_n_entries automatic fixed bin(17,0) dcl 3-284 def_ht_ptr automatic pointer dcl 3-277 def_ptr automatic pointer dcl 3-71 definition_ht based structure level 1 dcl 3-278 dup_table_n_names automatic fixed bin(17,0) dcl 3-310 dup_table_ptr automatic pointer dcl 3-301 duplicate_table based structure level 1 dcl 3-302 exp_ptr automatic pointer dcl 3-128 fr_traps based structure level 1 dcl 5-90 le_definitions based structure level 1 dcl 4-167 le_links based structure level 1 dcl 4-225 le_options based structure level 1 dcl 4-202 le_patches based structure level 1 dcl 4-293 le_segnames based structure level 1 dcl 4-149 link_count automatic fixed bin(17,0) dcl 4-231 link_init_copy_info based structure level 1 dcl 3-211 link_init_deferred based structure level 1 dcl 3-270 link_init_list_template based structure level 1 dcl 3-219 link_init_n_bits_in_datum automatic fixed bin(35,0) dcl 3-261 link_init_n_words automatic fixed bin(17,0) dcl 3-215 link_init_n_words_in_list automatic fixed bin(17,0) dcl 3-226 link_init_ptr automatic pointer dcl 3-204 link_trap_pair based structure level 1 dcl 3-177 link_trap_ptr automatic pointer dcl 3-176 linkage_header based structure level 1 dcl 5-50 linkage_header_flags based structure level 1 dcl 5-63 list_template_entry based structure level 1 dcl 3-239 msf_map based structure level 1 dcl 3-318 msf_map_ptr automatic pointer dcl 3-317 msf_map_version_1 internal static char(8) initial unaligned dcl 3-323 op_mnemonic_$op_mnemonic external static structure array level 1 dcl 1-5 pointer_init_template based structure level 1 packed unaligned dcl 3-253 section_nm internal static char(16) initial array unaligned dcl 4-41 segname_count automatic fixed bin(17,0) dcl 4-156 segname_ptr automatic pointer dcl 3-89 terminate_file_switches based structure level 1 packed unaligned dcl 7-4 type_ptr automatic pointer dcl 3-159 NAMES DECLARED BY EXPLICIT CONTEXT. adjust_heap 010443 constant entry internal dcl 874 ref 634 641 832 839 937 append 010660 constant entry internal dcl 948 ref 257 264 265 266 269 270 276 283 285 287 294 296 298 300 302 304 306 308 310 312 314 315 316 317 318 323 325 327 328 330 366 482 483 504 506 507 515 650 666 670 672 676 678 829 842 843 850 854 861 864 generate_list 004333 constant entry internal dcl 377 ref 168 generate_map 000740 constant entry internal dcl 180 ref 167 get_link_info 006464 constant entry internal dcl 691 ref 577 le_create_list_ 000425 constant entry external dcl 15 oct 011201 constant entry internal dcl 1081 ref 298 300 302 304 306 312 314 315 316 317 318 360 361 362 363 364 365 661 763 852 858 print_defs 005560 constant entry internal dcl 594 ref 498 557 print_links 007307 constant entry internal dcl 789 ref 583 tabin 010732 constant entry internal dcl 995 ref 980 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 11732 12002 11426 11742 Length 12372 11426 50 354 303 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME le_create_list_ 538 external procedure is an external procedure. generate_map P 8&OҜ  rats06/30/94 OEGA$0(ra90*@(r*@n&O9@@ra8 ss06/30/94 OEGQ $f^ra#9f*@^r*@8&MOvvran5cat.29jun94 MO`G2=$ra+j9*@Mr*@Mn&ݐO raPts071194 ݐO"G2$ras9*@ݐr*@ݐ&3jO08ra`ts07/15/94 3jO6 GQ$ra9*@3jr*@3jF&3ĶO]Brats07/31/94 3ĶO^y9G$>6rae9>*@3Ķ6r*@3Ķ|&3ĴO]NNraF ss07/31/94 3ĴO^y7G`Hp$tlra9t*@3Ĵlr*@3ĴF&QcOz.ra|ats08/15/94 QcO\G $ra9*@Qcr*@Qc|&QOÖra alfred QO eGL 5$ra9*@Qr*@Q&=yP֪rats08/31/94 =yPOG2 $ra9*@=yr*@=yT&=PT&&ra ss08/31/94 =PKGQ$LDra9L*@=Dr*@=HaWP-\raTACTC_Image_Discussion.forum aW:>udd>Multics>Maucieri>meetings>ACTC_Image_Discussion.forum9T&fڧP?raTelephone_Issues.forum fڧ&>site>forum_dir>Telephone_Issues.forum9 ~phone.forum fڧ&f&3Pcrabts09/15/94 f&3PsD1GL1$ra9*@f&3r*@f&3J&xP@ra6server xP7Gt$4,raS94*@x,r*@xOffice 9&;PRRraJss09/30/94 ;PG$xpra29x*@;pr*@;J&;P ra ts09/30/94 ;PG2$ra9*@;r*@;&bPYraact_codes.mail bPEGQv$ra5^9*@br*@b"&bVP/rac$ts10/15/94 le_create_list_ 000232 uid le_create_list_ 000242 compp generate_map 000244 pn generate_map 000316 strp generate_map 000320 dn generate_map 000372 dnl generate_map 000373 en generate_map 000403 ec generate_map 000404 user generate_map 000414 version generate_map 000454 value generate_map 000455 comp_pic generate_map 000456 b generate_map 000457 comp_info generate_map 000525 c generate_map 000526 col generate_map 000530 symbolp generate_map 000532 dtcm generate_map oct 000100 string oct 000111 overflow oct 000112 padding oct 000113 d oct print_defs 000100 i print_defs 000101 addr print_defs 000107 fixed_addr print_defs 000114 temp print_defs print_links 000100 temp print_links 000100 i print_links 000101 comp print_links 000104 fixed_comp print_links 000106 addr print_links 000112 fixed_addr print_links 000115 init print_links THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_char_temp realloc_char_temp cat_realloc_chars call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc call_int_other return_mac alloc_auto_adj enable_op shorten_stack ext_entry_desc int_entry int_entry_desc repeat set_chars_eis clock_mac THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. date_time_$format expand_pathname_$add_suffix get_shortest_path_ get_temp_segment_ hcs_$fs_get_path_name hcs_$get_uid_seg initiate_file_$create le_error_ le_util_$check_uid le_util_$get_user_and_version pathname_ release_temp_segment_ terminate_file_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. le_data_$caller le_et_$implementation_error le_et_$input_output_overlap LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 15 000420 149 000445 150 000477 152 000537 154 000541 156 000571 159 000572 160 000605 165 000652 167 000653 168 000670 171 000712 173 000737 180 000740 252 000742 253 000750 257 000752 259 001004 260 001042 262 001100 264 001105 265 001162 266 001215 268 001300 269 001315 270 001403 274 001502 275 001515 276 001523 279 001631 283 001634 285 001675 287 001725 290 001766 291 002001 293 002006 294 002016 296 002052 297 002104 298 002114 299 002201 300 002212 301 002277 302 002310 303 002375 304 002406 305 002473 306 002504 308 002571 310 002631 312 002662 314 002757 315 003055 316 003153 317 003251 318 003347 319 003445 323 003450 325 003511 327 003551 328 003602 330 003643 333 003705 334 003711 335 003714 336 003717 337 003721 339 003723 340 003735 342 003743 345 003746 346 003752 351 003755 353 003761 354 003771 355 003775 356 003776 357 004001 358 004013 359 004015 360 004055 361 004105 362 004135 363 004165 364 004215 365 004245 366 004275 368 004327 370 004331 377 004332 445 004340 447 004342 449 004356 451 004415 453 004417 455 004452 456 004462 458 004464 460 004473 464 004475 466 004500 467 004503 468 004505 469 004506 473 004511 475 004512 478 004522 480 004527 482 004535 483 004641 485 004704 487 004707 490 004716 496 004733 498 004735 500 004757 502 004760 504 004766 506 005043 507 005111 509 005161 514 005163 515 005170 516 005250 517 005251 518 005252 524 005254 525 005260 526 005265 528 005277 535 005303 536 005305 537 005312 538 005316 539 005321 540 005326 546 005327 547 005332 548 005334 549 005337 551 005344 553 005351 557 005357 560 005401 562 005402 563 005413 564 005421 565 005423 566 005426 568 005434 570 005437 571 005445 572 005450 574 005454 575 005460 576 005467 577 005472 579 005476 581 005500 583 005502 585 005522 587 005555 594 005557 629 005565 633 005571 634 005601 635 005622 637 005625 638 005635 639 005653 640 005657 641 005662 642 005706 646 005711 650 005723 654 005755 656 006062 660 006064 661 006130 662 006170 666 006174 670 006227 672 006275 676 006353 678 006415 680 006456 682 006460 684 006463 691 006464 735 006466 736 006476 737 006504 738 006512 739 006522 741 006530 743 006600 745 006626 747 006631 749 006656 750 006711 751 006713 754 006775 756 007000 758 007025 759 007060 760 007062 763 007117 765 007201 768 007250 770 007257 772 007274 773 007276 774 007300 776 007301 777 007303 782 007305 789 007306 821 007314 829 007320 831 007353 832 007363 833 007404 835 007407 836 007417 837 007435 838 007441 839 007444 840 007470 842 007473 843 007576 845 007646 846 007661 848 007667 849 007764 850 010011 852 010044 853 010116 854 010123 856 010214 858 010225 859 010270 860 010303 861 010360 864 010405 865 010437 867 010441 874 010442 908 010450 910 010462 911 010465 913 010467 916 010472 918 010475 920 010523 921 010527 922 010534 924 010540 927 010541 930 010603 932 010615 934 010617 935 010630 936 010634 937 010640 939 010656 948 010657 980 010673 982 010714 983 010716 985 010725 986 010727 988 010731 995 010732 1023 010750 1025 010753 1026 010755 1028 010760 1029 010762 1030 010776 1032 011002 1034 011004 1036 011006 1037 011017 1039 011022 1041 011024 1042 011037 1043 011041 1046 011043 1048 011045 1049 011060 1051 011064 1053 011066 1054 011074 1055 011076 1056 011100 1058 011102 1060 011105 1061 011112 1062 011122 1063 011124 1065 011125 1067 011127 1069 011153 1070 011155 1071 011175 1072 011176 1074 011177 1081 011200 1120 011206 1121 011207 1122 011210 1124 011212 1127 011235 1128 011243 1130 011245 1132 011254 1135 011267 1137 011270 1139 011302 1141 011320 1144 011332 1146 011333 1147 011343 1151 011346 1153 011350 ----------------------------------------------------------- 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