COMPILATION LISTING OF SEGMENT linkage_error_ Compiled by: Multics PL/I Compiler, Release 32f, of October 9, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 11/11/89 0957.3 mst Sat Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 13 14 15 /****^ HISTORY COMMENTS: 16* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7420), audit(86-11-12,Zwick), 17* install(86-11-20,MR12.0-1222): 18* special cased error code invalid_ptr_target to get a usefull message. 19* END HISTORY COMMENTS */ 20 21 22 linkage_error_: proc (mcptr, lngsw, lsp, sptr, pname1, pname2, optr, lng); 23 24 /* last modified by M. Weaver 21 August 1970 */ 25 /* last modified by M. Weaver 17 October 1973 */ 26 /* modified 10/76 by M. Weaver to improve messages for types 1 and 5 */ 27 /* modified 11/77 by M. Weaver to improve messages for ext variables and ec = bigger_ext_variable in particular */ 28 /* modified 21 Feb 80 JRDavis MCR 4347 remove red-shift */ 29 /* Modified 831006 BIM to change call from hcs_$set_ext_variable to just set_ext_variable_ */ 30 31 /* parameters */ 32 33 dcl mcptr ptr parameter; /* ptr to machine conditions */ 34 dcl lngsw fixed bin parameter; 35 dcl lsp ptr parameter; /* ptr to condition frame */ 36 dcl sptr ptr parameter; /* ptr to condition info structure */ 37 dcl (pname1, 38 pname2) char (500) aligned parameter; 39 dcl optr ptr parameter; /* ptr to output string */ 40 dcl lng fixed bin (17) parameter; 41 42 43 /* automatic */ 44 45 dcl (buf1, buf4) char (100) aligned automatic; 46 dcl (buf2, buf3) char (200) varying automatic; 47 dcl code fixed bin (35) automatic; 48 dcl def_section_ptr ptr automatic; /* ptr to defs */ 49 dcl dirname char (168) automatic; 50 dcl ec fixed bin (35) automatic; /* errcode from linker */ 51 dcl exp char (12) var automatic; /* value of expression */ 52 dcl entname char (32) automatic; 53 dcl ext_var_name char (65) automatic; 54 dcl ext_ptr ptr automatic; /* ptr to symbol */ 55 dcl found_sw bit (1) aligned automatic; 56 dcl header_ptr ptr automatic; /* ptr to linkage block header */ 57 dcl (i, tlng) fixed bin (17) automatic; 58 dcl linfo char (100) aligned 59 automatic; /* for convert_status_code_ */ 60 dcl link_ptr ptr automatic; /* pointer to link */ 61 dcl (n2, o2) varying char (32) 62 aligned automatic; /* printable names */ 63 dcl nchars fixed bin (17) automatic; /* number of chars in name */ 64 dcl nl char (1) aligned automatic; 65 dcl node_ptr ptr automatic; 66 dcl p ptr automatic; 67 dcl pname3 char (500) aligned automatic; 68 dcl segptr ptr automatic; /* ptr to seg name */ 69 dcl sinfo char (8) aligned automatic; 70 dcl type fixed bin (17) automatic; /* type of link */ 71 dcl texp char (12) aligned automatic; 72 73 /* constants */ 74 75 dcl New_line char (1) static options (constant) init (" 76 "); 77 78 79 /* external variables */ 80 81 dcl (error_table_$bad_link_type, 82 error_table_$no_ext_sym, 83 error_table_$bad_entry_point_name, 84 error_table_$bigger_ext_variable, 85 error_table_$bad_self_ref, 86 error_table_$invalid_ptr_target) ext fixed bin (35) aligned; 87 88 /* external entries */ 89 90 dcl get_ppr_ entry (fixed bin, ptr, ptr, 91 char (500) aligned, char (500) aligned, 92 char (500) aligned); 93 dcl (ioa_$rs, ioa_$rsnnl) ext entry options (variable); 94 dcl set_ext_variable_ entry (char (*), ptr, ptr, 95 bit (1) aligned, ptr, fixed bin (35)); 96 dcl hcs_$fs_get_path_name entry (ptr, char (*), fixed bin, char (*), 97 fixed bin (35)); 98 dcl convert_status_code_ ext entry (fixed bin (35), 99 char (8) aligned, char (100) aligned); 100 101 /* builtins */ 102 103 dcl (addr, addrel, baseptr, bin, fixed, index, 104 length, null, ptr, substr) builtin; 105 106 /* based */ 107 108 dcl ostring char (1000) aligned based (optr); 109 110 dcl 1 word based (p), /* access structure for pickup */ 111 2 (one, two) fixed bin (35); 112 113 dcl 1 init_info aligned based, 114 2 length fixed bin, 115 2 type fixed bin; 116 117 118 119 /* * * * * * * * * * * * * * * * * * * */ 120 121 122 linfo, nl, buf1, buf4 = " "; /* initialize */ 123 n2, o2, buf2, buf3 = ""; 124 code = 0; 125 126 scup = addr (mcptr -> mc.scu (0)); /* get ptr to scu; use real conditions */ 127 128 ec = mcptr -> mc.errcode; /* extract linker code */ 129 130 /* obtain ptr to link */ 131 132 link_ptr = ptr (baseptr (fixed (scup -> scu.tsr, 15)), scup -> scu.ca); 133 if ec = error_table_$bad_entry_point_name then do; 134 ugh: call ioa_$rsnnl ("^/Link is ^w ^w at ^p.", buf1, 135 tlng, link_ptr -> word.one, 136 link_ptr -> word.two, link_ptr); 137 go to exit; 138 end; 139 140 if link_ptr -> object_link.tag ^= FAULT_TAG_2 then 141 go to ugh; 142 143 /* get pointers to the information concerning the link. ie. 144* expression word, type_pair and link type 145**/ 146 147 header_ptr = addrel (link_ptr, link_ptr -> object_link.header_relp); 148 def_section_ptr = header_ptr -> linkage_header.def_ptr; 149 exp_ptr = addrel (def_section_ptr, link_ptr -> object_link.expression_relp); 150 type_ptr = addrel (def_section_ptr, exp_ptr -> exp_word.type_relp); 151 type = type_ptr -> type_pair.type; 152 153 if ec = error_table_$bad_link_type then do; 154 call ioa_$rsnnl ("^/Illegal type number in type pair block. Type = ^o.", buf1, tlng, type); 155 go to last_exit; 156 end; 157 158 159 /* check the trap information it is either a pointer to a trap or 160* it specifies the class information 161**/ 162 163 if type_ptr -> type_pair.trap_relp ^= 0 then 164 if type = LINK_CREATE_IF_NOT_FOUND then 165 call ioa_$rsnnl ("^/(with a create-if-not-found link)", buf1, tlng); 166 167 if exp_ptr -> exp_word.expression ^= 0 then do; 168 call ioa_$rsnnl ("^o", texp, tlng, exp_ptr -> exp_word.expression); 169 exp = substr (texp, 1, lng); 170 end; 171 else exp = ""; 172 173 /* get the symbolic name of the link */ 174 175 if (type = LINK_SELF_BASE) | (type = LINK_SELF_OFFSETNAME) then do; 176 if ec ^= error_table_$bad_self_ref 177 then n2 = SYMBOLIC_SECTION_NAMES (type_ptr -> type_pair.segname_relp); 178 else n2 = "*"; 179 if (type = LINK_SELF_OFFSETNAME) then 180 goto noent; 181 else goto noext; 182 end; 183 184 if (type = LINK_OBSOLETE_2) then do; /* ITB link? */ 185 if ec = error_table_$no_ext_sym then do; 186 call ioa_$rsnnl ("base ^o", n2, lng, 187 type_ptr -> type_pair.segname_relp); 188 go to noent; 189 end; 190 go to exit; 191 end; 192 193 /* get the link name information eg. either x$y or y or y|x */ 194 195 segptr = addrel (def_section_ptr, type_ptr -> type_pair.segname_relp); 196 nchars = bin (segptr -> acc_string.count, 9); 197 n2 = substr (segptr -> acc_string.string, 1, nchars); 198 if (type = LINK_REFNAME_BASE) then do; /* |exp,m ? */ 199 noext: if exp = "" then o2 = "0"; 200 else o2 = exp; 201 end; 202 else do; 203 noent: ext_ptr = addrel (def_section_ptr, type_ptr -> type_pair.offsetname_relp); 204 nchars = fixed (ext_ptr -> acc_string.count, 9); 205 if nchars = 0 then do; 206 if (type = LINK_CREATE_IF_NOT_FOUND) then 207 o2 = ""; 208 else o2 = "0"; 209 end; 210 else o2 = substr (ext_ptr -> acc_string.string, 1, nchars); 211 if exp ^= "" then o2 = o2 || "+" || exp; 212 end; 213 214 call ioa_$rsnnl ("^/referencing ^a|^a", buf2, tlng, n2, o2); 215 216 /* get information concerning the initialization information 217* of *system *heap or create if not found links 218* */ 219 220 if (type = LINK_SELF_OFFSETNAME) | 221 (type = LINK_CREATE_IF_NOT_FOUND) then do; 222 ext_var_name = " "; 223 if (type = LINK_SELF_OFFSETNAME) then do; 224 if (type_ptr -> type_pair.segname_relp = CLASS_SYSTEM) | 225 (type_ptr -> type_pair.segname_relp = CLASS_HEAP) 226 then ext_var_name = o2; 227 end; 228 else do; /* create if not found */ 229 if n2 = "stat_" then ext_var_name = o2; 230 else if o2 = "" then do; /* see if we have fortran common block */ 231 i = index (n2, ".com"); 232 if i = (length (n2) - 3) then do; 233 ext_var_name = substr (n2, 1, i - 1); 234 if ext_var_name = "b_" then ext_var_name = "blnk*com"; 235 end; 236 end; 237 else if n2 = "cobol_fsb_" then ext_var_name = n2 || o2; 238 239 if ext_var_name ^= " " then buf1 = " "; /* create-if-not-found now irrelevant */ 240 end; 241 242 if ext_var_name ^= " " 243 then buf2 = New_line || "referencing external variable or common block " || ext_var_name; 244 end; 245 246 if ec = error_table_$bigger_ext_variable then do; /* print out more useful information */ 247 call ioa_$rsnnl ("^a (^d words)", buf2, tlng, buf2, 248 addrel (def_section_ptr, type_ptr -> type_pair.trap_relp) 249 -> init_info.length); 250 251 buf4 = New_line || "Type ""help external_storage.gi"" for more information."; 252 253 call set_ext_variable_ (ext_var_name, null, 254 ptr (addr (node_ptr), 0), found_sw, node_ptr, code); 255 256 if code = 0 then if found_sw then do; 257 if node_ptr -> variable_node.init_ptr ^= null then do; 258 call hcs_$fs_get_path_name (ptr (node_ptr -> variable_node.init_ptr, 0), dirname, tlng, entname, code); 259 if code = 0 then call ioa_$rsnnl ("^/Original allocation (^d words) was by ^a>^a.", 260 buf3, tlng, node_ptr -> variable_node.init_ptr -> init_info.length, dirname, entname); 261 else call ioa_$rsnnl ("^/Original allocation was ^d words.", buf3, tlng, 262 node_ptr -> variable_node.init_ptr -> init_info.length); 263 end; 264 end; 265 end; 266 else if ec = error_table_$invalid_ptr_target then 267 do; 268 if ext_var_name ^= " " 269 then buf2 = New_line || "referencing external variable " || 270 ext_var_name; 271 buf3, buf4 = ""; 272 end; 273 274 275 exit: call convert_status_code_ (ec, sinfo, linfo); /* get message */ 276 nl = " 277 "; 278 279 last_exit: /* format the information */ 280 call get_ppr_ (lngsw, lsp, sptr, pname1, pname2, pname3); 281 call ioa_$rs ("Error: Linkage error by ^a^a^a^a^a^a^a^a", ostring, lng, pname1, pname2, buf2, buf1, nl, linfo, buf3, buf4); 282 283 return; /* default_error_handler_ will decide what to do with the string */ 284 285 286 /* INCLUDE FILES */ 287 1 1 /* BEGIN INCLUDE FILE object_link_dcls.incl.pl1 BIM 1981 from linkdcl */ 1 2 1 3 1 4 /****^ HISTORY COMMENTS: 1 5* 1) change(86-05-02,Elhard), approve(86-05-02,MCR7391), 1 6* audit(86-11-18,Schroth), install(86-11-20,MR12.0-1222): 1 7* Modified to add partial_link structure for an object MSF partially snapped 1 8* link. 1 9* 2) change(86-11-13,DGHowe), approve(86-11-13,MCR7391), audit(86-11-13,Zwick), 1 10* install(86-11-20,MR12.0-1222): 1 11* Added a declaration of FAULT_TAG_1, FAULT_TAG_2 and FAULT_TAG_3. 1 12* END HISTORY COMMENTS */ 1 13 1 14 1 15 /* format: style3 */ 1 16 /* everything you ever wanted in a linkage section */ 1 17 1 18 /* 1 19* Last Modified (Date and Reason): 1 20* 15 Nov 1971 by C Garman 1 21* 6/75 by M.Weaver to add virgin_linkage_header declaration 1 22* 6/75 by S.Webber to comment existing structures better 1 23* 9/77 by M. Weaver to add run_depth to link 1 24* 7/81 by B. Margulies for firstref structure, unsigned fixed bins. 1 25* 3/83 by M. Weaver to add flags overlaying def_ptr 1 26**/ 1 27 1 28 declare 1 object_link based aligned, /* link pair in linkage section */ 1 29 2 header_relp fixed bin (17) unal, /* rel pointer to beginning of linkage, always negative */ 1 30 2 ringno fixed bin (3) unsigned unal, /* MBZ */ 1 31 2 mbz bit (6) unal, 1 32 2 run_depth fixed bin (2) unal, /* run unit depth, filled when link is snapped */ 1 33 2 tag bit (6) unal, /* fault tag. 46(8) if not snapped, 43(8) if snapped */ 1 34 2 expression_relp fixed bin (18) unsigned unal, /* pointer (rel to defs) of expression word */ 1 35 2 mbz2 bit (12) unal, 1 36 2 modifier bit (6) unal; /* modifier to be left in snapped link */ 1 37 1 38 declare 1 partial_link based aligned, /* partially snapped link */ 1 39 2 type fixed bin (3) unsigned unal, /* target section of link */ 1 40 2 component fixed bin (15) unsigned unal, /* target component index */ 1 41 2 mbz1 bit (12) unal, 1 42 2 tag bit (6) unal, /* fault tag 3 47(8), ITS 43(8) if snapped */ 1 43 1 44 2 offset fixed bin (18) unsigned unal, /* word offset of link */ 1 45 2 mbz2 bit (3) unal, 1 46 2 bit_offset fixed bin (6) unsigned unal, /* bit offset (in practice, always 0) */ 1 47 2 mbz3 bit (3) unal, 1 48 2 modifier bit (6) unal; /* modifier to be left in snapped link */ 1 49 1 50 declare 1 linkage_header based aligned, /* linkage block header */ 1 51 2 def_ptr ptr, /* pointer to definition section */ 1 52 2 symbol_ptr ptr unal, /* pointer to symbol section in object segment */ 1 53 2 original_linkage_ptr 1 54 ptr unal, /* pointer to linkage section in object segment */ 1 55 2 unused bit (72), 1 56 2 stats, 1 57 3 begin_links fixed bin (18) unsigned unal, /* offset (rel to this section) of first link */ 1 58 3 block_length fixed bin (18) unsigned unal, /* number of words in this linkage section */ 1 59 3 segment_number 1 60 fixed bin (18) unsigned unal, /* text segment number associated with this section */ 1 61 3 static_length fixed bin (18) unsigned unal; /* number of words of static for this segment */ 1 62 1 63 declare 1 linkage_header_flags 1 64 aligned based, /* overlay of def_ptr for flags */ 1 65 2 pad1 bit (28) unaligned, /* flags are in first word */ 1 66 2 static_vlas bit (1) unaligned, /* static section "owns" some LA/VLA segments */ 1 67 2 perprocess_static 1 68 bit (1) unaligned, /* 1 copy of static section is shared among all tasks/run units */ 1 69 2 pad2 bit (6) unaligned; 1 70 1 71 declare 1 virgin_linkage_header 1 72 aligned based, /* template for linkage header in object segment */ 1 73 2 pad bit (30) unaligned, /* is filled in by linker */ 1 74 2 defs_in_link bit (6) unaligned, /* =o20 if defs in linkage (nonstandard) */ 1 75 2 def_offset fixed bin (18) unsigned unaligned, 1 76 /* offset of definition section */ 1 77 2 first_ref_relp fixed bin (18) unsigned unaligned, 1 78 /* offset of trap-at-first-reference offset array */ 1 79 2 filled_in_later bit (144), 1 80 2 link_begin fixed bin (18) unsigned unaligned, 1 81 /* offset of first link */ 1 82 2 linkage_section_lng 1 83 fixed bin (18) unsigned unaligned, 1 84 /* length of linkage section */ 1 85 2 segno_pad fixed bin (18) unsigned unaligned, 1 86 /* will be segment number of copied linkage */ 1 87 2 static_length fixed bin (18) unsigned unaligned; 1 88 /* length of static section */ 1 89 1 90 declare 1 fr_traps based aligned, /* First Reference Trap Procedures */ 1 91 2 decl_vers fixed bin, /* version of this struc, value=1, ABS reloc */ 1 92 2 n_traps fixed bin, /* number of traps on this segment, ABS */ 1 93 2 trap_array (n_fr_traps refer (fr_traps.n_traps)) aligned, 1 94 3 call_relp fixed bin (18) unsigned unaligned, 1 95 /* LINK18, offset of link defining procedure to call */ 1 96 3 info_relp fixed bin (18) unsigned unaligned; 1 97 /* LINK18, offser of link defining argument list for trap proc */ 1 98 1 99 declare FR_TRAPS_VERSION_1 init (1) fixed bin internal static options (constant); 1 100 declare FAULT_TAG_1 bit(6) unaligned init ("40"b3) static options (constant); 1 101 declare FAULT_TAG_2 bit(6) unaligned init ("46"b3) static options (constant); 1 102 declare FAULT_TAG_3 bit(6) unaligned init ("47"b3) static options (constant); 1 103 1 104 /* END INCLUDE FILE object_link_dcls.incl.pl1 */ 288 289 2 1 /* Begin include file definition_dcls.incl.pl1 BIM 1981 */ 2 2 2 3 2 4 /****^ HISTORY COMMENTS: 2 5* 1) change(86-05-02,Elhard), approve(86-05-02,MCR7391), 2 6* audit(86-07-18,DGHowe), install(86-11-20,MR12.0-1222): 2 7* Modified to add indirect bit to definition flags, add msf_map_relp to the 2 8* definition header, declare the msf_map, and add structures and constants 2 9* for deferred initialization. 2 10* 2) change(86-06-24,DGHowe), approve(86-06-24,MCR7420), 2 11* audit(86-08-05,Schroth), install(86-11-20,MR12.0-1222): 2 12* added the structures for pointer initialization. pointer_init_template. 2 13* changed list_template_entry 2 14* END HISTORY COMMENTS */ 2 15 2 16 2 17 /* Modified: */ 2 18 /* 13 Dec 1982 by Lee A. Newcomb to put definition_header.hash_table_relp */ 2 19 /* after unused half-word instead of before it. */ 2 20 /* 1 March 1983 by M. Weaver to add list template init type */ 2 21 2 22 /* format: style3,idind25 */ 2 23 /* everything for the definition section */ 2 24 2 25 declare ( 2 26 CLASS_TEXT init (0), /* text section definition */ 2 27 CLASS_LINKAGE init (1), /* linkage section definition */ 2 28 CLASS_SYMBOL init (2), /* symbol section definition */ 2 29 CLASS_SEGNAME init (3), /* segment name definition */ 2 30 CLASS_STATIC init (4), /* static section definition */ 2 31 CLASS_SYSTEM init (5), /* valid only in self links, not def class */ 2 32 CLASS_HEAP init (6) /* valid only in self links, not def class */ 2 33 ) fixed bin (3) unsigned internal static options (constant); 2 34 2 35 declare CLASS_NAMES (0:6) character (12) internal static options (constant) 2 36 init ("text", "linkage", "symbol", "segname", "static", "system", "heap"); 2 37 2 38 declare SYMBOLIC_SECTION_NAMES (0:6) character (8) 2 39 init ("*text", "*link", "*symbol", *, "*static", "*system", "*heap") internal static 2 40 options (constant); 2 41 2 42 declare 1 definition_flags unaligned based, 2 43 2 new bit (1), /* should be "1"b */ 2 44 2 ignore bit (1), /* cannot snap link to this */ 2 45 2 entry bit (1), /* can tra here */ 2 46 2 retain bit (1), /* binder respects this */ 2 47 2 argcount bit (1), /* OBSOLETE */ 2 48 2 descriptors bit (1), /* OBSOLETE */ 2 49 2 indirect bit (1), /* target is a pointer to actual target */ 2 50 2 unused bit (8); /* Must be zero */ 2 51 2 52 2 53 2 54 2 55 /* Header of the definition section */ 2 56 2 57 declare def_header_ptr pointer; 2 58 declare 1 definition_header aligned based (def_header_ptr), 2 59 2 def_list_relp fixed bin (18) unsigned unaligned, 2 60 /* first definition, reloc def18 */ 2 61 2 msf_map_relp fixed bin (18) unsigned unaligned, 2 62 /* msf_map if any, or 0 if none. reloc def18 unless none */ 2 63 2 hash_table_relp fixed bin (18) unsigned unaligned, 2 64 /* def hash table, if any, or 0 if none. reloc def18 unless none */ 2 65 2 flags unaligned like definition_flags; 2 66 /* both new and ignore must be "1"b here */ 2 67 2 68 /* A non class=3 definition. See segname_definition below for class=3 */ 2 69 2 70 2 71 declare def_ptr pointer; 2 72 declare 1 definition aligned based (def_ptr), 2 73 2 forward_relp unal fixed bin (18) unsigned, 2 74 /* offset of next def */ 2 75 2 backward_relp unal fixed bin (18) unsigned, 2 76 /* offset of previous def */ 2 77 2 thing_relp unal fixed bin (18) unsigned, 2 78 /* offset in section specified by class of thing this defines */ 2 79 2 flags unaligned like definition_flags, 2 80 2 class unal fixed bin (3) unsigned, 2 81 /* Type of definition */ 2 82 2 name_relp unal fixed bin (18) unsigned, 2 83 /* offset of ACC for symbol */ 2 84 2 segname_relp unal fixed bin (18) unsigned; 2 85 /* offset of segname def to which this belongs */ 2 86 2 87 /* Class=3, segname definition */ 2 88 2 89 declare segname_ptr pointer; 2 90 declare 1 segname_definition aligned based (segname_ptr), 2 91 2 forward_relp unal fixed bin (18) unsigned, 2 92 /* offset of next def */ 2 93 2 backward_relp unal fixed bin (18) unsigned, 2 94 /* offset of previous def */ 2 95 2 next_segname_relp unal fixed bin (18) unsigned, 2 96 /* offset of next segname def */ 2 97 2 flags unaligned like definition_flags, 2 98 2 class unal fixed bin (3) unsigned, 2 99 /* 3 for segname */ 2 100 2 name_relp unal fixed bin (18) unsigned, 2 101 /* offset of ACC for symbol */ 2 102 2 first_relp unal fixed bin (18) unsigned; 2 103 /* see following : */ 2 104 2 105 /* Definition blocks are chained off of segname definitions. 2 106* segname_definition.first_relp is one of three things: 2 107* (1) the def section offset of the first ordinary (class^=3) definition 2 108* belonging to this segname block. In the case where there are more than 2 109* one segname's on a block, all their first_relp will point 2 110* to the same place. 2 111* 2 112* (2) if there are no ordinary definitions associated with this segname, 2 113* then it is the def section offset of the next segname. 2 114* 2 115* (3) if there are no ordinary definitions in the block, and it 2 116* is the last block, then it points to a word containing 0. 2 117* 2 118* Thus the end of a list of synonym segnames can be detected by forward_relp 2 119* pointing to a class=3 definition whose first_relp is not the same as 2 120* the current definitions first_relp. 2 121**/ 2 122 2 123 /* All the definitions are linked through the forward and 2 124* backward thread variables. The end of the chain can is indicated 2 125* by forward pointing to a zero word. */ 2 126 2 127 2 128 declare exp_ptr pointer; 2 129 declare 1 exp_word based (exp_ptr) aligned, /* expression word in link definition */ 2 130 2 type_relp fixed bin (18) unsigned unal, 2 131 /* pointer (rel to defs) of type pair structure */ 2 132 2 expression fixed bin (17) unal; /* constant expression to be added in when snapping link */ 2 133 2 134 declare ( 2 135 LINK_SELF_BASE init (1), /* *section|0+expression,modifier */ 2 136 /* which section determined by segname_relp */ 2 137 LINK_OBSOLETE_2 init (2), /* not used */ 2 138 LINK_REFNAME_BASE init (3), /* refname|0+expression,modifier */ 2 139 LINK_REFNAME_OFFSETNAME init (4), /* refname|offsetname+expression,modifier */ 2 140 LINK_SELF_OFFSETNAME init (5), /* *section|offsetname+expression,modifier */ 2 141 LINK_CREATE_IF_NOT_FOUND init (6), /* OBSOLETE: like LINK_REFNAME_OFFSETNAME except that it will create instead of taking linkage_error */ 2 142 SECTION_TEXT init (0), /* *text */ 2 143 SECTION_LINK init (1), /* *link */ 2 144 SECTION_SYMBOL init (2), /* *symbol */ 2 145 SECTION_UNUSED init (3), /* reserved */ 2 146 SECTION_STATIC init (4), /* *static */ 2 147 SECTION_SYSTEM init (5), /* *system */ 2 148 SECTION_HEAP init (6) /* *heap */ 2 149 ) fixed bin (18) unsigned unaligned internal static options (constant); 2 150 2 151 /* use CLASS_NAMES for section names */ 2 152 2 153 declare LINK_TYPE_NAMES (1:6) 2 154 init ("absolute in section", "unused", "absolute off of refname", 2 155 "symbolic off of refname", "symbolic in section", "symbolic off of refname; create") 2 156 character (32) varying internal static options (constant); 2 157 2 158 2 159 declare type_ptr pointer; 2 160 declare 1 type_pair based (type_ptr) aligned,/* type pair in link definition */ 2 161 2 type fixed bin (18) unsigned unal, 2 162 /* see above */ 2 163 2 trap_relp fixed bin (18) unsigned unal, 2 164 /* pointer (rel to defs) to the trap word */ 2 165 /* unless LINK_SELF_OFFSETNAME off of *system or create link */ 2 166 2 segname_relp fixed bin (18) unsigned unal, 2 167 /* pointer (rel to defs) to ACC reference name for segment referenced, 2 168* /*or section code for SELF links */ 2 169 2 offsetname_relp fixed bin (18) unsigned unal; 2 170 /* for OFFSETNAME links, ACC string of name of location. */ 2 171 /* for others, must be ZERO */ 2 172 2 173 2 174 /* Link Trap Pair */ 2 175 2 176 declare link_trap_ptr pointer; 2 177 declare 1 link_trap_pair aligned based (link_trap_ptr), 2 178 2 call_relp fixed bin (18) unsigned unaligned, 2 179 /* LINK18, link to thing to call */ 2 180 2 info_relp fixed bin (18) unsigned unaligned; 2 181 /* LINK18, link to argument list */ 2 182 2 183 2 184 /* initialization info for *system or *heap link */ 2 185 2 186 2 187 /* NOTE -------------------------------------------------- 2 188* the following structures defining initialization information are also 2 189* defined in fortran_storage.incl.pl1 system_link_init_info.incl.pl1 2 190* and should be kept equivalent 2 191* ------------------------------------------------------- 2 192**/ 2 193 2 194 declare ( 2 195 INIT_NO_INIT init (0), 2 196 INIT_COPY_INFO init (3), 2 197 INIT_DEFINE_AREA init (4), 2 198 INIT_LIST_TEMPLATE init (5), 2 199 INIT_DEFERRED init (6) 2 200 ) fixed bin internal static options (constant); 2 201 2 202 /* for type = 0 or 4 */ 2 203 2 204 declare link_init_ptr pointer; 2 205 declare 1 link_init aligned based (link_init_ptr), 2 206 2 n_words fixed bin (35), /* number to invent */ 2 207 2 type fixed bin; /* see types above */ 2 208 2 209 /* for type=3, there is data to copy */ 2 210 2 211 declare 1 link_init_copy_info aligned based (link_init_ptr), 2 212 2 header aligned like link_init, 2 213 2 initial_data (link_init_n_words refer (link_init_copy_info.header.n_words)) bit (36) aligned; 2 214 2 215 declare link_init_n_words fixed bin; 2 216 2 217 /* for type = 5, there is a list template to copy */ 2 218 2 219 declare 1 link_init_list_template 2 220 aligned based (link_init_ptr), 2 221 2 header aligned like link_init, 2 222 2 pad bit (18) unaligned, 2 223 2 n_words_in_list fixed bin (18) unsigned unaligned, 2 224 2 template (link_init_n_words_in_list refer (link_init_list_template.n_words_in_list)); 2 225 2 226 declare link_init_n_words_in_list 2 227 fixed bin; 2 228 2 229 /* A list template consists of a series of entries with the following 2 230* description, concatenated together. n_bits and datum are bit items, 2 231* to permit a wide range of inputs. 2 232* 2 233* 1. A 'repeat' of '0' signifies skipping of 'n_bits' bits. 2 234* 2. A 'n_bits' of '0' signifies the last item of the list. 2 235* 2 236* COMMON, VLA's, and LA's are presumed to start at the base pointer 2 237* of their particular storage section. */ 2 238 2 239 declare 1 list_template_entry aligned based, 2 240 2 n_bits fixed bin (35) aligned, /* size of datum */ 2 241 2 mbz bit (3) unaligned, /* future expansion */ 2 242 2 init_type fixed bin (3) unsigned unaligned, /* 0 normal init, 1 ptr init, 2 packed ptr init */ 2 243 2 repeat fixed bin (30) unsigned unaligned, 2 244 /* number of times to repeat datum */ 2 245 2 datum bit (link_init_n_bits_in_datum refer (list_template_entry.n_bits)); 2 246 2 247 2 248 /* the pointer_init_template represents the initialization information 2 249* for ITS and packed pointers. Both pointer types require the entire 2 250* 72 bit structure. 2 251**/ 2 252 2 253 dcl 1 pointer_init_template based, 2 254 2 ptr_type fixed bin (18) unsigned unaligned, /* 0 text section, 1 linkage section, 2 static section */ 2 255 2 section_offset fixed bin (18) unsigned unaligned, /* offset to item in specified section */ 2 256 2 word_offset fixed bin (18) unsigned unaligned, /* offset from section item to target in words */ 2 257 2 mbz bit (12) unaligned, 2 258 2 bit_offset fixed bin (6) unsigned unaligned; /* offset from section item|word offset to target in bits */ 2 259 2 260 2 261 declare link_init_n_bits_in_datum 2 262 fixed bin (35); 2 263 2 264 /* for type = 6, the init_info resides in another MSF component */ 2 265 /* target_relp is a linkage section offset to a partial link to */ 2 266 /* the base of the linkage section of the component containing */ 2 267 /* the actual init_info. link_relp is the offset of the actual */ 2 268 /* link within that linkage section. */ 2 269 2 270 declare 1 link_init_deferred aligned based (link_init_ptr), 2 271 2 header aligned like link_init, 2 272 2 target_relp fixed bin (18) unsigned unaligned, 2 273 2 link_relp fixed bin (18) unsigned unaligned; 2 274 2 275 /* Definition section hash table */ 2 276 2 277 declare def_ht_ptr pointer; 2 278 declare 1 definition_ht aligned based (def_ht_ptr), 2 279 2 n_entries fixed bin, 2 280 2 table (def_ht_n_entries refer (definition_ht.n_entries)) aligned, 2 281 3 def_relp fixed bin (18) unsigned unaligned, 2 282 3 unused bit (18) unaligned; 2 283 2 284 declare def_ht_n_entries fixed bin; 2 285 2 286 2 287 /* Component name ht */ 2 288 declare comp_ht_ptr pointer; 2 289 declare 1 component_ht aligned based (comp_ht_ptr), 2 290 2 n_entries fixed bin, 2 291 2 table (comp_ht_n_entries refer (component_ht.n_entries)) aligned, 2 292 3 def_relp fixed bin (18) unsigned unaligned, 2 293 /* hashed segname */ 2 294 3 block_hdr_relp fixed bin (18) unsigned unaligned; 2 295 /* first segname def of block containing def_relp */ 2 296 2 297 declare comp_ht_n_entries fixed bin; 2 298 2 299 /* Duplicate name table */ 2 300 2 301 declare dup_table_ptr pointer; 2 302 declare 1 duplicate_table aligned based (dup_table_ptr), 2 303 2 mbz bit (18) unaligned, /* to tell it from a definition */ 2 304 2 n_names fixed bin (18) unsigned unaligned, 2 305 /* n in table */ 2 306 2 table (dup_table_n_names refer (duplicate_table.n_names)) aligned, 2 307 3 def_relp fixed bin (18) unsigned unaligned, 2 308 3 block_hdr_relp fixed bin (18) unsigned unaligned; 2 309 2 310 declare dup_table_n_names fixed bin; 2 311 2 312 /* The msf_map is found in the definition section of an */ 2 313 /* object MSF component. It is used by the linker to */ 2 314 /* determine whether a segment is a component of an object */ 2 315 /* MSF or a standard single-segment object. */ 2 316 2 317 dcl msf_map_ptr ptr; 2 318 dcl 01 msf_map aligned based (msf_map_ptr), 2 319 02 version char (8), 2 320 02 component_count fixed bin (15) unsigned, 2 321 02 my_component fixed bin (15) unsigned; 2 322 2 323 dcl msf_map_version_1 char (8) static options (constant) 2 324 init ("msfmp1.0"); 2 325 2 326 declare acc_string_ptr pointer; 2 327 declare 1 acc_string aligned based (acc_string_ptr), 2 328 2 count fixed bin (9) unsigned unaligned, 2 329 2 string character (max (3, acc_string_length) refer (acc_string.count)) unaligned, 2 330 2 mbz bit (0) aligned; /* this causes the statement */ 2 331 /* unspec (acc_string) = ""b to zero out */ 2 332 /* the last word, if the string is not of length 0mod4 */ 2 333 2 334 declare acc_string_length fixed bin (21); 2 335 2 336 2 337 /* end include file definitions_dcls.incl.pl1 */ 290 291 3 1 /* BEGIN INCLUDE FILE its.incl.pl1 3 2* modified 27 July 79 by JRDavis to add its_unsigned 3 3* Internal format of ITS pointer, including ring-number field for follow-on processor */ 3 4 3 5 dcl 1 its based aligned, /* declaration for ITS type pointer */ 3 6 2 pad1 bit (3) unaligned, 3 7 2 segno bit (15) unaligned, /* segment number within the pointer */ 3 8 2 ringno bit (3) unaligned, /* ring number within the pointer */ 3 9 2 pad2 bit (9) unaligned, 3 10 2 its_mod bit (6) unaligned, /* should be 43(8) */ 3 11 3 12 2 offset bit (18) unaligned, /* word offset within the addressed segment */ 3 13 2 pad3 bit (3) unaligned, 3 14 2 bit_offset bit (6) unaligned, /* bit offset within the word */ 3 15 2 pad4 bit (3) unaligned, 3 16 2 mod bit (6) unaligned; /* further modification */ 3 17 3 18 dcl 1 itp based aligned, /* declaration for ITP type pointer */ 3 19 2 pr_no bit (3) unaligned, /* number of pointer register to use */ 3 20 2 pad1 bit (27) unaligned, 3 21 2 itp_mod bit (6) unaligned, /* should be 41(8) */ 3 22 3 23 2 offset bit (18) unaligned, /* word offset from pointer register word offset */ 3 24 2 pad2 bit (3) unaligned, 3 25 2 bit_offset bit (6) unaligned, /* bit offset relative to new word offset */ 3 26 2 pad3 bit (3) unaligned, 3 27 2 mod bit (6) unaligned; /* further modification */ 3 28 3 29 3 30 dcl 1 its_unsigned based aligned, /* just like its, but with unsigned binary */ 3 31 2 pad1 bit (3) unaligned, 3 32 2 segno fixed bin (15) unsigned unaligned, 3 33 2 ringno fixed bin (3) unsigned unaligned, 3 34 2 pad2 bit (9) unaligned, 3 35 2 its_mod bit (6) unaligned, 3 36 3 37 2 offset fixed bin (18) unsigned unaligned, 3 38 2 pad3 bit (3) unaligned, 3 39 2 bit_offset fixed bin (6) unsigned unaligned, 3 40 2 pad4 bit (3) unaligned, 3 41 2 mod bit (6) unaligned; 3 42 3 43 dcl 1 itp_unsigned based aligned, /* just like itp, but with unsigned binary where appropriate */ 3 44 2 pr_no fixed bin (3) unsigned unaligned, 3 45 2 pad1 bit (27) unaligned, 3 46 2 itp_mod bit (6) unaligned, 3 47 3 48 2 offset fixed bin (18) unsigned unaligned, 3 49 2 pad2 bit (3) unaligned, 3 50 2 bit_offset fixed bin (6) unsigned unaligned, 3 51 2 pad3 bit (3) unaligned, 3 52 2 mod bit (6) unaligned; 3 53 3 54 3 55 dcl ITS_MODIFIER bit (6) unaligned internal static options (constant) init ("43"b3); 3 56 dcl ITP_MODIFIER bit (6) unaligned internal static options (constant) init ("41"b3); 3 57 3 58 /* END INCLUDE FILE its.incl.pl1 */ 292 293 4 1 /* */ 4 2 /* BEGIN INCLUDE FILE mc.incl.pl1 Created Dec 72 for 6180 - WSS. */ 4 3 /* Modified 06/07/76 by Greenberg for mc.resignal */ 4 4 /* Modified 07/07/76 by Morris for fault register data */ 4 5 /* Modified 08/28/80 by J. A. Bush for the DPS8/70M CVPU */ 4 6 /* Modified '82 to make values constant */ 4 7 4 8 /* words 0-15 pointer registers */ 4 9 4 10 dcl mcp ptr; 4 11 4 12 dcl 1 mc based (mcp) aligned, 4 13 2 prs (0:7) ptr, /* POINTER REGISTERS */ 4 14 (2 regs, /* registers */ 4 15 3 x (0:7) bit (18), /* index registers */ 4 16 3 a bit (36), /* accumulator */ 4 17 3 q bit (36), /* q-register */ 4 18 3 e bit (8), /* exponent */ 4 19 3 pad1 bit (28), 4 20 3 t bit (27), /* timer register */ 4 21 3 pad2 bit (6), 4 22 3 ralr bit (3), /* ring alarm register */ 4 23 4 24 2 scu (0:7) bit (36), 4 25 4 26 2 mask bit (72), /* mem controller mask at time of fault */ 4 27 2 ips_temp bit (36), /* Temporary storage for IPS info */ 4 28 2 errcode fixed bin (35), /* fault handler's error code */ 4 29 2 fim_temp, 4 30 3 unique_index bit (18) unal, /* unique index for restarting faults */ 4 31 3 resignal bit (1) unal, /* recompute signal name with fcode below */ 4 32 3 fcode bit (17) unal, /* fault code used as index to FIM table and SCT */ 4 33 2 fault_reg bit (36), /* fault register */ 4 34 2 pad2 bit (1), 4 35 2 cpu_type fixed bin (2) unsigned, /* L68 = 0, DPS8/70M = 1 */ 4 36 2 ext_fault_reg bit (15), /* extended fault reg for DPS8/70M CPU */ 4 37 2 fault_time bit (54), /* time of fault */ 4 38 4 39 2 eis_info (0:7) bit (36)) unaligned; 4 40 4 41 4 42 dcl (apx fixed bin init (0), 4 43 abx fixed bin init (1), 4 44 bpx fixed bin init (2), 4 45 bbx fixed bin init (3), 4 46 lpx fixed bin init (4), 4 47 lbx fixed bin init (5), 4 48 spx fixed bin init (6), 4 49 sbx fixed bin init (7)) internal static options (constant); 4 50 4 51 4 52 4 53 4 54 dcl scup ptr; 4 55 4 56 dcl 1 scu based (scup) aligned, /* SCU DATA */ 4 57 4 58 4 59 /* WORD (0) */ 4 60 4 61 (2 ppr, /* PROCEDURE POINTER REGISTER */ 4 62 3 prr bit (3), /* procedure ring register */ 4 63 3 psr bit (15), /* procedure segment register */ 4 64 3 p bit (1), /* procedure privileged bit */ 4 65 4 66 2 apu, /* APPENDING UNIT STATUS */ 4 67 3 xsf bit (1), /* ext seg flag - IT modification */ 4 68 3 sdwm bit (1), /* match in SDW Ass. Mem. */ 4 69 3 sd_on bit (1), /* SDW Ass. Mem. ON */ 4 70 3 ptwm bit (1), /* match in PTW Ass. Mem. */ 4 71 3 pt_on bit (1), /* PTW Ass. Mem. ON */ 4 72 3 pi_ap bit (1), /* Instr Fetch or Append cycle */ 4 73 3 dsptw bit (1), /* Fetch of DSPTW */ 4 74 3 sdwnp bit (1), /* Fetch of SDW non paged */ 4 75 3 sdwp bit (1), /* Fetch of SDW paged */ 4 76 3 ptw bit (1), /* Fetch of PTW */ 4 77 3 ptw2 bit (1), /* Fetch of pre-paged PTW */ 4 78 3 fap bit (1), /* Fetch of final address paged */ 4 79 3 fanp bit (1), /* Fetch of final address non-paged */ 4 80 3 fabs bit (1), /* Fetch of final address absolute */ 4 81 4 82 2 fault_cntr bit (3), /* number of retrys of EIS instructions */ 4 83 4 84 4 85 /* WORD (1) */ 4 86 4 87 2 fd, /* FAULT DATA */ 4 88 3 iro bit (1), /* illegal ring order */ 4 89 3 oeb bit (1), /* out of execute bracket */ 4 90 3 e_off bit (1), /* no execute */ 4 91 3 orb bit (1), /* out of read bracket */ 4 92 3 r_off bit (1), /* no read */ 4 93 3 owb bit (1), /* out of write bracket */ 4 94 3 w_off bit (1), /* no write */ 4 95 3 no_ga bit (1), /* not a gate */ 4 96 3 ocb bit (1), /* out of call bracket */ 4 97 3 ocall bit (1), /* outward call */ 4 98 3 boc bit (1), /* bad outward call */ 4 99 3 inret bit (1), /* inward return */ 4 100 3 crt bit (1), /* cross ring transfer */ 4 101 3 ralr bit (1), /* ring alarm register */ 4 102 3 am_er bit (1), /* associative memory fault */ 4 103 3 oosb bit (1), /* out of segment bounds */ 4 104 3 paru bit (1), /* processor parity upper */ 4 105 3 parl bit (1), /* processor parity lower */ 4 106 3 onc_1 bit (1), /* op not complete type 1 */ 4 107 3 onc_2 bit (1), /* op not complete type 2 */ 4 108 4 109 2 port_stat, /* PORT STATUS */ 4 110 3 ial bit (4), /* illegal action lines */ 4 111 3 iac bit (3), /* illegal action channel */ 4 112 3 con_chan bit (3), /* connect channel */ 4 113 4 114 2 fi_num bit (5), /* (fault/interrupt) number */ 4 115 2 fi_flag bit (1), /* 1 => fault, 0 => interrupt */ 4 116 4 117 4 118 /* WORD (2) */ 4 119 4 120 2 tpr, /* TEMPORARY POINTER REGISTER */ 4 121 3 trr bit (3), /* temporary ring register */ 4 122 3 tsr bit (15), /* temporary segment register */ 4 123 4 124 2 pad2 bit (9), 4 125 4 126 2 cpu_no bit (3), /* CPU number */ 4 127 4 128 2 delta bit (6), /* tally modification DELTA */ 4 129 4 130 4 131 /* WORD (3) */ 4 132 4 133 2 word3 bit (18), 4 134 4 135 2 tsr_stat, /* TSR STATUS for 1,2,&3 word instructions */ 4 136 3 tsna, /* Word 1 status */ 4 137 4 prn bit (3), /* Word 1 PR number */ 4 138 4 prv bit (1), /* Word 1 PR valid bit */ 4 139 3 tsnb, /* Word 2 status */ 4 140 4 prn bit (3), /* Word 2 PR number */ 4 141 4 prv bit (1), /* Word 2 PR valid bit */ 4 142 3 tsnc, /* Word 3 status */ 4 143 4 prn bit (3), /* Word 3 PR number */ 4 144 4 prv bit (1), /* Word 3 PR valid bit */ 4 145 4 146 2 tpr_tbr bit (6), /* TPR.TBR field */ 4 147 4 148 4 149 /* WORD (4) */ 4 150 4 151 2 ilc bit (18), /* INSTRUCTION COUNTER */ 4 152 4 153 2 ir, /* INDICATOR REGISTERS */ 4 154 3 zero bit (1), /* zero indicator */ 4 155 3 neg bit (1), /* negative indicator */ 4 156 3 carry bit (1), /* carryry indicator */ 4 157 3 ovfl bit (1), /* overflow indicator */ 4 158 3 eovf bit (1), /* eponent overflow */ 4 159 3 eufl bit (1), /* exponent underflow */ 4 160 3 oflm bit (1), /* overflow mask */ 4 161 3 tro bit (1), /* tally runout */ 4 162 3 par bit (1), /* parity error */ 4 163 3 parm bit (1), /* parity mask */ 4 164 3 bm bit (1), /* ^bar mode */ 4 165 3 tru bit (1), /* truncation mode */ 4 166 3 mif bit (1), /* multi-word instruction mode */ 4 167 3 abs bit (1), /* absolute mode */ 4 168 3 hex bit (1), /* hexadecimal exponent mode */ 4 169 3 pad bit (3), 4 170 4 171 4 172 /* WORD (5) */ 4 173 4 174 2 ca bit (18), /* COMPUTED ADDRESS */ 4 175 4 176 2 cu, /* CONTROL UNIT STATUS */ 4 177 3 rf bit (1), /* on first cycle of repeat instr */ 4 178 3 rpt bit (1), /* repeat instruction */ 4 179 3 rd bit (1), /* repeat double instruction */ 4 180 3 rl bit (1), /* repeat link instruciton */ 4 181 3 pot bit (1), /* IT modification */ 4 182 3 pon bit (1), /* return type instruction */ 4 183 3 xde bit (1), /* XDE from Even location */ 4 184 3 xdo bit (1), /* XDE from Odd location */ 4 185 3 poa bit (1), /* operation preparation */ 4 186 3 rfi bit (1), /* tells CPU to refetch instruction */ 4 187 3 its bit (1), /* ITS modification */ 4 188 3 if bit (1), /* fault occured during instruction fetch */ 4 189 4 190 2 cpu_tag bit (6)) unaligned, /* computed tag field */ 4 191 4 192 4 193 /* WORDS (6,7) */ 4 194 4 195 2 even_inst bit (36), /* even instruction of faulting pair */ 4 196 4 197 2 odd_inst bit (36); /* odd instruction of faulting pair */ 4 198 4 199 4 200 4 201 4 202 4 203 4 204 /* ALTERNATE SCU DECLARATION */ 4 205 4 206 4 207 dcl 1 scux based (scup) aligned, 4 208 4 209 (2 pad0 bit (36), 4 210 4 211 2 fd, /* GROUP II FAULT DATA */ 4 212 3 isn bit (1), /* illegal segment number */ 4 213 3 ioc bit (1), /* illegal op code */ 4 214 3 ia_am bit (1), /* illegal address - modifier */ 4 215 3 isp bit (1), /* illegal slave procedure */ 4 216 3 ipr bit (1), /* illegal procedure */ 4 217 3 nea bit (1), /* non existent address */ 4 218 3 oobb bit (1), /* out of bounds */ 4 219 3 pad bit (29), 4 220 4 221 2 pad2 bit (36), 4 222 4 223 2 pad3a bit (18), 4 224 4 225 2 tsr_stat (0:2), /* TSR STATUS as an ARRAY */ 4 226 3 prn bit (3), /* PR number */ 4 227 3 prv bit (1), /* PR valid bit */ 4 228 4 229 2 pad3b bit (6)) unaligned, 4 230 4 231 2 pad45 (0:1) bit (36), 4 232 4 233 2 instr (0:1) bit (36); /* Instruction ARRAY */ 4 234 4 235 4 236 4 237 /* END INCLUDE FILE mc.incl.pl1 */ 294 295 5 1 /* BEGIN INCLUDE FILE ... stack_header.incl.pl1 .. 3/72 Bill Silver */ 5 2 /* modified 7/76 by M. Weaver for *system links and more system use of areas */ 5 3 /* modified 3/77 by M. Weaver to add rnt_ptr */ 5 4 /* Modified April 1983 by C. Hornig for tasking */ 5 5 5 6 /****^ HISTORY COMMENTS: 5 7* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), 5 8* audit(86-08-05,Schroth), install(86-11-03,MR12.0-1206): 5 9* added the heap_header_ptr definition. 5 10* 2) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 5 11* audit(86-10-10,Fawcett), install(86-11-03,MR12.0-1206): 5 12* Modified to support control point management. These changes were actually 5 13* made in February 1985 by G. Palter. 5 14* 3) change(86-10-22,Fawcett), approve(86-10-22,MCR7473), 5 15* audit(86-10-22,Farley), install(86-11-03,MR12.0-1206): 5 16* Remove the old_lot pointer and replace it with cpm_data_ptr. Use the 18 5 17* bit pad after cur_lot_size for the cpm_enabled. This was done to save some 5 18* space int the stack header and change the cpd_ptr unal to cpm_data_ptr 5 19* (ITS pair). 5 20* END HISTORY COMMENTS */ 5 21 5 22 /* format: style2 */ 5 23 5 24 dcl sb ptr; /* the main pointer to the stack header */ 5 25 5 26 dcl 1 stack_header based (sb) aligned, 5 27 2 pad1 (4) fixed bin, /* (0) also used as arg list by outward_call_handler */ 5 28 2 cpm_data_ptr ptr, /* (4) pointer to control point which owns this stack */ 5 29 2 combined_stat_ptr ptr, /* (6) pointer to area containing separate static */ 5 30 2 clr_ptr ptr, /* (8) pointer to area containing linkage sections */ 5 31 2 max_lot_size fixed bin (17) unal, /* (10) DU number of words allowed in lot */ 5 32 2 main_proc_invoked fixed bin (11) unal, /* (10) DL nonzero if main procedure invoked in run unit */ 5 33 2 have_static_vlas bit (1) unal, /* (10) DL "1"b if (very) large arrays are being used in static */ 5 34 2 pad4 bit (2) unal, 5 35 2 run_unit_depth fixed bin (2) unal, /* (10) DL number of active run units stacked */ 5 36 2 cur_lot_size fixed bin (17) unal, /* (11) DU number of words (entries) in lot */ 5 37 2 cpm_enabled bit (18) unal, /* (11) DL non-zero if control point management is enabled */ 5 38 2 system_free_ptr ptr, /* (12) pointer to system storage area */ 5 39 2 user_free_ptr ptr, /* (14) pointer to user storage area */ 5 40 2 null_ptr ptr, /* (16) */ 5 41 2 stack_begin_ptr ptr, /* (18) pointer to first stack frame on the stack */ 5 42 2 stack_end_ptr ptr, /* (20) pointer to next useable stack frame */ 5 43 2 lot_ptr ptr, /* (22) pointer to the lot for the current ring */ 5 44 2 signal_ptr ptr, /* (24) pointer to signal procedure for current ring */ 5 45 2 bar_mode_sp ptr, /* (26) value of sp before entering bar mode */ 5 46 2 pl1_operators_ptr ptr, /* (28) pointer to pl1_operators_$operator_table */ 5 47 2 call_op_ptr ptr, /* (30) pointer to standard call operator */ 5 48 2 push_op_ptr ptr, /* (32) pointer to standard push operator */ 5 49 2 return_op_ptr ptr, /* (34) pointer to standard return operator */ 5 50 2 return_no_pop_op_ptr 5 51 ptr, /* (36) pointer to standard return / no pop operator */ 5 52 2 entry_op_ptr ptr, /* (38) pointer to standard entry operator */ 5 53 2 trans_op_tv_ptr ptr, /* (40) pointer to translator operator ptrs */ 5 54 2 isot_ptr ptr, /* (42) pointer to ISOT */ 5 55 2 sct_ptr ptr, /* (44) pointer to System Condition Table */ 5 56 2 unwinder_ptr ptr, /* (46) pointer to unwinder for current ring */ 5 57 2 sys_link_info_ptr ptr, /* (48) pointer to *system link name table */ 5 58 2 rnt_ptr ptr, /* (50) pointer to Reference Name Table */ 5 59 2 ect_ptr ptr, /* (52) pointer to event channel table */ 5 60 2 assign_linkage_ptr ptr, /* (54) pointer to storage for (obsolete) hcs_$assign_linkage */ 5 61 2 heap_header_ptr ptr, /* (56) pointer to the heap header for this ring */ 5 62 2 trace, 5 63 3 frames, 5 64 4 count fixed bin, /* (58) number of trace frames */ 5 65 4 top_ptr ptr unal, /* (59) pointer to last trace frame */ 5 66 3 in_trace bit (36) aligned, /* (60) trace antirecursion flag */ 5 67 2 pad2 bit (36), /* (61) */ 5 68 2 pad5 pointer; /* (62) pointer to future stuff */ 5 69 5 70 /* The following offset refers to a table within the pl1 operator table. */ 5 71 5 72 dcl tv_offset fixed bin init (361) internal static; 5 73 /* (551) octal */ 5 74 5 75 5 76 /* The following constants are offsets within this transfer vector table. */ 5 77 5 78 dcl ( 5 79 call_offset fixed bin init (271), 5 80 push_offset fixed bin init (272), 5 81 return_offset fixed bin init (273), 5 82 return_no_pop_offset fixed bin init (274), 5 83 entry_offset fixed bin init (275) 5 84 ) internal static; 5 85 5 86 5 87 5 88 5 89 5 90 /* The following declaration is an overlay of the whole stack header. Procedures which 5 91* move the whole stack header should use this overlay. 5 92**/ 5 93 5 94 dcl stack_header_overlay (size (stack_header)) fixed bin based (sb); 5 95 5 96 5 97 5 98 /* END INCLUDE FILE ... stack_header.incl.pl1 */ 296 297 6 1 /* BEGIN INCLUDE FILE ... system_link_names.incl.pl1 */ 6 2 6 3 6 4 /****^ HISTORY COMMENTS: 6 5* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), audit(86-11-12,Zwick), 6 6* install(86-11-20,MR12.0-1222): 6 7* added the declaration of the heap_header. 6 8* 2) change(86-10-20,DGHowe), approve(86-10-20,MCR7420), audit(86-11-12,Zwick), 6 9* install(86-11-20,MR12.0-1222): 6 10* add the seg ptr to the variable node structure. 6 11* END HISTORY COMMENTS */ 6 12 6 13 6 14 /* created by M. Weaver 7/28/76 */ 6 15 /* Modified: 82-11-19 by T. Oke to add LIST_TEMPLATE_INIT. */ 6 16 /* Modified 02/11/83 by M. Weaver to add have_vla_variables flag */ 6 17 6 18 6 19 dcl 1 variable_table_header aligned based, /* header for name table */ 6 20 2 hash_table (0:63) ptr unaligned, /* hash table for variable nodes */ 6 21 2 total_search_time fixed bin (71), /* total time to search for variables */ 6 22 2 total_allocation_time fixed bin (71), /* total time spent allocating and initializing nodes and variables */ 6 23 2 number_of_searches fixed bin, /* number of times names were looked up */ 6 24 2 number_of_variables fixed bin (35), /* number of variables allocated by the linker, incl deletions */ 6 25 2 flags unaligned, 6 26 3 have_vla_variables bit (1) unaligned, /* on if some variables are > sys_info$max_seg_size */ 6 27 3 pad bit (11) unaligned, 6 28 2 cur_num_of_variables fixed bin (24) unal, /* current number of variables allocated */ 6 29 2 number_of_steps fixed bin, /* total number of nodes looked at */ 6 30 2 total_allocated_size fixed bin (35); /* current amount of storage in user area */ 6 31 6 32 6 33 dcl 1 variable_node aligned based, /* individual variable information */ 6 34 2 forward_thread ptr unaligned, /* thread to next node off same hash bucket */ 6 35 2 vbl_size fixed bin (24) unsigned unaligned, /* length in words of variable */ 6 36 2 init_type fixed bin (11) unaligned, /* 0=not init; 3=init template; 4=area 5=list_template*/ 6 37 2 time_allocated fixed bin (71), /* time when variable was allocated */ 6 38 2 vbl_ptr ptr, /* pointer to variable's storage */ 6 39 2 init_ptr ptr, /* pointer to original init info in object seg */ 6 40 2 name_size fixed bin(21) aligned, /* length of name in characters */ 6 41 2 name char (nchars refer (variable_node.name_size)), /* name of variable */ 6 42 2 seg_ptr pointer; 6 43 6 44 /* variable_node.seg_ptr 6 45* Is a pointer to the segment containing the initialization information 6 46* for this variable. It is used as a segment base pointer for external 6 47* pointer initialization via list_init_. 6 48* 6 49* The init_ptr can not be used as a reference to the defining segment 6 50* due to the possibility of set_fortran_common being used to initialize 6 51* the external variables. sfc will generate an initialization information 6 52* structure if multiple intialization sizes are found in the specified 6 53* segments. sfc stores the address of this structure in the init_ptr field. 6 54* This is one reason why sfc does not perform external pointer 6 55* initialization. 6 56* 6 57* The seg_ptr is set to point at the segment used to define the 6 58* initialization information. term_ sets this field to null on termination 6 59* due to the possiblity of executing a different segment which defines 6 60* initialization information. In this way the seg_ptr field will either 6 61* be valid or null. 6 62**/ 6 63 6 64 dcl 1 heap_header based, 6 65 2 version char(8), /* specifies the verison of the header */ 6 66 2 heap_name_list_ptr pointer, /* points to the variable_table_header for this heap */ 6 67 2 previous_heap_ptr pointer, /* points to the previous heap or is null */ 6 68 2 area_ptr pointer, /* points to the heap area */ 6 69 2 execution_level fixed bin (17); /* specifies the execution level this header deals with */ 6 70 6 71 dcl heap_header_version_1 char(8) static options (constant) 6 72 init ("Heap_v01"); 6 73 6 74 6 75 /* END INCLUDE FILE ... system_link_names.incl.pl1 */ 298 299 300 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/11/89 0839.1 linkage_error_.pl1 >special_ldd>install>MR12.3-1114>linkage_error_.pl1 288 1 11/24/86 1226.9 object_link_dcls.incl.pl1 >ldd>include>object_link_dcls.incl.pl1 290 2 11/24/86 1226.9 definition_dcls.incl.pl1 >ldd>include>definition_dcls.incl.pl1 292 3 11/26/79 1320.6 its.incl.pl1 >ldd>include>its.incl.pl1 294 4 12/15/83 1100.4 mc.incl.pl1 >ldd>include>mc.incl.pl1 296 5 11/07/86 1550.3 stack_header.incl.pl1 >ldd>include>stack_header.incl.pl1 298 6 11/24/86 1226.9 system_link_names.incl.pl1 >ldd>include>system_link_names.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. CLASS_HEAP constant fixed bin(3,0) initial unsigned dcl 2-25 ref 224 CLASS_SYSTEM constant fixed bin(3,0) initial unsigned dcl 2-25 ref 224 FAULT_TAG_2 constant bit(6) initial packed unaligned dcl 1-101 ref 140 LINK_CREATE_IF_NOT_FOUND constant fixed bin(18,0) initial packed unsigned unaligned dcl 2-134 ref 163 206 220 LINK_OBSOLETE_2 constant fixed bin(18,0) initial packed unsigned unaligned dcl 2-134 ref 184 LINK_REFNAME_BASE constant fixed bin(18,0) initial packed unsigned unaligned dcl 2-134 ref 198 LINK_SELF_BASE constant fixed bin(18,0) initial packed unsigned unaligned dcl 2-134 ref 175 LINK_SELF_OFFSETNAME constant fixed bin(18,0) initial packed unsigned unaligned dcl 2-134 ref 175 179 220 223 New_line 001671 constant char(1) initial packed unaligned dcl 75 ref 242 251 268 SYMBOLIC_SECTION_NAMES 000000 constant char(8) initial array packed unaligned dcl 2-38 ref 176 acc_string based structure level 1 dcl 2-327 addr builtin function dcl 103 ref 126 253 253 addrel builtin function dcl 103 ref 147 149 150 195 203 247 baseptr builtin function dcl 103 ref 132 bin builtin function dcl 103 ref 196 buf1 000100 automatic char(100) dcl 45 set ref 122* 134* 154* 163* 239* 281* buf2 000162 automatic varying char(200) dcl 46 set ref 123* 214* 242* 247* 247* 268* 281* buf3 000245 automatic varying char(200) dcl 46 set ref 123* 259* 261* 271* 281* buf4 000131 automatic char(100) dcl 45 set ref 122* 251* 271* 281* ca 5 based bit(18) level 2 packed packed unaligned dcl 4-56 ref 132 code 000330 automatic fixed bin(35,0) dcl 47 set ref 124* 253* 256 258* 259 convert_status_code_ 000036 constant entry external dcl 98 ref 275 count based fixed bin(9,0) level 2 packed packed unsigned unaligned dcl 2-327 ref 196 197 204 210 def_ptr based pointer level 2 dcl 1-50 ref 148 def_section_ptr 000332 automatic pointer dcl 48 set ref 148* 149 150 195 203 247 definition_flags based structure level 1 packed packed unaligned dcl 2-42 dirname 000334 automatic char(168) packed unaligned dcl 49 set ref 258* 259* ec 000406 automatic fixed bin(35,0) dcl 50 set ref 128* 133 153 176 185 246 266 275* entname 000413 automatic char(32) packed unaligned dcl 52 set ref 258* 259* errcode 43 based fixed bin(35,0) level 2 packed packed unaligned dcl 4-12 ref 128 error_table_$bad_entry_point_name 000014 external static fixed bin(35,0) dcl 81 ref 133 error_table_$bad_link_type 000010 external static fixed bin(35,0) dcl 81 ref 153 error_table_$bad_self_ref 000020 external static fixed bin(35,0) dcl 81 ref 176 error_table_$bigger_ext_variable 000016 external static fixed bin(35,0) dcl 81 ref 246 error_table_$invalid_ptr_target 000022 external static fixed bin(35,0) dcl 81 ref 266 error_table_$no_ext_sym 000012 external static fixed bin(35,0) dcl 81 ref 185 exp 000407 automatic varying char(12) dcl 51 set ref 169* 171* 199 200 211 211 exp_ptr 000744 automatic pointer dcl 2-128 set ref 149* 150 167 168 exp_word based structure level 1 dcl 2-129 expression 0(18) based fixed bin(17,0) level 2 packed packed unaligned dcl 2-129 set ref 167 168* expression_relp 1 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 1-28 ref 149 ext_ptr 000444 automatic pointer dcl 54 set ref 203* 204 210 ext_var_name 000423 automatic char(65) packed unaligned dcl 53 set ref 222* 224* 229* 233* 234 234* 237* 239 242 242 253* 268 268 fixed builtin function dcl 103 ref 132 204 found_sw 000446 automatic bit(1) dcl 55 set ref 253* 256 get_ppr_ 000024 constant entry external dcl 90 ref 279 hcs_$fs_get_path_name 000034 constant entry external dcl 96 ref 258 header_ptr 000450 automatic pointer dcl 56 set ref 147* 148 header_relp based fixed bin(17,0) level 2 packed packed unaligned dcl 1-28 ref 147 i 000452 automatic fixed bin(17,0) dcl 57 set ref 231* 232 233 index builtin function dcl 103 ref 231 init_info based structure level 1 dcl 113 init_ptr 6 based pointer level 2 dcl 6-33 ref 257 258 258 259 261 ioa_$rs 000026 constant entry external dcl 93 ref 281 ioa_$rsnnl 000030 constant entry external dcl 93 ref 134 154 163 168 186 214 247 259 261 length builtin function dcl 103 in procedure "linkage_error_" ref 232 length based fixed bin(17,0) level 2 in structure "init_info" dcl 113 in procedure "linkage_error_" set ref 247* 259* 261* linfo 000454 automatic char(100) dcl 58 set ref 122* 275* 281* link_init based structure level 1 dcl 2-205 link_ptr 000506 automatic pointer dcl 60 set ref 132* 134 134 134* 140 147 147 149 linkage_header based structure level 1 dcl 1-50 lng parameter fixed bin(17,0) dcl 40 set ref 22 169 186* 281* lngsw parameter fixed bin(17,0) dcl 34 set ref 22 279* lsp parameter pointer dcl 35 set ref 22 279* mc based structure level 1 dcl 4-12 mcptr parameter pointer dcl 33 ref 22 126 128 n2 000510 automatic varying char(32) dcl 61 set ref 123* 176* 178* 186* 197* 214* 229 231 232 233 237 237 nchars 000532 automatic fixed bin(17,0) dcl 63 set ref 196* 197 204* 205 210 nl 000533 automatic char(1) dcl 64 set ref 122* 276* 281* node_ptr 000534 automatic pointer dcl 65 set ref 253 253 253* 257 258 258 259 261 null builtin function dcl 103 ref 253 253 257 o2 000521 automatic varying char(32) dcl 61 set ref 123* 199* 200* 206* 208* 210* 211* 211 214* 224 229 230 237 object_link based structure level 1 dcl 1-28 offsetname_relp 1(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-160 ref 203 one based fixed bin(35,0) level 2 dcl 110 set ref 134* optr parameter pointer dcl 39 ref 22 281 ostring based char(1000) dcl 108 set ref 281* pname1 parameter char(500) dcl 37 set ref 22 279* 281* pname2 parameter char(500) dcl 37 set ref 22 279* 281* pname3 000536 automatic char(500) dcl 67 set ref 279* ptr builtin function dcl 103 ref 132 253 253 258 258 scu based structure level 1 dcl 4-56 in procedure "linkage_error_" scu 30 based bit(36) array level 2 in structure "mc" packed packed unaligned dcl 4-12 in procedure "linkage_error_" set ref 126 scup 000750 automatic pointer dcl 4-54 set ref 126* 132 132 segname_relp 1 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-160 set ref 176 186* 195 224 224 segptr 000734 automatic pointer dcl 68 set ref 195* 196 197 set_ext_variable_ 000032 constant entry external dcl 94 ref 253 sinfo 000736 automatic char(8) dcl 69 set ref 275* sptr parameter pointer dcl 36 set ref 22 279* string 0(09) based char level 2 packed packed unaligned dcl 2-327 ref 197 210 substr builtin function dcl 103 ref 169 197 210 233 tag 0(30) based bit(6) level 2 packed packed unaligned dcl 1-28 ref 140 texp 000741 automatic char(12) dcl 71 set ref 168* 169 tlng 000453 automatic fixed bin(17,0) dcl 57 set ref 134* 154* 163* 168* 214* 247* 258* 259* 261* tpr 2 based structure level 2 packed packed unaligned dcl 4-56 trap_relp 0(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-160 ref 163 247 tsr 2(03) based bit(15) level 3 packed packed unaligned dcl 4-56 ref 132 two 1 based fixed bin(35,0) level 2 dcl 110 set ref 134* type based fixed bin(18,0) level 2 in structure "type_pair" packed packed unsigned unaligned dcl 2-160 in procedure "linkage_error_" ref 151 type 000740 automatic fixed bin(17,0) dcl 70 in procedure "linkage_error_" set ref 151* 154* 163 175 175 179 184 198 206 220 220 223 type_pair based structure level 1 dcl 2-160 type_ptr 000746 automatic pointer dcl 2-159 set ref 150* 151 163 176 186 195 203 224 224 247 type_relp based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-129 ref 150 variable_node based structure level 1 dcl 6-33 word based structure level 1 unaligned dcl 110 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. CLASS_LINKAGE internal static fixed bin(3,0) initial unsigned dcl 2-25 CLASS_NAMES internal static char(12) initial array packed unaligned dcl 2-35 CLASS_SEGNAME internal static fixed bin(3,0) initial unsigned dcl 2-25 CLASS_STATIC internal static fixed bin(3,0) initial unsigned dcl 2-25 CLASS_SYMBOL internal static fixed bin(3,0) initial unsigned dcl 2-25 CLASS_TEXT internal static fixed bin(3,0) initial unsigned dcl 2-25 FAULT_TAG_1 internal static bit(6) initial packed unaligned dcl 1-100 FAULT_TAG_3 internal static bit(6) initial packed unaligned dcl 1-102 FR_TRAPS_VERSION_1 internal static fixed bin(17,0) initial dcl 1-99 INIT_COPY_INFO internal static fixed bin(17,0) initial dcl 2-194 INIT_DEFERRED internal static fixed bin(17,0) initial dcl 2-194 INIT_DEFINE_AREA internal static fixed bin(17,0) initial dcl 2-194 INIT_LIST_TEMPLATE internal static fixed bin(17,0) initial dcl 2-194 INIT_NO_INIT internal static fixed bin(17,0) initial dcl 2-194 ITP_MODIFIER internal static bit(6) initial packed unaligned dcl 3-56 ITS_MODIFIER internal static bit(6) initial packed unaligned dcl 3-55 LINK_REFNAME_OFFSETNAME internal static fixed bin(18,0) initial packed unsigned unaligned dcl 2-134 LINK_TYPE_NAMES internal static varying char(32) initial array dcl 2-153 SECTION_HEAP internal static fixed bin(18,0) initial packed unsigned unaligned dcl 2-134 SECTION_LINK internal static fixed bin(18,0) initial packed unsigned unaligned dcl 2-134 SECTION_STATIC internal static fixed bin(18,0) initial packed unsigned unaligned dcl 2-134 SECTION_SYMBOL internal static fixed bin(18,0) initial packed unsigned unaligned dcl 2-134 SECTION_SYSTEM internal static fixed bin(18,0) initial packed unsigned unaligned dcl 2-134 SECTION_TEXT internal static fixed bin(18,0) initial packed unsigned unaligned dcl 2-134 SECTION_UNUSED internal static fixed bin(18,0) initial packed unsigned unaligned dcl 2-134 abx internal static fixed bin(17,0) initial dcl 4-42 acc_string_length automatic fixed bin(21,0) dcl 2-334 acc_string_ptr automatic pointer dcl 2-326 apx internal static fixed bin(17,0) initial dcl 4-42 bbx internal static fixed bin(17,0) initial dcl 4-42 bpx internal static fixed bin(17,0) initial dcl 4-42 call_offset internal static fixed bin(17,0) initial dcl 5-78 comp_ht_n_entries automatic fixed bin(17,0) dcl 2-297 comp_ht_ptr automatic pointer dcl 2-288 component_ht based structure level 1 dcl 2-289 def_header_ptr automatic pointer dcl 2-57 def_ht_n_entries automatic fixed bin(17,0) dcl 2-284 def_ht_ptr automatic pointer dcl 2-277 def_ptr automatic pointer dcl 2-71 definition based structure level 1 dcl 2-72 definition_header based structure level 1 dcl 2-58 definition_ht based structure level 1 dcl 2-278 dup_table_n_names automatic fixed bin(17,0) dcl 2-310 dup_table_ptr automatic pointer dcl 2-301 duplicate_table based structure level 1 dcl 2-302 entry_offset internal static fixed bin(17,0) initial dcl 5-78 fr_traps based structure level 1 dcl 1-90 heap_header based structure level 1 unaligned dcl 6-64 heap_header_version_1 internal static char(8) initial packed unaligned dcl 6-71 itp based structure level 1 dcl 3-18 itp_unsigned based structure level 1 dcl 3-43 its based structure level 1 dcl 3-5 its_unsigned based structure level 1 dcl 3-30 lbx internal static fixed bin(17,0) initial dcl 4-42 link_init_copy_info based structure level 1 dcl 2-211 link_init_deferred based structure level 1 dcl 2-270 link_init_list_template based structure level 1 dcl 2-219 link_init_n_bits_in_datum automatic fixed bin(35,0) dcl 2-261 link_init_n_words automatic fixed bin(17,0) dcl 2-215 link_init_n_words_in_list automatic fixed bin(17,0) dcl 2-226 link_init_ptr automatic pointer dcl 2-204 link_trap_pair based structure level 1 dcl 2-177 link_trap_ptr automatic pointer dcl 2-176 linkage_header_flags based structure level 1 dcl 1-63 list_template_entry based structure level 1 dcl 2-239 lpx internal static fixed bin(17,0) initial dcl 4-42 mcp automatic pointer dcl 4-10 msf_map based structure level 1 dcl 2-318 msf_map_ptr automatic pointer dcl 2-317 msf_map_version_1 internal static char(8) initial packed unaligned dcl 2-323 p automatic pointer dcl 66 partial_link based structure level 1 dcl 1-38 pointer_init_template based structure level 1 packed packed unaligned dcl 2-253 push_offset internal static fixed bin(17,0) initial dcl 5-78 return_no_pop_offset internal static fixed bin(17,0) initial dcl 5-78 return_offset internal static fixed bin(17,0) initial dcl 5-78 sb automatic pointer dcl 5-24 sbx internal static fixed bin(17,0) initial dcl 4-42 scux based structure level 1 dcl 4-207 segname_definition based structure level 1 dcl 2-90 segname_ptr automatic pointer dcl 2-89 spx internal static fixed bin(17,0) initial dcl 4-42 stack_header based structure level 1 dcl 5-26 stack_header_overlay based fixed bin(17,0) array dcl 5-94 tv_offset internal static fixed bin(17,0) initial dcl 5-72 variable_table_header based structure level 1 dcl 6-19 virgin_linkage_header based structure level 1 dcl 1-71 NAMES DECLARED BY EXPLICIT CONTEXT. exit 001547 constant label dcl 275 set ref 137 190 last_exit 001564 constant label dcl 279 ref 155 linkage_error_ 000242 constant entry external dcl 22 noent 000714 constant label dcl 203 ref 179 188 noext 000674 constant label dcl 199 ref 181 ugh 000314 constant label dcl 134 ref 140 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2060 2120 1675 2070 Length 2432 1675 40 275 162 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME linkage_error_ 598 external procedure is an external procedure. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME linkage_error_ 000100 buf1 linkage_error_ 000131 buf4 linkage_error_ 000162 buf2 linkage_error_ 000245 buf3 linkage_error_ 000330 code linkage_error_ 000332 def_section_ptr linkage_error_ 000334 dirname linkage_error_ 000406 ec linkage_error_ 000407 exp linkage_error_ 000413 entname linkage_error_ 000423 ext_var_name linkage_error_ 000444 ext_ptr linkage_error_ 000446 found_sw linkage_error_ 000450 header_ptr linkage_error_ 000452 i linkage_error_ 000453 tlng linkage_error_ 000454 linfo linkage_error_ 000506 link_ptr linkage_error_ 000510 n2 linkage_error_ 000521 o2 linkage_error_ 000532 nchars linkage_error_ 000533 nl linkage_error_ 000534 node_ptr linkage_error_ 000536 pname3 linkage_error_ 000734 segptr linkage_error_ 000736 sinfo linkage_error_ 000740 type linkage_error_ 000741 texp linkage_error_ 000744 exp_ptr linkage_error_ 000746 type_ptr linkage_error_ 000750 scup linkage_error_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as alloc_char_temp cat_realloc_chars call_ext_out_desc call_ext_out return_mac shorten_stack ext_entry set_chars_eis index_chars_eis THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. convert_status_code_ get_ppr_ hcs_$fs_get_path_name ioa_$rs ioa_$rsnnl set_ext_variable_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_entry_point_name error_table_$bad_link_type error_table_$bad_self_ref error_table_$bigger_ext_variable error_table_$invalid_ptr_target error_table_$no_ext_sym LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 22 000233 122 000247 123 000262 124 000266 126 000267 128 000274 132 000276 133 000310 134 000314 137 000357 140 000360 147 000364 148 000371 149 000373 150 000400 151 000405 153 000410 154 000413 155 000441 163 000442 167 000474 168 000500 169 000531 170 000542 171 000543 175 000544 176 000556 178 000575 179 000601 181 000605 184 000606 185 000612 186 000616 188 000646 190 000647 195 000650 196 000656 197 000661 198 000670 199 000674 200 000706 201 000713 203 000714 204 000722 205 000725 206 000726 208 000733 209 000737 210 000740 211 000747 212 001010 214 001011 220 001044 222 001052 223 001055 224 001061 227 001075 229 001076 230 001110 231 001115 232 001124 233 001130 234 001135 236 001144 237 001145 239 001171 242 001201 244 001227 246 001230 247 001234 251 001275 253 001310 256 001352 257 001357 258 001364 259 001417 261 001462 265 001512 266 001513 268 001515 271 001543 275 001547 276 001562 279 001564 281 001606 283 001670 ----------------------------------------------------------- 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