COMPILATION LISTING OF SEGMENT lisp_cg_utility_ Compiled by: Multics PL/I Compiler, Release 28b, of April 11, 1983 Compiled at: Honeywell LCPD Phoenix, System M Compiled on: 06/30/83 0842.4 mst Thu Options: map single_symbol_list 1 /* ************************************************************** 2* * * 3* * Copyright, (C) Massachusetts Institute of Technology, 1973 * 4* * * 5* ************************************************************** */ 6 /* protect old protection notice */ 7 /* (c) Copyright 1973, Massachusetts Institute of Technology. 8* All rights reserved. */ 9 10 lisp_cg_utility_: /* procedure to make object segment for lisp compiler */ 11 procedure(a_segname, a_codelist, gen_version, source_seg_list, fixnum_list, 12 flonum_list, string_list, bignum_list, atsym_list, cons_list, 13 entry_list, constant_list, link_list, action_list, 14 array_link_list, pl1_link_list); 15 16 /* makes the obj seg out of various lists */ 17 /* D. Reed 11/11/72 */ 18 /* Modified 74.06.14 by DAM for new arrays. This adds one more argument */ 19 /* again 74.09.29 by DAM for the defpl1 feature. This provides the ability 20* to create links and have relocatable text */ 21 /* modified 74.11.14 by DAM to make relocation work properly and to 22* be called via defpl1, which eliminates any number of bugs */ 23 24 dcl a_segname char(*) parameter, 25 segname char(length(a_segname)) init(a_segname), 26 gen_version char(*) parameter, 27 a_codelist fixed bin(71) parameter, 28 a_codelist_p pointer aligned based(addr(a_codelist)), 29 source_seg_list fixed bin(71) parameter, 30 source_seg_list_p pointer aligned based(addr(source_seg_list)), 31 fixnum_list fixed bin(71) parameter, 32 fixnum_list_p pointer aligned based(addr(fixnum_list)), 33 flonum_list fixed bin(71) parameter, 34 flonum_list_p pointer aligned based(addr(flonum_list)), 35 string_list fixed bin(71) parameter, 36 string_list_p pointer aligned based(addr(string_list)), 37 bignum_list fixed bin(71) parameter, 38 bignum_list_p pointer aligned based(addr(bignum_list)), 39 atsym_list fixed bin(71) parameter, 40 atsym_list_p pointer aligned based(addr(atsym_list)), 41 cons_list fixed bin(71) parameter, 42 cons_list_p pointer aligned based(addr(cons_list)), 43 entry_list fixed bin(71) parameter, 44 entry_list_p pointer aligned based(addr(entry_list)), 45 constant_list fixed bin(71) parameter, 46 constant_list_p pointer aligned based(addr(constant_list)), 47 link_list fixed bin(71) parameter, 48 link_list_p pointer aligned based(addr(link_list)), 49 action_list fixed bin(71) parameter, 50 action_list_p pointer aligned based(addr(action_list)), 51 array_link_list fixed bin(71) parameter, 52 array_link_list_p pointer aligned based(addr(array_link_list)), 53 pl1_link_list fixed bin(71) parameter, 54 pl1_link_list_p pointer aligned based(addr(pl1_link_list)); 55 dcl codelist fixed bin(71) automatic, 56 codelist_p pointer aligned based(addr(codelist)); 57 58 dcl cleanup condition; 59 60 dcl object_pointer ptr, 61 def_ptr ptr, 62 defsect ptr, 63 link_ptr ptr, 64 link_head_ptr ptr, 65 symbol_ptr ptr, 66 rel_bits_ptr ptr, 67 map_ptr ptr, 68 area_top ptr, 69 blockp ptr, 70 thingp ptr, 71 symrtp ptr, 72 total_objects fixed bin(18), 73 total_block_size fixed bin(18), 74 75 codeitem fixed bin(71), 76 77 rh_reloc fixed bin(5), 78 relbits_length fixed bin(18), 79 absolute_counter fixed bin(18), 80 link_list_count fixed bin, 81 link_list_ptr pointer, 82 (segmentname, entryname) char(32) varying, 83 (segmentname_relp, entryname_relp) bit(18), 84 segname_length fixed bin, 85 def_length_in_words fixed bin(18), 86 text_length fixed bin(18), 87 ic fixed bin(18), 88 stat_length fixed bin(18), 89 def_length fixed bin(18), 90 code fixed bin(35), 91 acinfo ptr init(null()), 92 93 last_def bit(18), 94 next_def bit(18), 95 (lcp_semant_$symbol_table, 96 lcp_cg_$symbol_table) ext fixed bin, 97 98 text_section dim(0:262143) bit(36) aligned based (object_pointer), 99 1 word_overlay based aligned, 100 2 typ_information bit(36) aligned, 101 2 word bit(36) aligned, 102 1 def_hdr based(def_ptr) aligned, 103 2 def_list bit(18) unal, 104 2 unused bit(36) unal, 105 2 flags like definition.flags unaligned, 106 2 the_rest bit(3) unal, 107 2 end_chain bit(36) unal, /* zero word to end the definition chain. */ 108 2 segname_def like definition aligned, 109 110 1 definition based(def_ptr) aligned, 111 2 fore_thread bit(18) unal, 112 2 back_thread bit(18) unal, 113 2 value bit(18) unal, 114 2 flags unal, 115 3 new_format bit(1), 116 3 ignore bit(1), 117 3 entrypoint bit(1), 118 3 retain bit(1), 119 3 descr_sw bit(1), 120 3 padding bit(10), 121 2 class bit(3) unal, 122 2 symbol_ptr bit(18) unal, 123 2 segname_ptr bit(18) unal, 124 2 symbol aligned, 125 3 len fixed bin(8) unal, 126 3 acc char(512) unal, /* can't use refer here... */ 127 1 accstring based aligned like definition.symbol, 128 1 link_hdr based(link_ptr) aligned, 129 2 fword bit(36), 130 2 def_section bit(18) unal, 131 2 first_reference bit(18) unal, 132 2 section_thread ptr, 133 2 linkage_ptr ptr, 134 2 begin_links bit(18) unal, 135 2 section_length bit(18) unal, 136 2 object_seg bit(18) unal, 137 2 combined_length bit(18) unal, 138 2 internal_static dim(0:262135) bit(36) aligned, 139 1 symbol_block based(symbol_ptr) aligned, 140 2 dcl_vers fixed bin, 141 2 identifier char(8), 142 2 gen_version_number fixed bin, 143 2 gen_creation_time fixed bin(71), 144 2 object_creation_time fixed bin(71), 145 2 generator char(8), 146 2 gen_version_name like stringpointer, 147 2 userid like stringpointer, 148 2 comment like stringpointer, 149 2 text_boundary fixed bin(17) unal, 150 2 stat_boundary fixed bin(17) unal, 151 2 source_map bit(18) unal, 152 2 area_pointer bit(18) unal, 153 2 sectionbase_backpointer bit(18) unal, 154 2 block_size bit(18) unal, 155 2 next_block_thread bit(18) unal, 156 2 rel_text bit(18) unal, 157 2 rel_def bit(18) unal, 158 2 rel_link bit(18) unal, 159 2 rel_symbol bit(18) unal, 160 2 default_truncate bit(18) unal, 161 2 optional_truncate bit(18) unal, 162 2 user_name char(32), /* userid above locates this */ 163 2 version_string char(64), /* gen_version_name above locates this */ 164 1 relocation_bits based(rel_bits_ptr) aligned, 165 2 dcl_vers fixed bin, 166 2 relbits bit(131072) varying, /* based varying bit string.... */ 167 1 object_map based (map_ptr) aligned, 168 2 dcl_vers fixed bin, 169 2 identifier char(8), 170 2 text_offset bit(18) unal, 171 2 text_length bit(18) unal, 172 2 definition_offset bit(18) unal, 173 2 definition_length bit(18) unal, 174 2 linkage_offset bit(18) unal, 175 2 linkage_length bit(18) unal, 176 2 symbol_offset bit(18) unal, 177 2 symbol_length bit(18) unal, 178 2 bmap_offset bit(18) unal, 179 2 bmap_length bit(18) unal, 180 2 format unal, 181 3 bound bit(1), 182 3 relocatable bit(1), 183 3 procedure bit(1), 184 3 standard bit(1), 185 3 unused bit(32), 186 2 map_offset bit(18) aligned, 187 188 189 1 stringpointer based aligned, 190 2 offset fixed bin(17) unal, 191 2 length fixed bin(17) unal; 192 193 dcl 1 source_map based aligned, 194 2 version fixed bin, /* 1 */ 195 2 size fixed bin, /* number of entries to follow */ 196 2 map( source_map_size refer(source_map.size)), 197 3 pathname like stringpointer, /* relp/length of pathname string */ 198 3 uid bit(36) aligned, /* source-segment unique id */ 199 3 dtm fixed bin(71), /* source-segment dtm */ 200 smdn char(168), 201 smen char(32), 202 smstr char(source_seg_list_p -> cons_ptrs.car -> lisp_string.string_length) unaligned based, 203 source_map_size fixed bin; 204 205 206 dcl 1 expression_word based aligned, 207 2 type_pair_relp bit(18) unaligned, 208 2 expression fixed bin(17) unaligned, 209 210 1 type_pair based aligned, 211 2 type fixed bin(17) unaligned, 212 2 trap_relp bit(18) unaligned, 213 2 segmentname_relp bit(18) unaligned, 214 2 entryname_relp bit(18) unaligned, 215 216 1 link_pair based aligned, 217 2 header_relp bit(18) unaligned, 218 2 ignore1 bit(12) unaligned, 219 2 fault_tag_2 bit(6) unaligned, 220 2 expression_relp bit(18) unaligned, 221 2 ignore2 bit(18) unaligned; 222 223 dcl expression_word_table(100) bit(18) aligned; 224 225 226 227 228 229 dcl get_wdir_ entry returns(char(168)aligned), 230 get_pdir_ entry returns(char(168)aligned), 231 get_dir_ entry variable returns(char(168)aligned), 232 get_group_id_ entry returns(char(32) aligned), 233 clock_ entry returns(fixed bin(71)), 234 235 com_err_ entry options(variable), 236 cu_$cl entry, 237 tssi_$get_segment entry (char(*), char(*), ptr, ptr, fixed bin(35)), 238 tssi_$clean_up_segment entry(ptr), 239 tssi_$finish_segment entry(ptr, fixed bin(24), bit(36) aligned, ptr, fixed bin(35)), 240 241 expand_path_ entry(pointer, fixed bin(17), pointer, pointer, fixed bin(35)), 242 hcs_$status_long entry(char(*), char(*), fixed bin(1), pointer, pointer, fixed bin(35)), 243 1 hcs_status_long_str aligned structure, 244 2 ( type bit(2), /* 00 link 01 segment 10 directory */ 245 nnames bit(16), /* number of names */ 246 nrp bit(18), /* names rel ptr */ 247 dtm bit(36), /* date time modified */ 248 dtu bit(36), /* date time used */ 249 mode bit(5), /* effective access */ 250 pad1 bit(13), 251 records bit(18), /* records used */ 252 dtd bit(36), /* date time dumped */ 253 dtem bit(36), /* date time entry modified */ 254 pad2 bit(36), 255 curlen bit(12), /* current length */ 256 bitcnt bit(24), /* bit count */ 257 did bit(4), /* device id */ 258 pad3 bit(4), 259 copysw bit(1), /* copy switch */ 260 pad4 bit(9), 261 rbs (0:2) bit(6), /* ring brackets */ 262 uid bit(36) /* unique id */ 263 ) unaligned; 264 265 dcl (addr, addrel, after, before, bit, divide, fixed, hbound, index, length, 266 max, mod, null, rel, size, string, substr, unspec) builtin; 267 1 1 /* MACLISP symbol section for compiled SUBR */ 1 2 1 3 dcl 1 symbol_root based aligned, /* starts off the LISP symbol section */ 1 4 1 5 2 version fixed bin, /* 2 for this dcl (new-arrays version) */ 1 6 2 number_objects fixed bin, /* number of objects which are to be made at fasload time */ 1 7 2 objects unal, 1 8 3 fixnum_blockp bit(18) unal, /* pointers to blocks describing variaous type classes of objects */ 1 9 3 flonum_blockp bit(18) unal, 1 10 3 string_blockp bit(18) unal, 1 11 3 bignum_blockp bit(18) unal, 1 12 3 atsym_blockp bit(18) unal, 1 13 3 cons_blockp bit(18) unal, 1 14 2 subr_block_size fixed bin(18), /* number of double word items to be put in subr block */ 1 15 2 subr_block_items unal, /* pointers to blocks indicating which objects to place in subr block */ 1 16 3 entry_blockp bit(18) unal, 1 17 3 const_blockp bit(18) unal, 1 18 3 links_blockp bit(18) unal, 1 19 2 action_blockp bit(18) unal, /* points to array of operations to be done at fasload time, in order */ 1 20 2 array_links_blockp bit(18) unal; /* points at block of array links */ 1 21 1 22 1 23 dcl 1 fixnum_block based aligned, 1 24 2 count fixed bin(18), 1 25 2 fixnums(0 refer(fixnum_block.count)) fixed bin(35); 1 26 1 27 dcl 1 flonum_block based aligned, 1 28 2 count fixed bin(18), 1 29 2 flonums(0 refer(flonum_block.count)) float bin(27); 1 30 1 31 dcl 1 string_block based aligned, 1 32 2 count fixed bin(18), 1 33 2 string_offset(0 refer(string_block.count)) bit(18) unal; /* pointers to string representation */ 1 34 1 35 1 36 dcl 1 atsym_block based aligned, 1 37 2 count fixed bin(18), 1 38 2 atsym_offset(0 refer(atsym_block.count)) bit(18) unal; /* pointers to atom names */ 1 39 1 40 dcl 1 bignum_block based aligned, 1 41 2 count fixed bin(18), 1 42 2 bignum_offsets(0 refer(bignum_block.count)) bit(18) unal; 1 43 1 44 dcl 1 cons_block based aligned, 1 45 2 count fixed bin(18), 1 46 2 conses(0 refer(cons_block.count)) unal, 1 47 3 car bin(17), 1 48 3 cdr bin(17); 1 49 1 50 dcl 1 string_chars based aligned, 1 51 2 flags unal, 1 52 3 uninterned_atom bit(1), 1 53 3 padding bit(10), 1 54 2 length fixed bin(24)unal, 1 55 2 chars char(0 refer (string_chars.length)) unaligned; 1 56 1 57 dcl 1 entry_block based aligned, 1 58 2 count fixed bin(18), 1 59 2 entry_info(0 refer(entry_block.count)) unal, 1 60 3 nargs bit(18), 1 61 3 entrypoint bit(18); 1 62 1 63 dcl 1 const_block based aligned, 1 64 2 count fixed bin(18), 1 65 2 constants (0 refer(const_block.count)) fixed bin(17) unal; 1 66 1 67 dcl 1 links_block based aligned, 1 68 2 count fixed bin(18), 1 69 2 link_info(0 refer(links_block.count)) bit(27); 1 70 1 71 dcl 1 array_links_block based aligned, 1 72 2 count fixed bin(18), 1 73 2 array_link(0 refer(array_links_block.count)), 1 74 3 control_word bit(36); /* rest is filled in at load time. 1 75* this word has type, ndims, symbol offset. */ 1 76 1 77 dcl 1 action_block based aligned, 1 78 2 count fixed bin(18), 1 79 2 actions(0 refer(action_block.count)) unal, /* each action described as one of these objects */ 1 80 3 action_code fixed bin(17) unal, 1 81 3 operand fixed bin(17) unal; /* offset of constant which is used in operation */ 1 82 1 83 /* End of description of MACLISP Compiled symbol tree */ 268 2 1 /* Include file lisp_bignum_fmt.incl.pl1 */ 2 2 2 3 dcl 1 lisp_bignum based aligned, /* structure describing lisp big number */ 2 4 2 sign bit(18) unaligned, /* either all ones, or all zeros */ 2 5 2 prec fixed bin(17) unaligned, /* number of words in this number's precision */ 2 6 2 words(0 refer(lisp_bignum.prec)) fixed bin(35); /* 35 significant bits per word. */ 2 7 2 8 /* End include file lisp_bognum_fmt.incl.pl1 */ 269 3 1 /* lisp number format -- overlaid on standard its pointer. */ 3 2 3 3 3 4 dcl 1 fixnum_fmt based aligned, 3 5 2 type_info bit(36) aligned, 3 6 2 fixedb fixed bin, 3 7 3 8 1 flonum_fmt based aligned, 3 9 2 type_info bit(36) aligned, 3 10 2 floatb float bin, 3 11 3 12 fixnum_type bit(36) aligned static init("000000000000000000000100000000100111"b), 3 13 flonum_type bit(36) aligned static init("000000000000000000000010000000100111"b); 3 14 3 15 /* end of lisp number format */ 3 16 270 4 1 /* Include file lisp_ptr_fmt.incl.pl1; 4 2* describes the format of lisp pointers as 4 3* a bit string overlay on the double word ITS pair 4 4* which allows lisp to access some unused bits in 4 5* the standard ITS pointer format. It should be noted that 4 6* this is somewhat of a kludge, since 4 7* it is quite machine dependent. However, to store type 4 8* fields in the pointer, saves 2 words in each cons, 4 9* plus some efficiency problems. 4 10* 4 11* D.Reed 4/1/71 */ 4 12 /* modified to move type field to other half of ptr */ 4 13 /* D.Reed 5/31/72 */ 4 14 4 15 4 16 dcl based_ptr ptr aligned based; /* for dealing with lisp values as pointers */ 4 17 dcl lisp_ptr_type bit(36) aligned based, /* for more efficient checking of type bits */ 4 18 1 lisp_ptr based aligned, /* structure of double word pointer in lisp */ 4 19 2 segno bit(18) unaligned, /* segment number pointed to by pointer */ 4 20 2 ringnum bit(3) unaligned, /* ring mumber for validation */ 4 21 2 type bit(9) unaligned, /* type field */ 4 22 2 itsmod bit(6) unaligned, 4 23 2 offset fixed bin(17) unaligned, /* offset in segment of object pointed to */ 4 24 2 chain bit(18) unaligned, /* normally 0, but may be set to chain pointers together */ 4 25 4 26 /* manifest constant strings for testing above type field */ 4 27 4 28 ( 4 29 Cons init("000000000"b), /* a pointer to a list has a zero type field */ 4 30 Fixed init("100000000"b), /* a fixed point number, stored in second word of the ptr */ 4 31 Float init("010000000"b), /* a floating number, also stored in the second word of the ptr */ 4 32 Atsym init("001000000"b), /* this bit on means a ptr to an atomic symbol */ 4 33 Atomic init("111111111"b), /* any bit on means an atomic data type */ 4 34 Bignum init("000001000"b), /* a multiple-precision number */ 4 35 Bigfix init("000001000"b), /* a fixed point bignum (only kind for now) */ 4 36 Numeric init("110000000"b), /* either type immediate number. Both bits on 4 37* means a special internal uncollectable weird object */ 4 38 Uncollectable init("110000000"b), /* not looked through by garbage collector */ 4 39 String init("000100000"b), /* pointer to lisp character string - length word, chars */ 4 40 Subr init("000010000"b), /* pointer to compiled (or builtin) subroutine (linkage) code */ 4 41 System_Subr init("000000100"b), /* Subr bit must be on too, indicates ptr into lisp_subr_tv_ */ 4 42 Array init("000000010"b), /* Subr bit must be on too, indicates ptr to a lisp array */ 4 43 File init("000000001"b) /* pointer to a file object (iochan block) */ 4 44 ) bit(9) static, 4 45 4 46 /* 36 bit manifest constant strings for testing lisp_ptr_type */ 4 47 4 48 4 49 ( 4 50 Cons36 init("000000000000000000000000000000"b), 4 51 Fixed36 init("000000000000000000000100000000"b), 4 52 Float36 init("000000000000000000000010000000"b), 4 53 Atsym36 init("000000000000000000000001000000"b), 4 54 Atomic36 init("000000000000000000000111111100"b), 4 55 Bignum36 init("000000000000000000000000001000"b), 4 56 System_Subr36 4 57 init("000000000000000000000000000100"b), 4 58 Bigfix36 init("000000000000000000000000001000"b), 4 59 Numeric36 init("000000000000000000000110000000"b), /* does not check for bignum */ 4 60 NotConsOrAtsym36 4 61 init("000000000000000000000110111111"b), 4 62 SubrNumeric36 4 63 init("000000000000000000000110010000"b), /* used in garbage collector, for quick check */ 4 64 String36 init("000000000000000000000000100000"b), 4 65 Subr36 init("000000000000000000000000010000"b), 4 66 File36 init("000000000000000000000000000001"b), 4 67 Array36 init("000000000000000000000000000010"b)) bit(36) aligned static, 4 68 4 69 /* undefined pointer value is double word of zeros */ 4 70 4 71 Undefined bit(72) static init(""b); 4 72 4 73 /* end of include file lisp_ptr_fmt.incl.pl1 */ 271 5 1 /***** BEGIN INCLUDE FILE lisp_string_fmt.incl.pl1 ***** 5 2* describes format of storage for lisp 5 3* character strings. 5 4* D. Reed 4/1/71 */ 5 5 5 6 dcl 1 lisp_string based aligned, 5 7 2 string_length fixed bin, 5 8 2 string char(1 refer(string_length)); 5 9 5 10 /***** END INCLUDE FILE lisp_string_fmt.incl.pl1 */ 272 6 1 /* Include file lisp_atom_fmt.incl.pl1; 6 2* describes internal format of atoms in the lisp system 6 3* D.Reed 4/1/71 */ 6 4 6 5 dcl 1 atom aligned based, /* overlay for atom fomat */ 6 6 2 value fixed bin(71), /* atom's value */ 6 7 2 plist fixed bin(71), /* property list */ 6 8 2 pnamel fixed bin, /* length of print name */ 6 9 2 pname char(1 refer(pnamel)), /* print name of atom */ 6 10 6 11 1 atom_ptrs based aligned, /* for use of plist and value of atom as ptrs */ 6 12 2 value ptr, 6 13 2 plist ptr, 6 14 6 15 1 atom_double_words based aligned, /* overlay for atom pointer checking */ 6 16 2 value bit(72), 6 17 2 plist bit(72); 6 18 6 19 /* end of include file lisp_atom_fmt.incl.pl1 */ 273 7 1 /* Include file lisp_cons_fmt.incl.pl1; 7 2* defines the format for a cons within the lisp system 7 3* D.Reed 4/1/71 */ 7 4 7 5 dcl consptr ptr, 7 6 1 cons aligned based (consptr), /* structure defining format for cons */ 7 7 2 car fixed bin(71), 7 8 2 cdr fixed bin(71), 7 9 7 10 1 cons_ptrs aligned based (consptr), /* for using car and cdr as pointers */ 7 11 2 car ptr, 7 12 2 cdr ptr, 7 13 7 14 7 15 1 cons_types aligned based (consptr), /* structure for extracting types out of cons */ 7 16 2 padding bit(21) unaligned, 7 17 2 car bit(9) unaligned, 7 18 2 padding2 bit(63) unaligned, 7 19 2 cdr bit(9) unaligned, 7 20 2 padend bit(42) unaligned; 7 21 7 22 dcl 1 cons_types36 aligned based, 7 23 2 car bit(36), 7 24 2 pada bit(36), 7 25 2 cdr bit(36), 7 26 2 padd bit(36); 7 27 7 28 7 29 /* end include file lisp_cons_fmt.incl.pl1 */ 274 275 276 277 on condition(cleanup) 278 call tssi_$clean_up_segment(acinfo); 279 280 get_dir_ = get_wdir_; /* usual case */ 281 if length(segname) > 5 282 then if substr(segname, 1, 5) = "[pd]>" 283 then do; /* special case - put in process dir */ 284 get_dir_ = get_pdir_; 285 segname = substr(segname, 6); 286 end; 287 288 loop_back: 289 call tssi_$get_segment (get_dir_(), segname, object_pointer, acinfo, code); 290 if object_pointer = null() then do; 291 call com_err_(code, "lisp_cg_utility_", "^a>^a^/Fix it and type start.", get_dir_(), segname); 292 call cu_$cl; /* give loser a chance to recover */ 293 go to loop_back; 294 end; 295 296 297 if pl1_link_list_p -> fixedb > hbound(expression_word_table, 1) 298 then do; 299 call com_err_(0, "lisp_cg_utility_", 300 "Too many outbound links. Compilation aborted."); 301 return; 302 end; 303 304 ic = 0; 305 codelist = a_codelist; /* don't clobber codelist, need later */ 306 do while(addr(codelist) -> lisp_ptr.type = Cons); 307 codeitem = codelist_p -> cons.car; 308 codelist = codelist_p -> cons.cdr; 309 if addr(codeitem) -> lisp_ptr_type & Numeric36 then; 310 else codeitem = addr(codeitem) -> based_ptr -> cons.cdr; /* relocatable */ 311 text_section(ic) = addr(codeitem) -> word_overlay.word; 312 ic = ic + 1; 313 end; 314 315 ic, text_length = 2*divide(ic+1,2,18,0); 316 317 defsect, def_ptr = addr(text_section(ic)); /* get pointer to where to put def section*/ 318 319 /* make definition section */ 320 321 def_hdr.def_list = "000000000000000011"b; /* def hdr immediately followed by first def */ 322 def_hdr.flags.new_format, 323 def_hdr.flags.ignore = "1"b; /* ignore bit must be on in def header. */ 324 325 326 def_hdr.segname_def.symbol.len = length(segname); 327 substr(def_hdr.segname_def.symbol.acc, 1, length(segname)) = segname; 328 def_length_in_words = divide(length(segname),4,17,0) + 7; 329 def_hdr.segname_def.fore_thread = bit(def_length_in_words,18); 330 def_hdr.segname_def.back_thread = "000000000000000010"b; /* pointer to end chain */ 331 def_hdr.segname_def.value = "000000000000000010"b; 332 def_hdr.segname_def.flags.retain, 333 def_hdr.segname_def.flags.new_format = "1"b; 334 def_hdr.segname_def.class = "011"b; /* segname definition */ 335 def_hdr.segname_def.symbol_ptr = "000000000000000110"b; /* 6 offset from beginning of def section */ 336 def_hdr.segname_def.segname_ptr = def_hdr.segname_def.fore_thread; /* defblock ptr actually */ 337 338 339 last_def = "000000000000000011"b; 340 341 def_ptr = addrel(def_ptr, def_length_in_words); /* move on to ename def */ 342 definition.fore_thread = bit(fixed(def_length_in_words+5,18,0),18); 343 definition.back_thread = last_def; 344 definition.value = ""b; 345 definition.flags.new_format, 346 definition.flags.retain = "1"b; 347 definition.class = "000"b; 348 definition.symbol_ptr = bit(fixed(3-text_length+fixed(rel(def_ptr),18,0),18,0),18); 349 definition.segname_ptr = "000000000000000011"b; 350 definition.symbol.len = 7; 351 substr(definition.symbol.acc,1,7) = "*segtop"; 352 last_def = bit(fixed(def_length_in_words,18,0),18); 353 def_length_in_words = 5; 354 def_ptr = addrel(def_ptr, def_length_in_words); /* move along structure */ 355 definition.symbol.len = 12; 356 substr(definition.symbol.acc,1,12) = "symbol_table"; /* the symbol table defn */ 357 definition.fore_thread = "000000000000000010"b; /* points to zero word */ 358 definition.back_thread = last_def; 359 definition.value = ""b; 360 definition.flags.retain, 361 definition.flags.new_format = "1"b; /* all other flags are already zero */ 362 definition.class = "010"b; 363 definition.symbol_ptr = bit(fixed(3-text_length+fixed(rel(def_ptr),18,0),18,0),18); 364 definition.segname_ptr = "000000000000000011"b; /* pointer to segname definition */ 365 def_ptr = addrel(def_ptr, 8); 366 367 /* make cruft for links - expression words, type pairs, names */ 368 369 link_list_count = pl1_link_list_p -> fixedb; 370 link_list_ptr = pl1_link_list_p -> cons_ptrs.cdr; 371 do while (link_list_count > 0); 372 /* segmentname = before(link_list_ptr -> cons_ptrs.car -> lisp_string.string, "$"); COMPILER BUG 373* entryname = after(link_list_ptr -> cons_ptrs.car -> lisp_string.string, "$"); */ 374 dcl iiiii fixed bin; 375 entryname = ""; 376 iiiii = index(link_list_ptr -> cons_ptrs.car -> lisp_string.string, "$"); 377 if iiiii = 0 then iiiii = length(link_list_ptr -> cons_ptrs.car -> lisp_string.string)+1; 378 else entryname = substr(link_list_ptr -> cons_ptrs.car -> lisp_string.string, iiiii+1); 379 segmentname = substr(link_list_ptr -> cons_ptrs.car -> lisp_string.string, 1, iiiii-1); 380 def_ptr -> accstring.len = length(segmentname); 381 substr(def_ptr -> accstring.acc, 1, length(segmentname)) = segmentname; 382 segmentname_relp = ptr_sub(def_ptr, defsect); 383 def_ptr = addrel(def_ptr, divide(length(segmentname)+4,4,18,0)); 384 if entryname = "" then entryname_relp = segmentname_relp; 385 else do; 386 def_ptr -> accstring.len = length(entryname); 387 substr(def_ptr -> accstring.acc, 1, length(entryname)) = entryname; 388 entryname_relp = ptr_sub(def_ptr, defsect); 389 def_ptr = addrel(def_ptr, divide(length(entryname)+4,4,18,0)); 390 end; 391 def_ptr -> type_pair.segmentname_relp = segmentname_relp; 392 def_ptr -> type_pair.entryname_relp = entryname_relp; 393 def_ptr -> type_pair.type = 4; 394 def_ptr -> type_pair.trap_relp = ""b; 395 entryname_relp = ptr_sub(def_ptr, defsect); /* save for a second */ 396 def_ptr = addrel(def_ptr, 2); 397 def_ptr -> expression_word.type_pair_relp = entryname_relp; 398 def_ptr -> expression_word.expression = 0; 399 expression_word_table(link_list_count) = ptr_sub(def_ptr, defsect); 400 def_ptr = addrel(def_ptr, 1); 401 link_list_ptr = link_list_ptr -> cons_ptrs.cdr; 402 link_list_count = link_list_count - 1; 403 end; 404 def_length = fixed(rel(def_ptr), 18) - text_length; 405 if mod(def_length, 2) ^= 0 then def_length = def_length + 1; /* put linkage on double word boundary */ 406 407 /* now make linkage section */ 408 409 link_ptr = addrel(object_pointer,text_length+def_length); 410 link_ptr -> link_hdr.def_section = bit(text_length,18); 411 412 stat_length = 8; /* only exists linkage header */ 413 414 link_ptr -> link_hdr.begin_links, 415 link_ptr -> link_hdr.section_length = bit(stat_length,18); /* no links are present */ 416 link_ptr -> link_hdr.combined_length = ""b; /* obsolete field must be zero or linker screws up */ 417 418 link_head_ptr = link_ptr; 419 link_ptr = addrel(link_ptr, 8); /* skip link header */ 420 link_list_count = pl1_link_list_p -> fixedb; 421 do while(link_list_count > 0); 422 link_ptr -> link_pair.header_relp = ptr_sub(link_head_ptr, link_ptr); 423 link_ptr -> link_pair.fault_tag_2 = "100110"b; 424 link_ptr -> link_pair.expression_relp = expression_word_table(link_list_count); 425 link_ptr = addrel(link_ptr, 2); 426 link_list_count = link_list_count - 1; 427 end; 428 link_head_ptr -> link_hdr.section_length = ptr_sub(link_ptr, link_head_ptr); 429 430 /* now make the symbol section, which is the hard part */ 431 432 symbol_ptr = link_ptr; 433 symbol_block.dcl_vers = 1; 434 symbol_block.identifier = "symbtree"; 435 symbol_block.gen_version_number = 2; 436 symbol_block.gen_creation_time = max(addr(lcp_semant_$symbol_table)->symbol_block.object_creation_time, 437 addr(lcp_cg_$symbol_table)->symbol_block.object_creation_time); 438 symbol_block.object_creation_time = clock_(); 439 symbol_block.generator = "lisp"; 440 symbol_block.gen_version_name.offset = 28; 441 symbol_block.gen_version_name.length = 64; 442 symbol_block.userid.offset = 20; 443 symbol_block.userid.length = 32; 444 symbol_block.comment.offset, symbol_block.comment.length = 0; 445 symbol_block.text_boundary, symbol_block.stat_boundary = 2; 446 symbol_block.sectionbase_backpointer = "0"b; 447 symbol_block.next_block_thread = "0"b; 448 symbol_block.user_name = get_group_id_(); 449 symbol_block.version_string = gen_version; 450 area_top = addrel(symbol_ptr,size(symbol_block)); 451 452 /* create source map */ 453 454 source_map_size = source_seg_list_p -> fixedb; 455 thingp = sym_alloc(size(source_map)); 456 symbol_block.source_map = ptr_sub(thingp, symbol_ptr); 457 thingp -> source_map.version = 1; 458 thingp -> source_map.size = source_map_size; 459 ic = 0; 460 do while(source_map_size > 0); /* process source seg list */ 461 source_map_size = source_map_size - 1; 462 ic = ic + 1; 463 source_seg_list = source_seg_list_p -> cons.cdr; 464 call expand_path_(addr(source_seg_list_p -> cons_ptrs.car -> lisp_string.string), 465 source_seg_list_p -> cons_ptrs.car -> lisp_string.string_length, 466 addr(smdn), 467 addr(smen), 468 code); 469 if code ^= 0 then go to source_map_loss; 470 call hcs_$status_long(smdn, smen, 1 /*chase*/, addr(hcs_status_long_str), null, code); 471 if code ^= 0 then go to source_map_loss; 472 thingp -> source_map.map(ic).uid = hcs_status_long_str.uid; 473 thingp -> source_map.map(ic).dtm = fixed(hcs_status_long_str.dtm || (16)"0"b, 52); 474 source_map_loss: 475 symrtp = sym_alloc(divide(source_seg_list_p -> cons_ptrs.car -> lisp_string.string_length+7,8,17,0)*2); 476 thingp -> source_map.map(ic).pathname.offset = fixed(ptr_sub(symrtp, symbol_ptr), 18); 477 thingp -> source_map.map(ic).pathname.length = source_seg_list_p -> cons_ptrs.car -> lisp_string.string_length; 478 symrtp -> smstr = source_seg_list_p -> cons_ptrs.car -> lisp_string.string; 479 end; 480 481 symrtp = sym_alloc(size(symbol_root)); 482 symbol_block.area_pointer = ptr_sub(symrtp, symbol_ptr); 483 484 /* now make the lisp symbol tree */ 485 486 blockp = sym_alloc(fixnum_list_p -> fixedb+1); /* number of fixnums */ 487 blockp -> fixnum_block.count, total_objects = fixnum_list_p -> fixedb; 488 489 do ic = 1 to blockp -> fixnum_block.count; 490 fixnum_list = fixnum_list_p -> cons.cdr; 491 blockp -> fixnum_block.fixnums(ic) = fixnum_list_p -> fixedb; 492 end; 493 494 symrtp -> symbol_root.objects.fixnum_blockp = ptr_sub(blockp,symrtp); 495 496 497 blockp = sym_alloc(flonum_list_p -> fixedb+1); /* number of flonums */ 498 blockp -> flonum_block.count = flonum_list_p -> fixedb; 499 total_objects = total_objects + blockp -> flonum_block.count; 500 501 do ic = 1 to blockp -> flonum_block.count; 502 flonum_list = flonum_list_p -> cons.cdr; 503 blockp -> flonum_block.flonums(ic) = flonum_list_p -> floatb; 504 end; 505 506 symrtp -> symbol_root.objects.flonum_blockp = ptr_sub(blockp,symrtp); 507 508 509 blockp = sym_alloc(divide(string_list_p ->fixedb+3,2,17,0)); 510 blockp -> string_block.count = string_list_p -> fixedb; 511 total_objects = total_objects + blockp -> string_block.count; 512 513 do ic = 1 to blockp -> string_block.count; 514 515 string_list = string_list_p -> cons.cdr; 516 thingp = sym_alloc(divide(string_list_p -> based_ptr -> lisp_string.string_length+7,4,17,0)); 517 518 blockp -> string_block.string_offset(ic) = ptr_sub(thingp,symrtp); 519 thingp -> string_chars.length = string_list_p -> based_ptr -> lisp_string.string_length; 520 thingp -> string_chars.chars = string_list_p -> based_ptr -> lisp_string.string; 521 522 end; 523 524 symrtp -> symbol_root.objects.string_blockp = ptr_sub(blockp,symrtp); 525 526 527 528 blockp = sym_alloc(divide(bignum_list_p -> fixedb+3,2,18,0)); 529 blockp -> bignum_block.count = bignum_list_p -> fixedb; 530 total_objects = total_objects + blockp -> bignum_block.count; 531 532 do ic = 1 to blockp -> bignum_block.count; 533 bignum_list = bignum_list_p -> cons.cdr; 534 535 thingp = sym_alloc(1+bignum_list_p -> based_ptr -> lisp_bignum.prec); 536 blockp -> bignum_block.bignum_offsets(ic) = ptr_sub(thingp,symrtp); 537 thingp -> lisp_bignum.sign = bignum_list_p -> based_ptr -> lisp_bignum.sign; 538 thingp -> lisp_bignum.prec = bignum_list_p -> based_ptr -> lisp_bignum.prec; 539 thingp -> lisp_bignum.words = bignum_list_p -> based_ptr -> lisp_bignum.words; 540 end; 541 symrtp -> symbol_root.objects.bignum_blockp = ptr_sub(blockp,symrtp); 542 543 544 blockp = sym_alloc(divide(atsym_list_p -> fixedb+3,2,17,0)); 545 blockp -> atsym_block.count = atsym_list_p -> fixedb; 546 total_objects = total_objects + blockp -> atsym_block.count; 547 548 do ic = 1 to blockp -> atsym_block.count; 549 atsym_list = atsym_list_p -> cons.cdr; 550 thingp = sym_alloc(divide(atsym_list_p -> based_ptr -> atom.pnamel+7,4,17,0)); 551 blockp -> atsym_block.atsym_offset(ic) = ptr_sub(thingp,symrtp); 552 thingp -> string_chars.length = atsym_list_p -> based_ptr -> atom.pnamel; 553 thingp -> string_chars.chars = atsym_list_p -> based_ptr -> atom.pname; 554 end; 555 556 symrtp -> symbol_root.objects.atsym_blockp = ptr_sub(blockp,symrtp); 557 558 blockp = sym_alloc(cons_list_p -> fixedb+1); /* size of cons block */ 559 560 blockp -> cons_block.count = cons_list_p -> fixedb; 561 total_objects = total_objects + blockp -> cons_block.count; 562 563 do ic = 1 to blockp -> cons_block.count; 564 cons_list = cons_list_p -> cons.cdr; 565 unspec(blockp -> cons_block.conses(ic)) = cons_list_p -> word_overlay.word; 566 end; 567 568 symrtp -> symbol_root.objects.cons_blockp = ptr_sub(blockp,symrtp); 569 570 blockp = sym_alloc(entry_list_p ->fixedb+1); /* size of entry descriptions */ 571 blockp -> entry_block.count, total_block_size = entry_list_p -> fixedb; 572 573 do ic = 1 to blockp -> entry_block.count; 574 entry_list = entry_list_p -> cons.cdr; 575 string(blockp -> entry_block.entry_info(ic)) = entry_list_p -> word_overlay.word; 576 end; 577 symrtp -> symbol_root.subr_block_items.entry_blockp = ptr_sub(blockp,symrtp); 578 579 blockp = sym_alloc(divide(constant_list_p -> fixedb+3,2,17,0)); 580 blockp -> const_block.count = constant_list_p -> fixedb; 581 total_block_size = total_block_size + blockp -> const_block.count; 582 583 do ic = 1 to blockp -> const_block.count; 584 constant_list = constant_list_p -> cons.cdr; 585 blockp -> const_block.constants(ic) = constant_list_p -> fixedb; 586 end; 587 symrtp -> symbol_root.subr_block_items.const_blockp = ptr_sub(blockp,symrtp); 588 589 blockp = sym_alloc(1+link_list_p -> fixedb); 590 blockp -> links_block.count = link_list_p -> fixedb; 591 total_block_size = total_block_size+blockp -> links_block.count; 592 do ic = 1 to blockp -> links_block.count; 593 link_list = link_list_p -> cons.cdr; 594 blockp -> links_block.link_info(ic)= substr(link_list_p -> word_overlay.word,10,27); 595 end; 596 symrtp -> symbol_root.subr_block_items.links_blockp = ptr_sub(blockp,symrtp); 597 598 blockp = sym_alloc(1+ action_list_p -> fixedb); 599 blockp -> action_block.count = action_list_p -> fixedb; 600 do ic = 1 to blockp -> action_block.count; 601 action_list = action_list_p -> cons.cdr; 602 unspec(blockp -> action_block.actions(ic)) = action_list_p -> word_overlay.word; 603 end; 604 symrtp -> symbol_root.action_blockp = ptr_sub(blockp,symrtp); 605 606 blockp = sym_alloc(1 + array_link_list_p -> fixedb); 607 blockp -> array_links_block.count = array_link_list_p -> fixedb; 608 do ic = 1 to blockp -> array_links_block.count; 609 array_link_list = array_link_list_p -> cons.cdr; 610 blockp -> array_links_block.array_link(ic).control_word = 611 array_link_list_p -> word_overlay.word; 612 end; 613 symrtp -> symbol_root.array_links_blockp = ptr_sub(blockp,symrtp); 614 615 /* now fill in lengths of various items */ 616 617 symrtp -> symbol_root.version = 2; 618 symrtp -> symbol_root.number_objects = total_objects; 619 symrtp -> symbol_root.subr_block_size = total_block_size; 620 621 /* now make up the relocation bits */ 622 623 rel_bits_ptr = area_top; 624 symbol_block.default_truncate, 625 symbol_block.optional_truncate, 626 symbol_block.rel_text = ptr_sub(rel_bits_ptr,symbol_ptr); 627 relocation_bits.dcl_vers = 1; 628 relbits = ""b; 629 absolute_counter = 0; 630 do codelist = a_codelist repeat codelist_p -> cons.cdr 631 while (addr(codelist) -> lisp_ptr.type = Cons); /* process codelist again */ 632 if codelist_p -> cons_types.car 633 then absolute_counter = absolute_counter + 2; 634 else do; 635 call put_rel; /* relocatable word - a cons in codelist */ 636 relbits = relbits || bit(fixed(codelist_p -> cons_ptrs.car -> fixedb, 5), 5); /* put out the relocation */ 637 rh_reloc = divide(codelist_p -> cons_ptrs.car -> fixedb, 262144, 17, 0); 638 if rh_reloc = 0 /* if no rh relocation */ 639 then absolute_counter = 1; /* then is 1 abs for right half */ 640 else relbits = relbits || bit(rh_reloc, 5); /* else put out rh relocation */ 641 end; 642 end; 643 call put_rel; 644 relbits_length = divide(length(relbits)+107,36,35,0); /* length of text relocation bits */ 645 rel_bits_ptr = addrel(rel_bits_ptr,relbits_length); 646 symbol_block.rel_link = ptr_sub(rel_bits_ptr,symbol_ptr); 647 relocation_bits.dcl_vers = 1; 648 relbits = "00100000000000001001010010010010"b; 649 relbits_length = divide(length(relbits)+107,36,35,0); 650 rel_bits_ptr = addrel(rel_bits_ptr, relbits_length); 651 652 relocation_bits.dcl_vers = 1; 653 relbits = "11110"b || "0000011110"b || "101110"b; /* up to section_base_backptr */ 654 absolute_counter = 2*(fixed(ptr_sub(area_top,symbol_ptr),18,0)-16); /* first 16 words aready encoded */ 655 call put_rel; 656 symbol_block.rel_symbol = ptr_sub(rel_bits_ptr,symbol_ptr); 657 658 put_rel: proc; /* put out some absolute relocation */ 659 do while(absolute_counter > 1111111111b); /* pack in absolute relocation */ 660 relbits = relbits || "111101111111111"b; /* max length of expanded absolute */ 661 absolute_counter = absolute_counter - 1111111111b; 662 end; 663 if absolute_counter > 0 then do; 664 relbits = relbits || "11110"b; 665 relbits = relbits || bit(fixed(absolute_counter,10,0),10); 666 end; 667 absolute_counter = 0; 668 end; 669 670 map_ptr = addrel(rel_bits_ptr, divide(length(relbits)+107,36,35,0)); 671 symbol_block.block_size = ptr_sub(map_ptr, symbol_ptr); 672 673 object_map.dcl_vers = 1; 674 object_map.identifier = "obj_map"; 675 object_map.text_offset = ""b; 676 object_map.text_length = bit(fixed(text_length,18,0),18); 677 object_map.definition_offset = bit(text_length,18); 678 object_map.definition_length = bit(fixed(def_length,18,0),18); 679 object_map.linkage_offset = rel(link_head_ptr); 680 object_map.linkage_length = ptr_sub(link_ptr, link_head_ptr); 681 object_map.symbol_offset = rel(symbol_ptr); 682 object_map.symbol_length = bit(fixed(symbol_block.block_size,18,0),18); 683 object_map.bmap_offset = ""b; 684 object_map.bmap_length = "0"b; 685 object_map.format.bound = "0"b; 686 object_map.format.relocatable, object_map.format.procedure = "1"b; 687 object_map.format.standard = "1"b; 688 object_map.map_offset = rel(map_ptr); 689 690 call tssi_$finish_segment (object_pointer, 36*(10+fixed(symbol_block.block_size,18,0)+fixed(rel(symbol_ptr), 18)), "1100"b, acinfo, code); 691 692 return; 693 694 695 ptr_sub: proc(ap, bp)returns(bit(18)); /* subtracts bp from ap, returns offset of bp from ap as bit(18) */ 696 dcl (ap, bp) ptr; 697 dcl diff fixed bin(19); 698 699 diff = fixed(rel(ap), 18) - fixed(rel(bp), 18); 700 if diff < 0 then diff = 262144+diff; /* want 2's complement bitstring */ 701 return (bit(fixed(diff, 18), 18)); 702 end ptr_sub; 703 704 705 706 sym_alloc: proc(space) returns(ptr); 707 708 dcl space fixed bin(18), 709 tempp ptr; 710 711 tempp = area_top; 712 area_top = addrel(area_top,space); 713 return(tempp); 714 end sym_alloc; 715 end lisp_cg_utility_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 06/29/83 1541.4 lisp_cg_utility_.pl1 >special_ldd>on>06/27/83>lisp_cg_utility_.pl1 268 1 03/27/82 0436.9 lisp_symb_tree.incl.pl1 >ldd>include>lisp_symb_tree.incl.pl1 269 2 03/27/82 0437.0 lisp_bignum_fmt.incl.pl1 >ldd>include>lisp_bignum_fmt.incl.pl1 270 3 03/27/82 0437.0 lisp_nums.incl.pl1 >ldd>include>lisp_nums.incl.pl1 271 4 03/27/82 0437.0 lisp_ptr_fmt.incl.pl1 >ldd>include>lisp_ptr_fmt.incl.pl1 272 5 03/27/82 0436.9 lisp_string_fmt.incl.pl1 >ldd>include>lisp_string_fmt.incl.pl1 273 6 03/27/82 0437.1 lisp_atom_fmt.incl.pl1 >ldd>include>lisp_atom_fmt.incl.pl1 274 7 03/27/82 0437.0 lisp_cons_fmt.incl.pl1 >ldd>include>lisp_cons_fmt.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) Array internal static bit(9) initial unaligned dcl 4-17 Array36 internal static bit(36) initial dcl 4-17 Atomic internal static bit(9) initial unaligned dcl 4-17 Atomic36 internal static bit(36) initial dcl 4-17 Atsym internal static bit(9) initial unaligned dcl 4-17 Atsym36 internal static bit(36) initial dcl 4-17 Bigfix internal static bit(9) initial unaligned dcl 4-17 Bigfix36 internal static bit(36) initial dcl 4-17 Bignum internal static bit(9) initial unaligned dcl 4-17 Bignum36 internal static bit(36) initial dcl 4-17 Cons constant bit(9) initial unaligned dcl 4-17 ref 306 630 Cons36 internal static bit(36) initial dcl 4-17 File internal static bit(9) initial unaligned dcl 4-17 File36 internal static bit(36) initial dcl 4-17 Fixed internal static bit(9) initial unaligned dcl 4-17 Fixed36 internal static bit(36) initial dcl 4-17 Float internal static bit(9) initial unaligned dcl 4-17 Float36 internal static bit(36) initial dcl 4-17 NotConsOrAtsym36 internal static bit(36) initial dcl 4-17 Numeric internal static bit(9) initial unaligned dcl 4-17 Numeric36 constant bit(36) initial dcl 4-17 ref 309 String internal static bit(9) initial unaligned dcl 4-17 String36 internal static bit(36) initial dcl 4-17 Subr internal static bit(9) initial unaligned dcl 4-17 Subr36 internal static bit(36) initial dcl 4-17 SubrNumeric36 internal static bit(36) initial dcl 4-17 System_Subr internal static bit(9) initial unaligned dcl 4-17 System_Subr36 internal static bit(36) initial dcl 4-17 Uncollectable internal static bit(9) initial unaligned dcl 4-17 Undefined internal static bit(72) initial unaligned dcl 4-17 a_codelist parameter fixed bin(71,0) dcl 24 ref 10 305 630 a_codelist_p based pointer dcl 24 a_segname parameter char unaligned dcl 24 ref 10 24 24 absolute_counter 000146 automatic fixed bin(18,0) dcl 60 set ref 629* 632* 632 638* 654* 659 661* 661 663 665 667* acc 6(09) based char(512) level 4 in structure "def_hdr" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 327* acc 3(09) based char(512) level 3 in structure "definition" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 351* 356* acc 0(09) based char(512) level 2 in structure "accstring" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 381* 387* accstring based structure level 1 dcl 60 acinfo 000204 automatic pointer initial dcl 60 set ref 60* 277* 288* 690* action_block based structure level 1 dcl 1-77 action_blockp 7(18) based bit(18) level 2 packed unaligned dcl 1-3 set ref 604* action_list parameter fixed bin(71,0) dcl 24 set ref 10 598 599 601* 601 602 action_list_p based pointer dcl 24 ref 598 599 601 602 actions 1 based structure array level 2 packed unaligned dcl 1-77 set ref 602* addr builtin function dcl 265 ref 297 306 307 308 309 310 311 317 369 370 420 436 436 454 463 464 464 464 464 464 464 464 464 464 470 470 474 477 478 478 486 487 490 491 497 498 502 503 509 509 510 515 516 516 519 520 528 528 529 533 535 537 538 539 544 544 545 549 550 550 552 553 558 560 564 565 570 571 574 575 579 579 580 584 585 589 590 593 594 598 599 601 602 606 607 609 610 630 632 636 637 642 addrel builtin function dcl 265 ref 341 354 365 383 389 396 400 409 419 425 450 645 650 670 712 after builtin function dcl 265 ap parameter pointer dcl 696 ref 695 699 area_pointer 16(18) based bit(18) level 2 packed unaligned dcl 60 set ref 482* area_top 000130 automatic pointer dcl 60 set ref 450* 623 654* 711 712* 712 array_link 1 based structure array level 2 dcl 1-71 array_link_list parameter fixed bin(71,0) dcl 24 set ref 10 606 607 609* 609 610 array_link_list_p based pointer dcl 24 ref 606 607 609 610 array_links_block based structure level 1 dcl 1-71 array_links_blockp 10 based bit(18) level 2 packed unaligned dcl 1-3 set ref 613* atom based structure level 1 dcl 6-5 atom_double_words based structure level 1 dcl 6-5 atom_ptrs based structure level 1 dcl 6-5 atsym_block based structure level 1 dcl 1-36 atsym_blockp 4 based bit(18) level 3 packed unaligned dcl 1-3 set ref 556* atsym_list parameter fixed bin(71,0) dcl 24 set ref 10 544 544 545 549* 549 550 550 552 553 atsym_list_p based pointer dcl 24 ref 544 544 545 549 550 550 552 553 atsym_offset 1 based bit(18) array level 2 packed unaligned dcl 1-36 set ref 551* back_thread 3(18) based bit(18) level 3 in structure "def_hdr" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 330* back_thread 0(18) based bit(18) level 2 in structure "definition" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 343* 358* based_ptr based pointer dcl 4-16 ref 310 516 516 519 520 535 537 538 539 550 550 552 553 before builtin function dcl 265 begin_links 6 based bit(18) level 2 packed unaligned dcl 60 set ref 414* bignum_block based structure level 1 dcl 1-40 bignum_blockp 3(18) based bit(18) level 3 packed unaligned dcl 1-3 set ref 541* bignum_list parameter fixed bin(71,0) dcl 24 set ref 10 528 528 529 533* 533 535 537 538 539 bignum_list_p based pointer dcl 24 ref 528 528 529 533 535 537 538 539 bignum_offsets 1 based bit(18) array level 2 packed unaligned dcl 1-40 set ref 536* bit builtin function dcl 265 ref 329 342 348 352 363 410 414 636 640 665 676 677 678 682 701 block_size 17(18) based bit(18) level 2 packed unaligned dcl 60 set ref 671* 682 690 blockp 000132 automatic pointer dcl 60 set ref 486* 487 489 491 494* 497* 498 499 501 503 506* 509* 510 511 513 518 524* 528* 529 530 532 536 541* 544* 545 546 548 551 556* 558* 560 561 563 565 568* 570* 571 573 575 577* 579* 580 581 583 585 587* 589* 590 591 592 594 596* 598* 599 600 602 604* 606* 607 608 610 613* bmap_length 7(18) based bit(18) level 2 packed unaligned dcl 60 set ref 684* bmap_offset 7 based bit(18) level 2 packed unaligned dcl 60 set ref 683* bound 10 based bit(1) level 3 packed unaligned dcl 60 set ref 685* bp parameter pointer dcl 696 ref 695 699 car based pointer level 2 in structure "cons_ptrs" dcl 7-5 in procedure "lisp_cg_utility_" ref 376 377 378 379 464 464 464 474 477 478 478 636 637 car 0(21) based bit(9) level 2 in structure "cons_types" packed unaligned dcl 7-5 in procedure "lisp_cg_utility_" ref 632 car based fixed bin(71,0) level 2 in structure "cons" dcl 7-5 in procedure "lisp_cg_utility_" ref 307 cdr 2 based fixed bin(71,0) level 2 in structure "cons" dcl 7-5 in procedure "lisp_cg_utility_" ref 308 310 463 490 502 515 533 549 564 574 584 593 601 609 642 cdr 2 based pointer level 2 in structure "cons_ptrs" dcl 7-5 in procedure "lisp_cg_utility_" ref 370 401 chars 1 based char level 2 packed unaligned dcl 1-50 set ref 520* 553* class 4(33) based bit(3) level 3 in structure "def_hdr" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 334* class 1(33) based bit(3) level 2 in structure "definition" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 347* 362* cleanup 000102 stack reference condition dcl 58 ref 277 clock_ 000022 constant entry external dcl 229 ref 438 code 000203 automatic fixed bin(35,0) dcl 60 set ref 288* 291* 464* 469 470* 471 690* codeitem 000142 automatic fixed bin(71,0) dcl 60 set ref 307* 309 310* 310 311 codelist 000100 automatic fixed bin(71,0) dcl 55 set ref 305* 306 307 308* 308 630* 630* 632 636 637* 642 codelist_p based pointer dcl 55 ref 307 308 632 636 637 642 com_err_ 000024 constant entry external dcl 229 ref 291 299 combined_length 7(18) based bit(18) level 2 packed unaligned dcl 60 set ref 416* comment 14 based structure level 2 dcl 60 cons based structure level 1 dcl 7-5 cons_block based structure level 1 dcl 1-44 cons_blockp 4(18) based bit(18) level 3 packed unaligned dcl 1-3 set ref 568* cons_list parameter fixed bin(71,0) dcl 24 set ref 10 558 560 564* 564 565 cons_list_p based pointer dcl 24 ref 558 560 564 565 cons_ptrs based structure level 1 dcl 7-5 cons_types based structure level 1 dcl 7-5 cons_types36 based structure level 1 dcl 7-22 conses 1 based structure array level 2 packed unaligned dcl 1-44 set ref 565* consptr automatic pointer dcl 7-5 const_block based structure level 1 dcl 1-63 const_blockp 6(18) based bit(18) level 3 packed unaligned dcl 1-3 set ref 587* constant_list parameter fixed bin(71,0) dcl 24 set ref 10 579 579 580 584* 584 585 constant_list_p based pointer dcl 24 ref 579 579 580 584 585 constants 1 based fixed bin(17,0) array level 2 packed unaligned dcl 1-63 set ref 585* control_word 1 based bit(36) array level 3 dcl 1-71 set ref 610* count based fixed bin(18,0) level 2 in structure "string_block" dcl 1-31 in procedure "lisp_cg_utility_" set ref 510* 511 513 count based fixed bin(18,0) level 2 in structure "fixnum_block" dcl 1-23 in procedure "lisp_cg_utility_" set ref 487* 489 count based fixed bin(18,0) level 2 in structure "flonum_block" dcl 1-27 in procedure "lisp_cg_utility_" set ref 498* 499 501 count based fixed bin(18,0) level 2 in structure "links_block" dcl 1-67 in procedure "lisp_cg_utility_" set ref 590* 591 592 count based fixed bin(18,0) level 2 in structure "const_block" dcl 1-63 in procedure "lisp_cg_utility_" set ref 580* 581 583 count based fixed bin(18,0) level 2 in structure "bignum_block" dcl 1-40 in procedure "lisp_cg_utility_" set ref 529* 530 532 count based fixed bin(18,0) level 2 in structure "action_block" dcl 1-77 in procedure "lisp_cg_utility_" set ref 599* 600 count based fixed bin(18,0) level 2 in structure "cons_block" dcl 1-44 in procedure "lisp_cg_utility_" set ref 560* 561 563 count based fixed bin(18,0) level 2 in structure "array_links_block" dcl 1-71 in procedure "lisp_cg_utility_" set ref 607* 608 count based fixed bin(18,0) level 2 in structure "entry_block" dcl 1-57 in procedure "lisp_cg_utility_" set ref 571* 573 count based fixed bin(18,0) level 2 in structure "atsym_block" dcl 1-36 in procedure "lisp_cg_utility_" set ref 545* 546 548 cu_$cl 000026 constant entry external dcl 229 ref 292 dcl_vers based fixed bin(17,0) level 2 in structure "symbol_block" dcl 60 in procedure "lisp_cg_utility_" set ref 433* dcl_vers based fixed bin(17,0) level 2 in structure "relocation_bits" dcl 60 in procedure "lisp_cg_utility_" set ref 627* 647* 652* dcl_vers based fixed bin(17,0) level 2 in structure "object_map" dcl 60 in procedure "lisp_cg_utility_" set ref 673* def_hdr based structure level 1 dcl 60 def_length 000202 automatic fixed bin(18,0) dcl 60 set ref 404* 405 405* 405 409 678 def_length_in_words 000176 automatic fixed bin(18,0) dcl 60 set ref 328* 329 341 342 352 353* 354 def_list based bit(18) level 2 packed unaligned dcl 60 set ref 321* def_ptr 000112 automatic pointer dcl 60 set ref 317* 321 322 322 326 327 329 330 331 332 332 334 335 336 336 341* 341 342 343 344 345 345 347 348 348 349 350 351 354* 354 355 356 357 358 359 360 360 362 363 363 364 365* 365 380 381 382* 383* 383 386 387 388* 389* 389 391 392 393 394 395* 396* 396 397 398 399* 400* 400 404 def_section 1 based bit(18) level 2 packed unaligned dcl 60 set ref 410* default_truncate 22(18) based bit(18) level 2 packed unaligned dcl 60 set ref 624* definition based structure level 1 dcl 60 definition_length 4(18) based bit(18) level 2 packed unaligned dcl 60 set ref 678* definition_offset 4 based bit(18) level 2 packed unaligned dcl 60 set ref 677* defsect 000114 automatic pointer dcl 60 set ref 317* 382* 388* 395* 399* diff 000514 automatic fixed bin(19,0) dcl 697 set ref 699* 700 700* 700 701 divide builtin function dcl 265 ref 315 328 383 389 474 509 509 516 516 528 528 544 544 550 550 579 579 637 644 649 670 dtm 1 000442 automatic bit(36) level 2 in structure "hcs_status_long_str" packed unaligned dcl 229 in procedure "lisp_cg_utility_" set ref 473 dtm 4 based fixed bin(71,0) array level 3 in structure "source_map" dcl 193 in procedure "lisp_cg_utility_" set ref 473* entry_block based structure level 1 dcl 1-57 entry_blockp 6 based bit(18) level 3 packed unaligned dcl 1-3 set ref 577* entry_info 1 based structure array level 2 packed unaligned dcl 1-57 set ref 575* entry_list parameter fixed bin(71,0) dcl 24 set ref 10 570 571 574* 574 575 entry_list_p based pointer dcl 24 ref 570 571 574 575 entryname 000163 automatic varying char(32) dcl 60 set ref 375* 378* 384 386 387 387 389 entryname_relp 1(18) based bit(18) level 2 in structure "type_pair" packed unaligned dcl 206 in procedure "lisp_cg_utility_" set ref 392* entryname_relp 000175 automatic bit(18) unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 384* 388* 392 395* 397 expand_path_ 000036 constant entry external dcl 229 ref 464 expression 0(18) based fixed bin(17,0) level 2 packed unaligned dcl 206 set ref 398* expression_relp 1 based bit(18) level 2 packed unaligned dcl 206 set ref 424* expression_word based structure level 1 dcl 206 expression_word_table 000272 automatic bit(18) array dcl 223 set ref 297 399* 424 fault_tag_2 0(30) based bit(6) level 2 packed unaligned dcl 206 set ref 423* fixed builtin function dcl 265 ref 342 348 348 352 363 363 404 473 476 636 654 665 676 678 682 690 690 699 699 701 fixedb 1 based fixed bin(17,0) level 2 dcl 3-4 ref 297 369 420 454 486 487 491 497 498 509 509 510 528 528 529 544 544 545 558 560 570 571 579 579 580 585 589 590 598 599 606 607 636 637 fixnum_block based structure level 1 dcl 1-23 fixnum_blockp 2 based bit(18) level 3 packed unaligned dcl 1-3 set ref 494* fixnum_fmt based structure level 1 dcl 3-4 fixnum_list parameter fixed bin(71,0) dcl 24 set ref 10 486 487 490* 490 491 fixnum_list_p based pointer dcl 24 ref 486 487 490 491 fixnum_type internal static bit(36) initial dcl 3-4 fixnums 1 based fixed bin(35,0) array level 2 dcl 1-23 set ref 491* flags 1(18) based structure level 2 in structure "definition" packed unaligned dcl 60 in procedure "lisp_cg_utility_" flags 4(18) based structure level 3 in structure "def_hdr" packed unaligned dcl 60 in procedure "lisp_cg_utility_" flags 1(18) based structure level 2 in structure "def_hdr" packed unaligned dcl 60 in procedure "lisp_cg_utility_" floatb 1 based float bin(27) level 2 dcl 3-4 ref 503 flonum_block based structure level 1 dcl 1-27 flonum_blockp 2(18) based bit(18) level 3 packed unaligned dcl 1-3 set ref 506* flonum_fmt based structure level 1 dcl 3-4 flonum_list parameter fixed bin(71,0) dcl 24 set ref 10 497 498 502* 502 503 flonum_list_p based pointer dcl 24 ref 497 498 502 503 flonum_type internal static bit(36) initial dcl 3-4 flonums 1 based float bin(27) array level 2 dcl 1-27 set ref 503* fore_thread 3 based bit(18) level 3 in structure "def_hdr" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 329* 336 fore_thread based bit(18) level 2 in structure "definition" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 342* 357* format 10 based structure level 2 packed unaligned dcl 60 gen_creation_time 4 based fixed bin(71,0) level 2 dcl 60 set ref 436* gen_version parameter char unaligned dcl 24 ref 10 449 gen_version_name 12 based structure level 2 dcl 60 gen_version_number 3 based fixed bin(17,0) level 2 dcl 60 set ref 435* generator 10 based char(8) level 2 dcl 60 set ref 439* get_dir_ 000436 automatic entry variable dcl 229 set ref 280* 284* 288 288 291 291 get_group_id_ 000020 constant entry external dcl 229 ref 448 get_pdir_ 000016 constant entry external dcl 229 ref 284 get_wdir_ 000014 constant entry external dcl 229 ref 280 hbound builtin function dcl 265 ref 297 hcs_$status_long 000040 constant entry external dcl 229 ref 470 hcs_status_long_str 000442 automatic structure level 1 dcl 229 set ref 470 470 header_relp based bit(18) level 2 packed unaligned dcl 206 set ref 422* ic 000200 automatic fixed bin(18,0) dcl 60 set ref 304* 311 312* 312 315 315* 317 459* 462* 462 472 473 476 477 489* 491* 501* 503* 513* 518* 532* 536* 548* 551* 563* 565* 573* 575* 583* 585* 592* 594* 600* 602* 608* 610* identifier 1 based char(8) level 2 in structure "object_map" dcl 60 in procedure "lisp_cg_utility_" set ref 674* identifier 1 based char(8) level 2 in structure "symbol_block" dcl 60 in procedure "lisp_cg_utility_" set ref 434* ignore 1(19) based bit(1) level 3 packed unaligned dcl 60 set ref 322* iiiii 000454 automatic fixed bin(17,0) dcl 374 set ref 376* 377 377* 378 379 index builtin function dcl 265 ref 376 last_def 000206 automatic bit(18) unaligned dcl 60 set ref 339* 343 352* 358 lcp_cg_$symbol_table 000012 external static fixed bin(17,0) dcl 60 set ref 436 lcp_semant_$symbol_table 000010 external static fixed bin(17,0) dcl 60 set ref 436 len based fixed bin(8,0) level 2 in structure "accstring" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 380* 386* len 3 based fixed bin(8,0) level 3 in structure "definition" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 350* 355* len 6 based fixed bin(8,0) level 4 in structure "def_hdr" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 326* length 2(18) based fixed bin(17,0) array level 4 in structure "source_map" packed unaligned dcl 193 in procedure "lisp_cg_utility_" set ref 477* length 14(18) based fixed bin(17,0) level 3 in structure "symbol_block" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 444* length 12(18) based fixed bin(17,0) level 3 in structure "symbol_block" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 441* length 13(18) based fixed bin(17,0) level 3 in structure "symbol_block" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 443* length 0(11) based fixed bin(24,0) level 2 in structure "string_chars" packed unaligned dcl 1-50 in procedure "lisp_cg_utility_" set ref 519* 520 552* 553 length builtin function dcl 265 in procedure "lisp_cg_utility_" ref 24 281 326 327 328 377 380 381 383 386 387 389 644 649 670 link_hdr based structure level 1 dcl 60 link_head_ptr 000120 automatic pointer dcl 60 set ref 418* 422* 428 428* 679 680* link_info 1 based bit(27) array level 2 dcl 1-67 set ref 594* link_list parameter fixed bin(71,0) dcl 24 set ref 10 589 590 593* 593 594 link_list_count 000147 automatic fixed bin(17,0) dcl 60 set ref 369* 371 399 402* 402 420* 421 424 426* 426 link_list_p based pointer dcl 24 ref 589 590 593 594 link_list_ptr 000150 automatic pointer dcl 60 set ref 370* 376 377 378 379 401* 401 link_pair based structure level 1 dcl 206 link_ptr 000116 automatic pointer dcl 60 set ref 409* 410 414 414 416 418 419* 419 422 422* 423 424 425* 425 428* 432 680* linkage_length 5(18) based bit(18) level 2 packed unaligned dcl 60 set ref 680* linkage_offset 5 based bit(18) level 2 packed unaligned dcl 60 set ref 679* links_block based structure level 1 dcl 1-67 links_blockp 7 based bit(18) level 3 packed unaligned dcl 1-3 set ref 596* lisp_bignum based structure level 1 dcl 2-3 lisp_cg_utility_ 000106 constant entry external dcl 10 lisp_ptr based structure level 1 dcl 4-17 lisp_ptr_type based bit(36) dcl 4-17 ref 309 lisp_string based structure level 1 dcl 5-6 loop_back 000233 constant label dcl 288 ref 293 map 2 based structure array level 2 dcl 193 map_offset 11 based bit(18) level 2 dcl 60 set ref 688* map_ptr 000126 automatic pointer dcl 60 set ref 670* 671* 673 674 675 676 677 678 679 680 681 682 683 684 685 686 686 687 688 688 max builtin function dcl 265 ref 436 mod builtin function dcl 265 ref 405 new_format 1(18) based bit(1) level 3 in structure "definition" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 345* 360* new_format 4(18) based bit(1) level 4 in structure "def_hdr" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 332* new_format 1(18) based bit(1) level 3 in structure "def_hdr" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 322* next_block_thread 20 based bit(18) level 2 packed unaligned dcl 60 set ref 447* next_def automatic bit(18) unaligned dcl 60 null builtin function dcl 265 ref 60 290 470 470 number_objects 1 based fixed bin(17,0) level 2 dcl 1-3 set ref 618* object_creation_time 6 based fixed bin(71,0) level 2 dcl 60 set ref 436 436 438* object_map based structure level 1 dcl 60 object_pointer 000110 automatic pointer dcl 60 set ref 288* 290 311 317 409 690* objects 2 based structure level 2 packed unaligned dcl 1-3 offset 2 based fixed bin(17,0) array level 4 in structure "source_map" packed unaligned dcl 193 in procedure "lisp_cg_utility_" set ref 476* offset 12 based fixed bin(17,0) level 3 in structure "symbol_block" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 440* offset 14 based fixed bin(17,0) level 3 in structure "symbol_block" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 444* offset 13 based fixed bin(17,0) level 3 in structure "symbol_block" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 442* optional_truncate 23 based bit(18) level 2 packed unaligned dcl 60 set ref 624* pathname 2 based structure array level 3 dcl 193 pl1_link_list parameter fixed bin(71,0) dcl 24 set ref 10 297 369 370 420 pl1_link_list_p based pointer dcl 24 ref 297 369 370 420 pname 5 based char level 2 dcl 6-5 ref 553 pnamel 4 based fixed bin(17,0) level 2 dcl 6-5 ref 550 550 552 553 prec 0(18) based fixed bin(17,0) level 2 packed unaligned dcl 2-3 set ref 535 538* 538 539 procedure 10(02) based bit(1) level 3 packed unaligned dcl 60 set ref 686* ptr_sub 003423 constant entry internal dcl 695 ref 382 388 395 399 422 428 456 476 482 494 506 518 524 536 541 551 556 568 577 587 596 604 613 624 646 654 656 671 680 put_rel 003342 constant entry internal dcl 658 ref 635 643 655 rel builtin function dcl 265 ref 348 363 404 679 681 688 690 699 699 rel_bits_ptr 000124 automatic pointer dcl 60 set ref 623* 624* 627 628 636 636 640 640 644 645* 645 646* 647 648 649 650* 650 652 653 656* 660 660 664 664 665 665 670 670 rel_link 21(18) based bit(18) level 2 packed unaligned dcl 60 set ref 646* rel_symbol 22 based bit(18) level 2 packed unaligned dcl 60 set ref 656* rel_text 20(18) based bit(18) level 2 packed unaligned dcl 60 set ref 624* relbits 1 based varying bit(131072) level 2 dcl 60 set ref 628* 636* 636 640* 640 644 648* 649 653* 660* 660 664* 664 665* 665 670 relbits_length 000145 automatic fixed bin(18,0) dcl 60 set ref 644* 645 649* 650 relocatable 10(01) based bit(1) level 3 packed unaligned dcl 60 set ref 686* relocation_bits based structure level 1 dcl 60 retain 1(21) based bit(1) level 3 in structure "definition" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 345* 360* retain 4(21) based bit(1) level 4 in structure "def_hdr" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 332* rh_reloc 000144 automatic fixed bin(5,0) dcl 60 set ref 637* 638 640 section_length 6(18) based bit(18) level 2 packed unaligned dcl 60 set ref 414* 428* sectionbase_backpointer 17 based bit(18) level 2 packed unaligned dcl 60 set ref 446* segmentname 000152 automatic varying char(32) dcl 60 set ref 379* 380 381 381 383 segmentname_relp 1 based bit(18) level 2 in structure "type_pair" packed unaligned dcl 206 in procedure "lisp_cg_utility_" set ref 391* segmentname_relp 000174 automatic bit(18) unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 382* 384 391 segname 000100 automatic char initial unaligned dcl 24 set ref 24* 281 281 285* 285 288* 291* 326 327 327 328 segname_def 3 based structure level 2 dcl 60 segname_length automatic fixed bin(17,0) dcl 60 segname_ptr 2(18) based bit(18) level 2 in structure "definition" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 349* 364* segname_ptr 5(18) based bit(18) level 3 in structure "def_hdr" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 336* sign based bit(18) level 2 packed unaligned dcl 2-3 set ref 537* 537 size builtin function dcl 265 in procedure "lisp_cg_utility_" ref 450 455 455 481 481 size 1 based fixed bin(17,0) level 2 in structure "source_map" dcl 193 in procedure "lisp_cg_utility_" set ref 458* smdn 000207 automatic char(168) unaligned dcl 193 set ref 464 464 470* smen 000261 automatic char(32) unaligned dcl 193 set ref 464 464 470* smstr based char unaligned dcl 193 set ref 478* source_map based structure level 1 dcl 193 in procedure "lisp_cg_utility_" set ref 455 455 source_map 16 based bit(18) level 2 in structure "symbol_block" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 456* source_map_loss 001454 constant label dcl 474 ref 469 471 source_map_size 000271 automatic fixed bin(17,0) dcl 193 set ref 454* 455 455 458 460 461* 461 source_seg_list parameter fixed bin(71,0) dcl 24 set ref 10 454 463* 463 464 464 464 474 477 478 478 source_seg_list_p based pointer dcl 24 ref 454 463 464 464 464 474 477 478 478 space parameter fixed bin(18,0) dcl 708 ref 706 712 standard 10(03) based bit(1) level 3 packed unaligned dcl 60 set ref 687* stat_boundary 15(18) based fixed bin(17,0) level 2 packed unaligned dcl 60 set ref 445* stat_length 000201 automatic fixed bin(18,0) dcl 60 set ref 412* 414 string builtin function dcl 265 in procedure "lisp_cg_utility_" set ref 575* string 1 based char level 2 in structure "lisp_string" dcl 5-6 in procedure "lisp_cg_utility_" set ref 376 377 378 379 464 464 478 520 string_block based structure level 1 dcl 1-31 string_blockp 3 based bit(18) level 3 packed unaligned dcl 1-3 set ref 524* string_chars based structure level 1 dcl 1-50 string_length based fixed bin(17,0) level 2 dcl 5-6 set ref 376 377 378 379 464 464 464* 474 477 478 478 516 516 519 520 string_list parameter fixed bin(71,0) dcl 24 set ref 10 509 509 510 515* 515 516 516 519 520 string_list_p based pointer dcl 24 ref 509 509 510 515 516 516 519 520 string_offset 1 based bit(18) array level 2 packed unaligned dcl 1-31 set ref 518* stringpointer based structure level 1 dcl 60 subr_block_items 6 based structure level 2 packed unaligned dcl 1-3 subr_block_size 5 based fixed bin(18,0) level 2 dcl 1-3 set ref 619* substr builtin function dcl 265 set ref 281 285 327* 351* 356* 378 379 381* 387* 594 sym_alloc 003455 constant entry internal dcl 706 ref 455 474 481 486 497 509 516 528 535 544 550 558 570 579 589 598 606 symbol 6 based structure level 3 in structure "def_hdr" dcl 60 in procedure "lisp_cg_utility_" symbol 3 based structure level 2 in structure "definition" dcl 60 in procedure "lisp_cg_utility_" symbol_block based structure level 1 dcl 60 set ref 450 symbol_length 6(18) based bit(18) level 2 packed unaligned dcl 60 set ref 682* symbol_offset 6 based bit(18) level 2 packed unaligned dcl 60 set ref 681* symbol_ptr 5 based bit(18) level 3 in structure "def_hdr" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 335* symbol_ptr 000122 automatic pointer dcl 60 in procedure "lisp_cg_utility_" set ref 432* 433 434 435 436 438 439 440 441 442 443 444 444 445 445 446 447 448 449 450 450 456 456* 476* 482 482* 624* 624 624 624 646 646* 654* 656 656* 671 671* 681 682 690 690 symbol_ptr 2 based bit(18) level 2 in structure "definition" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 348* 363* symbol_root based structure level 1 dcl 1-3 set ref 481 481 symrtp 000136 automatic pointer dcl 60 set ref 474* 476* 478 481* 482* 494 494* 506 506* 518* 524 524* 536* 541 541* 551* 556 556* 568 568* 577 577* 587 587* 596 596* 604 604* 613 613* 617 618 619 tempp 000524 automatic pointer dcl 708 set ref 711* 713 text_boundary 15 based fixed bin(17,0) level 2 packed unaligned dcl 60 set ref 445* text_length 000177 automatic fixed bin(18,0) dcl 60 in procedure "lisp_cg_utility_" set ref 315* 348 363 404 409 410 676 677 text_length 3(18) based bit(18) level 2 in structure "object_map" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 676* text_offset 3 based bit(18) level 2 packed unaligned dcl 60 set ref 675* text_section based bit(36) array dcl 60 set ref 311* 317 thingp 000134 automatic pointer dcl 60 set ref 455* 456* 457 458 472 473 476 477 516* 518* 519 520 535* 536* 537 538 539 550* 551* 552 553 total_block_size 000141 automatic fixed bin(18,0) dcl 60 set ref 571* 581* 581 591* 591 619 total_objects 000140 automatic fixed bin(18,0) dcl 60 set ref 487* 499* 499 511* 511 530* 530 546* 546 561* 561 618 trap_relp 0(18) based bit(18) level 2 packed unaligned dcl 206 set ref 394* tssi_$clean_up_segment 000032 constant entry external dcl 229 ref 277 tssi_$finish_segment 000034 constant entry external dcl 229 ref 690 tssi_$get_segment 000030 constant entry external dcl 229 ref 288 type 0(21) based bit(9) level 2 in structure "lisp_ptr" packed unaligned dcl 4-17 in procedure "lisp_cg_utility_" ref 306 630 type based fixed bin(17,0) level 2 in structure "type_pair" packed unaligned dcl 206 in procedure "lisp_cg_utility_" set ref 393* type_pair based structure level 1 dcl 206 type_pair_relp based bit(18) level 2 packed unaligned dcl 206 set ref 397* uid 11 000442 automatic bit(36) level 2 in structure "hcs_status_long_str" packed unaligned dcl 229 in procedure "lisp_cg_utility_" set ref 472 uid 3 based bit(36) array level 3 in structure "source_map" dcl 193 in procedure "lisp_cg_utility_" set ref 472* unspec builtin function dcl 265 set ref 565* 602* user_name 24 based char(32) level 2 dcl 60 set ref 448* userid 13 based structure level 2 dcl 60 value 4 based bit(18) level 3 in structure "def_hdr" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 331* value 1 based bit(18) level 2 in structure "definition" packed unaligned dcl 60 in procedure "lisp_cg_utility_" set ref 344* 359* version based fixed bin(17,0) level 2 in structure "source_map" dcl 193 in procedure "lisp_cg_utility_" set ref 457* version based fixed bin(17,0) level 2 in structure "symbol_root" dcl 1-3 in procedure "lisp_cg_utility_" set ref 617* version_string 34 based char(64) level 2 dcl 60 set ref 449* word 1 based bit(36) level 2 dcl 60 ref 311 565 575 594 602 610 word_overlay based structure level 1 dcl 60 words 1 based fixed bin(35,0) array level 2 dcl 2-3 set ref 539* 539 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 4002 4044 3621 4012 Length 4400 3621 42 317 160 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME lisp_cg_utility_ 472 external procedure is an external procedure. on unit on line 277 68 on unit put_rel internal procedure shares stack frame of external procedure lisp_cg_utility_. ptr_sub internal procedure shares stack frame of external procedure lisp_cg_utility_. sym_alloc internal procedure shares stack frame of external procedure lisp_cg_utility_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME lisp_cg_utility_ 000100 segname lisp_cg_utility_ 000100 codelist lisp_cg_utility_ 000110 object_pointer lisp_cg_utility_ 000112 def_ptr lisp_cg_utility_ 000114 defsect lisp_cg_utility_ 000116 link_ptr lisp_cg_utility_ 000120 link_head_ptr lisp_cg_utility_ 000122 symbol_ptr lisp_cg_utility_ 000124 rel_bits_ptr lisp_cg_utility_ 000126 map_ptr lisp_cg_utility_ 000130 area_top lisp_cg_utility_ 000132 blockp lisp_cg_utility_ 000134 thingp lisp_cg_utility_ 000136 symrtp lisp_cg_utility_ 000140 total_objects lisp_cg_utility_ 000141 total_block_size lisp_cg_utility_ 000142 codeitem lisp_cg_utility_ 000144 rh_reloc lisp_cg_utility_ 000145 relbits_length lisp_cg_utility_ 000146 absolute_counter lisp_cg_utility_ 000147 link_list_count lisp_cg_utility_ 000150 link_list_ptr lisp_cg_utility_ 000152 segmentname lisp_cg_utility_ 000163 entryname lisp_cg_utility_ 000174 segmentname_relp lisp_cg_utility_ 000175 entryname_relp lisp_cg_utility_ 000176 def_length_in_words lisp_cg_utility_ 000177 text_length lisp_cg_utility_ 000200 ic lisp_cg_utility_ 000201 stat_length lisp_cg_utility_ 000202 def_length lisp_cg_utility_ 000203 code lisp_cg_utility_ 000204 acinfo lisp_cg_utility_ 000206 last_def lisp_cg_utility_ 000207 smdn lisp_cg_utility_ 000261 smen lisp_cg_utility_ 000271 source_map_size lisp_cg_utility_ 000272 expression_word_table lisp_cg_utility_ 000436 get_dir_ lisp_cg_utility_ 000442 hcs_status_long_str lisp_cg_utility_ 000454 iiiii lisp_cg_utility_ 000514 diff ptr_sub 000524 tempp sym_alloc THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_var call_ext_out_desc call_ext_out return alloc_auto_adj mod_fx1 enable ext_entry_desc int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. clock_ com_err_ cu_$cl expand_path_ get_group_id_ get_pdir_ get_wdir_ hcs_$status_long tssi_$clean_up_segment tssi_$finish_segment tssi_$get_segment THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. lcp_cg_$symbol_table lcp_semant_$symbol_table LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 10 000073 24 000126 60 000147 288 000151 291 000154 277 000157 280 000203 281 000210 284 000221 285 000225 288 000233 290 000274 291 000300 292 000350 293 000355 297 000356 299 000364 301 000417 304 000420 305 000421 306 000423 307 000427 308 000431 309 000434 310 000440 311 000443 312 000446 313 000447 315 000450 317 000456 321 000462 322 000464 326 000470 327 000473 328 000501 329 000505 330 000512 331 000514 332 000516 334 000522 335 000526 336 000530 339 000533 341 000535 342 000537 343 000545 344 000547 345 000551 347 000555 348 000557 349 000572 350 000574 351 000576 352 000601 353 000606 354 000610 355 000612 356 000614 357 000617 358 000621 359 000624 360 000626 362 000632 363 000636 364 000651 365 000653 369 000655 370 000662 371 000666 375 000670 376 000671 377 000705 378 000713 379 000727 380 000742 381 000746 382 000754 383 000756 384 000764 386 000775 387 001000 388 001005 389 001007 391 001015 392 001017 393 001022 394 001024 395 001026 396 001030 397 001033 398 001035 399 001037 400 001045 401 001050 402 001053 403 001055 404 001056 405 001062 409 001066 410 001073 412 001100 414 001102 416 001111 418 001113 419 001114 420 001116 421 001123 422 001126 423 001140 424 001143 425 001147 426 001151 427 001153 428 001154 432 001171 433 001173 434 001175 435 001201 436 001203 438 001213 439 001221 440 001225 441 001227 442 001231 443 001233 444 001235 445 001241 446 001245 447 001247 448 001250 449 001257 450 001266 454 001271 455 001275 456 001302 457 001315 458 001317 459 001322 460 001323 461 001326 462 001330 463 001331 464 001336 469 001370 470 001373 471 001435 472 001440 473 001445 474 001454 476 001466 477 001502 478 001513 479 001526 481 001527 482 001533 486 001550 487 001560 489 001566 490 001575 491 001602 492 001607 494 001611 497 001624 498 001634 499 001641 501 001643 502 001653 503 001660 504 001665 506 001667 509 001704 510 001715 511 001722 513 001724 515 001733 516 001740 518 001750 519 001767 520 001776 522 002011 524 002013 528 002026 529 002037 530 002044 532 002046 533 002055 535 002062 536 002073 537 002112 538 002120 539 002125 540 002140 541 002142 544 002157 545 002170 546 002175 548 002177 549 002207 550 002214 551 002225 552 002244 553 002254 554 002267 556 002271 558 002304 560 002314 561 002321 563 002323 564 002333 565 002340 566 002345 568 002347 570 002364 571 002374 573 002402 574 002411 575 002416 576 002423 577 002425 579 002440 580 002451 581 002456 583 002460 584 002467 585 002474 586 002511 587 002513 589 002530 590 002540 591 002545 592 002547 593 002557 594 002564 595 002572 596 002574 598 002607 599 002617 600 002624 601 002633 602 002640 603 002645 604 002647 606 002664 607 002674 608 002701 609 002711 610 002716 612 002723 613 002725 617 002740 618 002742 619 002745 623 002747 624 002751 627 002767 628 002771 629 002773 630 002774 632 003003 635 003011 636 003012 637 003034 638 003041 640 003045 642 003064 643 003070 644 003071 645 003076 646 003100 647 003115 648 003117 649 003124 650 003130 652 003132 653 003134 654 003140 655 003147 656 003150 670 003163 671 003172 673 003207 674 003211 675 003215 676 003217 677 003224 678 003231 679 003236 680 003240 681 003254 682 003257 683 003271 684 003273 685 003275 686 003277 687 003303 688 003305 690 003307 692 003341 658 003342 659 003343 660 003347 661 003362 662 003364 663 003365 664 003367 665 003402 667 003421 668 003422 695 003423 699 003425 700 003440 701 003443 706 003455 711 003457 712 003461 713 003464 ----------------------------------------------------------- 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