COMPILATION LISTING OF SEGMENT compare_link_ Compiled by: Multics PL/I Compiler, Release 28b, of April 11, 1983 Compiled at: Honeywell LCPD Phoenix, System M Compiled on: 06/03/83 1335.2 mst Fri Options: optimize map 1 /* ****************************************************** 2* * * 3* * * 4* * Copyright (c) 1972 by Massachusetts Institute of * 5* * Technology and Honeywell Information Systems, Inc. * 6* * * 7* * * 8* ****************************************************** */ 9 10 compare_link_: proc(optr,a_diff,a_brief,segptr); 11 12 /* Changed to use interpret_link_info.incl.pl1 05/12/83 S. Herbst */ 13 14 dcl optr pointer; 15 dcl a_diff bit(1) unaligned; 16 dcl a_brief bit(1) unaligned; 17 dcl segptr pointer; 18 1 1 /* BEGIN INCLUDE FILE ... object_info.incl.pl1 1 2*coded February 8, 1972 by Michael J. Spier */ 1 3 /* modified May 26, 1972 by M. Weaver */ 1 4 /* modified 15 April, 1975 by M. Weaver */ 1 5 1 6 declare 1 object_info aligned based, /* structure containing object info based, returned by object_info_ */ 1 7 2 version_number fixed bin, /* version number of current structure format (=2) */ 1 8 2 textp pointer, /* pointer to beginning of text section */ 1 9 2 defp pointer, /* pointer to beginning of definition section */ 1 10 2 linkp pointer, /* pointer to beginning of linkage section */ 1 11 2 statp pointer, /* pointer to beginning of static section */ 1 12 2 symbp pointer, /* pointer to beginning of symbol section */ 1 13 2 bmapp pointer, /* pointer to beginning of break map (may be null) */ 1 14 2 tlng fixed bin, /* length in words of text section */ 1 15 2 dlng fixed bin, /* length in words of definition section */ 1 16 2 llng fixed bin, /* length in words of linkage section */ 1 17 2 ilng fixed bin, /* length in words of static section */ 1 18 2 slng fixed bin, /* length in words of symbol section */ 1 19 2 blng fixed bin, /* length in words of break map */ 1 20 2 format, /* word containing bit flags about object type */ 1 21 3 old_format bit(1) unaligned, /* on if segment isn't in new format, i.e. has old style object map */ 1 22 3 bound bit(1) unaligned, /* on if segment is bound */ 1 23 3 relocatable bit(1) unaligned, /* on if seg has relocation info in its first symbol block */ 1 24 3 procedure bit(1) unaligned, /* on if segment is an executable object program */ 1 25 3 standard bit(1) unaligned, /* on if seg is in standard format (more than just standard map) */ 1 26 3 gate bit(1) unaligned, /* on if segment is a gate */ 1 27 3 separate_static bit(1) unaligned, /* on if static not in linkage */ 1 28 3 links_in_text bit(1) unaligned, /* on if there are threaded links in text */ 1 29 3 perprocess_static bit (1) unaligned, /* on if static is not to be per run unit */ 1 30 3 pad bit(27) unaligned, 1 31 2 entry_bound fixed bin, /* entry bound if segment is a gate */ 1 32 2 textlinkp pointer, /* ptr to first link in text */ 1 33 1 34 /* LIMIT OF BRIEF STRUCTURE */ 1 35 1 36 2 compiler char(8) aligned, /* name of processor which generated segment */ 1 37 2 compile_time fixed bin(71), /* clock reading of date/time object was generated */ 1 38 2 userid char(32) aligned, /* standard Multics id of creator of object segment */ 1 39 2 cvers aligned, /* generator version name in printable char string form */ 1 40 3 offset bit(18) unaligned, /* offset of name in words relative to base of symbol section */ 1 41 3 length bit(18) unaligned, /* length of name in characters */ 1 42 2 comment aligned, /* printable comment concerning generator or generation of segment */ 1 43 3 offset bit(18) unaligned, /* offset of comment in words relative to base of symbol section */ 1 44 3 length bit(18) unaligned, /* length of comment in characters */ 1 45 2 source_map fixed bin, /* offset, relative to base of symbol section, of source map structure */ 1 46 1 47 /* LIMIT OF DISPLAY STRUCTURE */ 1 48 1 49 2 rel_text pointer, /* pointer to text section relocation info */ 1 50 2 rel_def pointer, /* pointer to definition section relocation info */ 1 51 2 rel_link pointer, /* pointer to linkage section relocation info */ 1 52 2 rel_static pointer, /* pointer to static section relocation info */ 1 53 2 rel_symbol pointer, /* pointer to symbol section relocation info */ 1 54 2 text_boundary fixed bin, /* specifies mod of text section base boundary */ 1 55 2 static_boundary fixed bin, /* specifies mod of internal static base boundary */ 1 56 /* currently not used by system */ 1 57 2 default_truncate fixed bin, /* offset rel to symbp for binder to automatically trunc. symb sect. */ 1 58 2 optional_truncate fixed bin; /* offset rel to symbp for binder to optionally trunc. symb sect. */ 1 59 1 60 declare object_info_version_2 fixed bin int static init(2); 1 61 1 62 /* END INCLUDE FILE ... object_info.incl.pl1 */ 19 20 21 2 1 /* BEGIN INCLUDE FILE interpret_link_info.incl.pl1 */ 2 2 2 3 /* Written 05/12/83 by S. Herbst */ 2 4 2 5 dcl 1 interpret_link_info aligned based (interpret_link_info_ptr), 2 6 2 version char (8), 2 7 2 segment_name char (32) aligned, 2 8 2 entry_point_name char (260) aligned, 2 9 2 expression char (8) aligned, 2 10 2 modifier char (4) aligned, 2 11 2 trap char (48) aligned; 2 12 2 13 dcl INTERPRET_LINK_INFO_VERSION_1 char (8) int static options (constant) init ("ILI 1.0"); 2 14 2 15 dcl interpret_link_info_ptr ptr; 2 16 2 17 /* END INCLUDE FILE interpret_link_info.incl.pl1 */ 22 3 1 /* BEGIN INCLUDE FILE linkdcl.incl.pl1 --- last modified 15 Nov 1971 by C Garman */ 3 2 3 3 /* Last Modified (Date and Reason): 3 4* 6/75 by M.Weaver to add virgin_linkage_header declaration 3 5* 6/75 by S.Webber to comment existing structures better 3 6* 9/77 by M. Weaver to add run_depth to link 3 7**/ 3 8 3 9 dcl 1 link based aligned, /* link pair in linkage section */ 3 10 2 head_ptr bit (18) unal, /* rel pointer to beginning of linkage section */ 3 11 2 ringno bit (3) unal, 3 12 2 mbz bit (3) unal, 3 13 2 run_depth fixed bin (5) unal, /* run unit depth, filled when link is snapped */ 3 14 2 ft2 bit (6) unal, /* fault tag. 46(8) if not snapped, 43(8) if snapped */ 3 15 3 16 2 exp_ptr bit (18) unal, /* pointer (rel to defs) of expression word */ 3 17 2 mbz2 bit (12) unal, 3 18 2 modifier bit (6) unal; /* modifier to be left in snapped link */ 3 19 3 20 dcl 1 exp_word based aligned, /* expression word in link definition */ 3 21 2 type_ptr bit (18) unal, /* pointer (rel to defs) of type pair structure */ 3 22 2 exp bit (18) unal; /* constant expression to be added in when snapping link */ 3 23 3 24 dcl 1 type_pair based aligned, /* type pair in link definition */ 3 25 2 type bit (18) unal, /* type of link. may be 1,2,3,4,5, or 6 */ 3 26 2 trap_ptr bit (18) unal, /* pointer (rel to defs) to the trap word */ 3 27 2 seg_ptr bit (18) unal, /* pointer to ACC reference name for segment referenced */ 3 28 2 ext_ptr bit (18) unal; /* pointer (rel to defs) of ACC segdef name */ 3 29 3 30 dcl 1 header based aligned, /* linkage block header */ 3 31 2 def_ptr ptr, /* pointer to definition section */ 3 32 2 symbol_ptr ptr unal, /* pointer to symbol section in object segment */ 3 33 2 original_linkage_ptr ptr unal, /* pointer to linkage section in object segment */ 3 34 2 unused bit (72), 3 35 2 stats, 3 36 3 begin_links bit (18) unal, /* offset (rel to this section) of first link */ 3 37 3 block_length bit (18) unal, /* number of words in this linkage section */ 3 38 3 segment_number bit (18) unal, /* text segment number associated with this section */ 3 39 3 static_length bit (18) unal; /* number of words of static for this segment */ 3 40 3 41 dcl 1 virgin_linkage_header aligned based, /* template for linkage header in object segment */ 3 42 2 pad bit (30) unaligned, /* is filled in by linker */ 3 43 2 defs_in_link bit (6) unaligned, /* =o20 if defs in linkage (nonstandard) */ 3 44 2 def_offset bit (18) unaligned, /* offset of definition section */ 3 45 2 first_ref_relp bit (18) unaligned, /* offset of trap-at-first-reference offset array */ 3 46 2 filled_in_later bit (144), 3 47 2 link_begin bit (18) unaligned, /* offset of first link */ 3 48 2 linkage_section_lng bit (18) unaligned, /* length of linkage section */ 3 49 2 segno_pad bit (18) unaligned, /* will be segment number of copied linkage */ 3 50 2 static_length bit (18) unaligned; /* length of static section */ 3 51 3 52 3 53 dcl 1 trap_word based aligned, /* trap word in link definition */ 3 54 2 call_ptr bit (18) unal, /* pointer (rel to link) of link to trap procedure */ 3 55 2 arg_ptr bit (18) unal; /* pointer (rel to link) of link to arg info for trap proc */ 3 56 3 57 dcl 1 name based aligned, /* storage of ASCII names in definitions */ 3 58 2 nchars bit (9) unaligned, /* number of characters in name */ 3 59 2 char_string char (31) unaligned; /* 31-character name */ 3 60 3 61 /* END INCLUDE FILE linkdcl.incl.pl1 */ 23 24 25 dcl 1 oi(2) based(optr) aligned like object_info; 26 27 dcl 1 seg based(segptr), 28 2 p(4) pointer, /* segment pointers */ 29 2 sname(2) char(200) aligned; /* segment names */ 30 31 32 dcl differ bit(1) aligned init("0"b); 33 dcl brief bit(1) aligned; 34 35 36 /* Linkage Info for printing */ 37 38 dcl 1 link_info (2) aligned like interpret_link_info; 39 40 41 dcl liptr(2) ptr; 42 dcl lptr(2) pointer; 43 44 dcl rptr(2) pointer; /* relocation pointers */ 45 46 dcl lp(2) pointer; 47 dcl sp(2) pointer; 48 dcl tp(2) pointer; 49 50 dcl relwrd(oi.llng(1)+oi.llng(2)) based(rptr(1)) fixed bin(17); 51 52 dcl even bit(1) aligned init("1"b); 53 dcl last_ne bit(1) aligned init("0"b); 54 55 dcl code fixed bin(17); 56 dcl first bit(1) aligned init("1"b); 57 dcl limit fixed bin(17); 58 dcl loff(2) fixed bin(17); 59 dcl (i,j) fixed bin(17); 60 dcl lword fixed bin(17) based; 61 dcl nwords fixed bin (17); 62 dcl nw(2) fixed bin(17); 63 dcl rname char(14) int static init("compare_object"); 64 dcl start(2) fixed bin(17); 65 dcl word(limit) fixed bin(17) based; 66 67 /* Function Definitions */ 68 69 dcl ioa_ entry options (variable); 70 dcl display_text_ entry(ptr,ptr,fixed bin,fixed bin,fixed bin); 71 dcl com_err_ entry options(variable); 72 dcl interpret_link_$tptr entry(ptr,ptr,ptr,fixed bin); 73 dcl (addr,addrel,divide,fixed,min,size,string,substr) builtin; 74 75 /* INITIALIZE */ 76 77 brief = a_brief; 78 substr(link_info(1).entry_point_name,33,4) = " "; 79 substr(link_info(2).entry_point_name,33,4) = " "; 80 liptr(1) = addr(link_info(1)); 81 liptr(2) = addr(link_info(2)); 82 lp(1) = oi.linkp(1); 83 lp(2) = oi.linkp(2); 84 tp(1) = oi.textp(1); 85 tp(2) = oi.textp(2); 86 87 88 /* COMPARE INTERNAL STATIC */ 89 90 if ^ oi.separate_static(1) 91 then do; 92 do i=1 to 2; 93 nw(i) = fixed(lp(i) -> header.begin_links,18) - size(header); 94 end; 95 96 call comp_stat(lp,size(header)); 97 end; 98 99 /* COMPARE LINKS */ 100 /* zero out relocation bits */ 101 102 rptr(1) = p(3); 103 rptr(2) = addrel(rptr(1),oi.llng(1)); 104 relwrd = 0; 105 106 /* initialize search */ 107 108 first = "1"b; 109 do i = 1 to 2; 110 loff(i) = fixed(lp(i) -> header.begin_links,17); 111 nw(i) = oi.llng(i) - loff(i); 112 end; 113 114 /* Check for same number of links */ 115 116 if nw(1) = nw(2) then limit = nw(1); 117 else 118 do; 119 limit = min(nw(1),nw(2)); 120 differ = "1"b; 121 call ioa_("^/**^a has ^d words of links while ^a has ^d words of links.", 122 sname(1),nw(1),sname(2),nw(2)); 123 end; 124 125 /* MAIN COMPARISON LOOP */ 126 127 do i = 1 to limit; 128 lptr(1) = addrel(lp(1),loff(1)); 129 lptr(2) = addrel(lp(2),loff(2)); 130 if even then /* if even we have to look for ft2 flags */ 131 do; 132 if lptr(1)->link.ft2 ^= lptr(2)->link.ft2 then go to odd; 133 if lptr(1)->link.ft2 ^= "100110"b then go to odd; 134 135 /* We've found 2 link pairs */ 136 137 if last_ne then call badtext; 138 do j = 1 to 2; 139 link_info(j).version = INTERPRET_LINK_INFO_VERSION_1; 140 call interpret_link_$tptr(liptr(j),lptr(j),tp(j),code); 141 if code ^= 0 then 142 do; 143 call com_err_(code,rname,sname(j)); 144 go to return; 145 end; 146 end; 147 if string(link_info(1)) ^= string(link_info(2)) then 148 do; 149 differ = "1"b; 150 if ^brief then 151 do; 152 if first then call title; 153 do j = 1 to 2; 154 call ioa_("^a(^o):^-^a^a^a^a^a", 155 sname (j), loff (j), 156 link_info (j).segment_name, 157 link_info (j).entry_point_name, 158 link_info (j).expression, 159 link_info (j).modifier, 160 link_info (j).trap); 161 end; 162 call ioa_("^/"); 163 end; 164 end; 165 i = i + 1; 166 loff(1) = loff(1) + 2; 167 loff(2) = loff(2) + 2; 168 end; 169 170 /* We have plain text (entry sequences) to check */ 171 172 else 173 odd: do; 174 if last_ne then if lptr(1)->lword=lptr(2)->lword then call badtext; 175 else; 176 else if lptr(1)->lword ^= lptr(2)->lword then 177 do; 178 last_ne = "1"b; 179 start(1) = loff(1); 180 start(2) = loff(2); 181 end; 182 even = ^even; 183 loff(1) = loff(1) + 1; 184 loff(2) = loff(2) + 1; 185 end; 186 end; 187 if last_ne then call badtext; 188 /* RETURN SECTION */ 189 190 return: a_diff = differ; 191 return; 192 193 /* COMPARE STATIC */ 194 195 compare_static_: entry(optr,a_diff,a_brief,segptr); 196 197 brief = a_brief; 198 sp(1) = oi.statp(1); 199 sp(2) = oi.statp(2); 200 nw(1) = oi.ilng(1); 201 nw(2) = oi.ilng(2); 202 call comp_stat(sp,0); 203 a_diff = differ; 204 return; 205 206 /* COMP_STAT */ 207 208 comp_stat: proc(pt,inc); 209 210 dcl (p(2),pt(2)) ptr; 211 dcl inc fixed bin; 212 213 p(1) = pt(1); 214 p(2) = pt(2); 215 216 if nw(1) = nw(2) 217 then limit = nw(1) + inc; 218 else do; 219 limit = min(nw(1),nw(2)) + inc; 220 differ = "1"b; 221 call ioa_("^/**Internal static for ^a has ^d words while that of ^a has ^d words.", 222 sname(1),nw(1),sname(2),nw(2)); 223 end; 224 225 do i = inc + 1 to limit; 226 if p(1) -> word(i) ^= p(2) -> word(i) 227 then do; 228 differ = "1"b; 229 if ^ brief 230 then do; 231 if first 232 then do; 233 first = "0"b; 234 call ioa_ 235 ("^/**Internal Static Discrepancies^/^/Location^-^-^2xSegment 1^-^2xSegment 2^/"); 236 end; 237 call ioa_("^o^-^-^w^-^w",i-1,p(1)->word(i),p(2)->word(i)); 238 end; 239 end; 240 end; 241 242 end; 243 244 /* BADTEXT */ 245 246 badtext: proc; 247 nwords = loff(1) - start(1); 248 last_ne = "0"b; 249 differ = "1"b; 250 if ^brief then 251 do; 252 if first then call title; 253 do j = 1 to 2; 254 call ioa_("^/^a:",sname(j)); 255 call display_text_(lp(j),rptr(j),start(j),nwords,oi.llng(j)); 256 end; 257 call ioa_("^/"); 258 end; 259 end; 260 261 /* TITLE */ 262 263 title: proc; 264 first = "0"b; 265 call ioa_("^/**Link discrepancies have been found.^/"); 266 end; 267 268 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 06/03/83 1330.4 compare_link_.pl1 >special_ldd>on>06/03/83-1>compare_link_.pl1 19 1 08/05/77 1022.5 object_info.incl.pl1 >ldd>include>object_info.incl.pl1 22 2 06/03/83 1330.6 interpret_link_info.incl.pl1 >special_ldd>on>06/03/83-1>interpret_link_info.incl.pl1 23 3 10/13/77 1545.6 linkdcl.incl.pl1 >ldd>include>linkdcl.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. INTERPRET_LINK_INFO_VERSION_1 000000 constant char(8) initial unaligned dcl 2-13 ref 139 a_brief parameter bit(1) unaligned dcl 16 ref 10 77 195 197 a_diff parameter bit(1) unaligned dcl 15 set ref 10 190* 195 203* addr builtin function dcl 73 ref 80 81 addrel builtin function dcl 73 ref 103 128 129 begin_links 6 based bit(18) level 3 packed unaligned dcl 3-30 ref 93 110 brief 000101 automatic bit(1) dcl 33 set ref 77* 150 197* 229 250 code 000420 automatic fixed bin(17,0) dcl 55 set ref 140* 141 143* com_err_ 000020 constant entry external dcl 71 ref 143 differ 000100 automatic bit(1) initial dcl 32 set ref 32* 120* 149* 190 203 220* 228* 249* display_text_ 000016 constant entry external dcl 70 ref 255 entry_point_name 12 000102 automatic char(260) array level 2 dcl 38 set ref 78* 79* 154* even 000416 automatic bit(1) initial dcl 52 set ref 52* 130 182* 182 expression 113 000102 automatic char(8) array level 2 dcl 38 set ref 154* first 000421 automatic bit(1) initial dcl 56 set ref 56* 108* 152 231 233* 252 264* fixed builtin function dcl 73 ref 93 110 format 24 based structure array level 2 dcl 25 ft2 0(30) based bit(6) level 2 packed unaligned dcl 3-9 ref 132 132 133 header based structure level 1 dcl 3-30 ref 93 96 96 i 000426 automatic fixed bin(17,0) dcl 59 set ref 92* 93 93* 109* 110 110 111 111 111* 127* 165* 165* 225* 226 226 237 237 237* ilng 21 based fixed bin(17,0) array level 2 dcl 25 ref 200 201 inc parameter fixed bin(17,0) dcl 211 ref 208 216 219 225 interpret_link_$tptr 000022 constant entry external dcl 72 ref 140 interpret_link_info based structure level 1 dcl 2-5 ioa_ 000014 constant entry external dcl 69 ref 121 154 162 221 234 237 254 257 265 j 000427 automatic fixed bin(17,0) dcl 59 set ref 138* 139 140 140 140 143* 153* 154 154 154 154 154 154 154* 253* 254 255 255 255 255* last_ne 000417 automatic bit(1) initial dcl 53 set ref 53* 137 174 178* 187 248* limit 000422 automatic fixed bin(17,0) dcl 57 set ref 116* 119* 127 216* 219* 225 link based structure level 1 dcl 3-9 link_info 000102 automatic structure array level 1 dcl 38 set ref 80 81 147 147 linkp 6 based pointer array level 2 dcl 25 ref 82 83 liptr 000366 automatic pointer array dcl 41 set ref 80* 81* 140* llng 20 based fixed bin(17,0) array level 2 dcl 25 set ref 103 104 104 111 255* loff 000424 automatic fixed bin(17,0) array dcl 58 set ref 110* 111 128 129 154* 166* 166 167* 167 179 180 183* 183 184* 184 247 lp 000402 automatic pointer array dcl 46 set ref 82* 83* 93 96* 110 128 129 255* lptr 000372 automatic pointer array dcl 42 set ref 128* 129* 132 132 133 140* 174 174 176 176 lword based fixed bin(17,0) dcl 60 ref 174 174 176 176 min builtin function dcl 73 ref 119 219 modifier 115 000102 automatic char(4) array level 2 dcl 38 set ref 154* nw 000432 automatic fixed bin(17,0) array dcl 62 set ref 93* 111* 116 116 116 119 119 121* 121* 200* 201* 216 216 216 219 219 221* 221* nwords 000430 automatic fixed bin(17,0) dcl 61 set ref 247* 255* object_info based structure level 1 dcl 1-6 oi based structure array level 1 dcl 25 optr parameter pointer dcl 14 ref 10 82 83 84 85 90 103 104 104 111 195 198 199 200 201 255 p 000446 automatic pointer array dcl 210 in procedure "comp_stat" set ref 213* 214* 226 226 237 237 p based pointer array level 2 in structure "seg" dcl 27 in procedure "compare_link_" ref 102 pt parameter pointer array dcl 210 ref 208 213 214 relwrd based fixed bin(17,0) array dcl 50 set ref 104* rname 000010 internal static char(14) initial unaligned dcl 63 set ref 143* rptr 000376 automatic pointer array dcl 44 set ref 102* 103* 103 104 255* seg based structure level 1 unaligned dcl 27 segment_name 2 000102 automatic char(32) array level 2 dcl 38 set ref 154* segptr parameter pointer dcl 17 ref 10 102 121 121 143 154 195 221 221 254 separate_static 24(06) based bit(1) array level 3 packed unaligned dcl 25 ref 90 size builtin function dcl 73 ref 93 96 96 sname 10 based char(200) array level 2 dcl 27 set ref 121* 121* 143* 154* 221* 221* 254* sp 000406 automatic pointer array dcl 47 set ref 198* 199* 202* start 000434 automatic fixed bin(17,0) array dcl 64 set ref 179* 180* 247 255* statp 10 based pointer array level 2 dcl 25 ref 198 199 stats 6 based structure level 2 dcl 3-30 string builtin function dcl 73 ref 147 147 substr builtin function dcl 73 set ref 78* 79* textp 2 based pointer array level 2 dcl 25 ref 84 85 tp 000412 automatic pointer array dcl 48 set ref 84* 85* 140* trap 116 000102 automatic char(48) array level 2 dcl 38 set ref 154* version 000102 automatic char(8) array level 2 dcl 38 set ref 139* word based fixed bin(17,0) array dcl 65 set ref 226 226 237* 237* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. divide builtin function dcl 73 exp_word based structure level 1 dcl 3-20 interpret_link_info_ptr automatic pointer dcl 2-15 name based structure level 1 dcl 3-57 object_info_version_2 internal static fixed bin(17,0) initial dcl 1-60 trap_word based structure level 1 dcl 3-53 type_pair based structure level 1 dcl 3-24 virgin_linkage_header based structure level 1 dcl 3-41 NAMES DECLARED BY EXPLICIT CONTEXT. badtext 001133 constant entry internal dcl 246 ref 137 174 187 comp_stat 000741 constant entry internal dcl 208 ref 96 202 compare_link_ 000161 constant entry external dcl 10 compare_static_ 000702 constant entry external dcl 195 odd 000640 constant label dcl 172 ref 132 133 return 000672 constant label dcl 190 ref 144 title 001247 constant entry internal dcl 263 ref 152 252 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1372 1416 1302 1402 Length 1650 1302 24 216 67 4 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME compare_link_ 472 external procedure is an external procedure. comp_stat internal procedure shares stack frame of external procedure compare_link_. badtext internal procedure shares stack frame of external procedure compare_link_. title internal procedure shares stack frame of external procedure compare_link_. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 rname compare_link_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME compare_link_ 000100 differ compare_link_ 000101 brief compare_link_ 000102 link_info compare_link_ 000366 liptr compare_link_ 000372 lptr compare_link_ 000376 rptr compare_link_ 000402 lp compare_link_ 000406 sp compare_link_ 000412 tp compare_link_ 000416 even compare_link_ 000417 last_ne compare_link_ 000420 code compare_link_ 000421 first compare_link_ 000422 limit compare_link_ 000424 loff compare_link_ 000426 i compare_link_ 000427 j compare_link_ 000430 nwords compare_link_ 000432 nw compare_link_ 000434 start compare_link_ 000446 p comp_stat THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ display_text_ interpret_link_$tptr ioa_ NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 32 000145 52 000146 53 000150 56 000151 10 000154 77 000167 78 000175 79 000177 80 000200 81 000202 82 000204 83 000210 84 000212 85 000214 90 000216 92 000221 93 000227 94 000236 96 000240 102 000244 103 000251 104 000256 108 000271 109 000273 110 000301 111 000307 112 000317 116 000321 119 000326 120 000332 121 000334 127 000372 128 000401 129 000405 130 000411 132 000413 133 000422 137 000424 138 000427 139 000435 140 000442 141 000461 143 000463 144 000511 146 000512 147 000514 149 000520 150 000522 152 000524 153 000527 154 000535 161 000616 162 000620 165 000633 166 000634 167 000636 168 000637 174 000640 175 000646 176 000647 178 000652 179 000654 180 000656 182 000660 183 000663 184 000664 186 000665 187 000667 190 000672 191 000677 195 000700 197 000710 198 000716 199 000722 200 000724 201 000726 202 000730 203 000733 204 000740 208 000741 213 000743 214 000746 216 000751 219 000757 220 000764 221 000766 225 001023 226 001035 228 001043 229 001045 231 001047 233 001051 234 001052 237 001066 240 001130 242 001132 246 001133 247 001134 248 001137 249 001140 250 001142 252 001144 253 001147 254 001155 255 001201 256 001231 257 001233 259 001246 263 001247 264 001250 265 001251 266 001265 ----------------------------------------------------------- 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