COMPILATION LISTING OF SEGMENT get_reference Compiled by: Multics PL/I Compiler, Release 28d, of September 14, 1983 Compiled at: Honeywell LCPD Phoenix, System M Compiled on: 10/03/83 1642.8 mst Mon Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 /* This procedure is called by various code generator modules to obtain 12* a reference node for temporary use. A list of previously allocated 13* nodes is maintained and each call returns the next node on the list. 14* If the end of the list is reached, a new node is allocated. 15* 16* The program is initialized by the statement 17* cg_stat$first_ref, cg_stat$next_ref = null; 18* 19* The list of reference nodes will be re-used starting at the begining, 20* if the statement 21* cg_stat$next_ref = cg_stat$first_ref; 22* is executed. 23* 24* Initial Version: 3 Februrary 1971 by BLW 25* Modified: 30 March 1980 by RAB for reference.(padded aligned)_for_store_ref. 26* See prepare_operand for details. */ 27 28 get_reference: proc returns(ptr); 29 30 dcl (p,q) ptr, 31 n fixed bin, 32 (cg_stat$first_ref,cg_stat$next_ref,cg_stat$m_s_p) ptr ext, 33 create_list entry(fixed bin) returns(ptr), 34 create_reference entry(ptr) returns(ptr), 35 (state_man$flush_ref,state_man$flush_address) entry(ptr); 36 37 dcl (null,string) builtin; 38 1 1 /* BEGIN INCLUDE FILE ... list.incl.pl1 */ 1 2 1 3 /* Modified 26 June 81 by EBush to add max_list_elements */ 1 4 1 5 1 6 dcl 1 list based aligned, 1 7 2 node_type bit(9) unaligned, 1 8 2 reserved bit(12) unaligned, 1 9 2 number fixed(14) unaligned, 1 10 2 element dimension(n refer(list.number)) ptr unaligned; 1 11 1 12 dcl max_list_elements fixed bin(17) internal static options (constant) 1 13 init(16383); 1 14 1 15 /* END INCLUDE FILE ... list.incl.pl1 */ 39 2 1 /* BEGIN INCLUDE FILE ... cg_reference.incl.pl1 */ 2 2 2 3 dcl 1 reference based aligned, 2 4 2 node_type bit(9) unaligned, 2 5 2 array_ref bit(1) unaligned, 2 6 2 varying_ref bit(1) unaligned, 2 7 2 shared bit(1) unaligned, 2 8 2 put_data_sw bit(1) unaligned, 2 9 2 processed bit(1) unaligned, 2 10 2 units fixed(3) unaligned, 2 11 2 ref_count fixed(17) unaligned, 2 12 2 c_offset fixed(24), 2 13 2 c_length fixed(24), 2 14 2 symbol ptr unaligned, 2 15 2 qualifier ptr unaligned, 2 16 2 offset ptr unaligned, 2 17 2 length ptr unaligned, 2 18 /* these fields are used by the 645 code generator */ 2 19 2 c_f_offset fixed bin(6), 2 20 2 address structure unaligned, 2 21 3 base bit(3), 2 22 3 offset bit(15), 2 23 3 op bit(9), 2 24 3 no_address bit(1), 2 25 3 inhibit bit(1), 2 26 3 ext_base bit(1), 2 27 3 tag bit(6), 2 28 2 info structure unaligned, 2 29 3 address_in structure, 2 30 4 b dimension(0:7) bit(1), 2 31 4 storage bit(1), 2 32 3 value_in structure, 2 33 4 a bit(1), 2 34 4 q bit(1), 2 35 4 aq bit(1), 2 36 4 string_aq bit(1), 2 37 4 complex_aq bit(1), 2 38 4 decimal_aq bit(1), 2 39 4 b dimension(0:7) bit(1), 2 40 4 storage bit(1), 2 41 4 indicators bit(1), 2 42 4 x dimension(0:7) bit(1), 2 43 3 other structure, 2 44 4 big_offset bit(1), 2 45 4 big_length bit(1), 2 46 4 modword_in_offset bit(1), 2 47 2 data_type fixed(5) unaligned, 2 48 2 bits structure unaligned, 2 49 3 padded_ref bit(1), 2 50 3 aligned_ref bit(1), 2 51 3 long_ref bit(1), 2 52 3 forward_ref bit(1), 2 53 3 ic_ref bit(1), 2 54 3 temp_ref bit(1), 2 55 3 defined_ref bit(1), 2 56 3 evaluated bit(1), 2 57 3 allocate bit(1), 2 58 3 allocated bit(1), 2 59 3 aliasable bit(1), 2 60 3 even bit(1), 2 61 3 perm_address bit(1), 2 62 3 aggregate bit(1), 2 63 3 hit_zero bit(1), 2 64 3 dont_save bit(1), 2 65 3 fo_in_qual bit(1), 2 66 3 hard_to_load bit(1), 2 67 2 relocation bit(12) unaligned, 2 68 2 more_bits structure unaligned, 2 69 3 substr bit(1), 2 70 3 padded_for_store_ref bit(1), 2 71 3 aligned_for_store_ref bit(1), 2 72 3 mbz bit(15), 2 73 2 store_ins bit(18) unaligned; 2 74 2 75 /* END INCLUDE FILE ... cg_reference.incl.pl1 */ 40 3 1 /* BEGIN INCLUDE FILE ... boundary.incl.pl1 */ 3 2 3 3 /* Modified: 26 Apr 1979 by PCK to implement 4-bit decimal */ 3 4 3 5 dcl ( bit_ init(1), 3 6 digit_ init(2), 3 7 character_ init(3), 3 8 half_ init(4), 3 9 word_ init(5), 3 10 mod2_ init(6), 3 11 mod4_ init(7)) fixed bin(3) int static options(constant); 3 12 3 13 /* END INCLUDE FILE ... boundary.incl.pl1 */ 41 42 43 if cg_stat$next_ref = null 44 then do; 45 q = create_list(2); 46 p, q -> element(2) = create_reference(null); 47 q -> element(1) = cg_stat$first_ref; 48 cg_stat$first_ref = q; 49 goto l1; 50 end; 51 52 q = cg_stat$next_ref; 53 p = q -> element(2); 54 cg_stat$next_ref = q -> element(1); 55 56 p -> reference.offset, 57 p -> reference.symbol, 58 p -> reference.qualifier, 59 p -> reference.length = null; 60 61 p -> reference.c_offset, 62 p -> reference.c_length, 63 p -> reference.data_type = 0; 64 65 p -> reference.value_in.storage = "0"b; 66 p -> reference.store_ins = "0"b; 67 68 if cg_stat$m_s_p ^= null 69 then do; 70 if string(p -> reference.address_in.b) then call state_man$flush_address(p); 71 if string(p -> reference.value_in) then call state_man$flush_ref(p); 72 end; 73 74 l1: string(p -> reference.bits) = "11"b; /* padded, aligned */ 75 string(p -> reference.relocation) = "0"b; 76 string(p -> reference.more_bits) = "0"b; 77 78 p -> reference.padded_for_store_ref, 79 p -> reference.aligned_for_store_ref = "1"b; 80 81 p -> reference.c_f_offset = 0; 82 83 p -> reference.units = word_; 84 85 string(p -> reference.address) = "0000000000000000000000000001"b; /* no_address */ 86 string(p -> reference.info) = "0"b; 87 p -> reference.array_ref, p -> reference.varying_ref, p -> reference.shared = "0"b; 88 89 p -> reference.ref_count = 1; 90 91 return(p); 92 93 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/03/83 1008.5 get_reference.pl1 >spec>on>pl128d>get_reference.pl1 39 1 08/13/81 2211.5 list.incl.pl1 >ldd>include>list.incl.pl1 40 2 07/21/80 1546.3 cg_reference.incl.pl1 >ldd>include>cg_reference.incl.pl1 41 3 10/25/79 1645.8 boundary.incl.pl1 >ldd>include>boundary.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. address 10 based structure level 2 packed unaligned dcl 2-3 set ref 85* address_in 11 based structure level 3 packed unaligned dcl 2-3 aligned_for_store_ref 13(02) based bit(1) level 3 packed unaligned dcl 2-3 set ref 78* array_ref 0(09) based bit(1) level 2 packed unaligned dcl 2-3 set ref 87* b 11 based bit(1) array level 4 packed unaligned dcl 2-3 set ref 70 bits 12(06) based structure level 2 packed unaligned dcl 2-3 set ref 74* c_f_offset 7 based fixed bin(6,0) level 2 dcl 2-3 set ref 81* c_length 2 based fixed bin(24,0) level 2 dcl 2-3 set ref 61* c_offset 1 based fixed bin(24,0) level 2 dcl 2-3 set ref 61* cg_stat$first_ref 000010 external static pointer dcl 30 set ref 47 48* cg_stat$m_s_p 000014 external static pointer dcl 30 ref 68 cg_stat$next_ref 000012 external static pointer dcl 30 set ref 43 52 54* create_list 000016 constant entry external dcl 30 ref 45 create_reference 000020 constant entry external dcl 30 ref 46 data_type 12 based fixed bin(5,0) level 2 packed unaligned dcl 2-3 set ref 61* element 1 based pointer array level 2 packed unaligned dcl 1-6 set ref 46* 47* 53 54 info 11 based structure level 2 packed unaligned dcl 2-3 set ref 86* length 6 based pointer level 2 packed unaligned dcl 2-3 set ref 56* list based structure level 1 dcl 1-6 more_bits 13 based structure level 2 packed unaligned dcl 2-3 set ref 76* null builtin function dcl 37 ref 43 46 46 56 68 offset 5 based pointer level 2 packed unaligned dcl 2-3 set ref 56* p 000100 automatic pointer dcl 30 set ref 46* 53* 56 56 56 56 61 61 61 65 66 70 70* 71 71* 74 75 76 78 78 81 83 85 86 87 87 87 89 91 padded_for_store_ref 13(01) based bit(1) level 3 packed unaligned dcl 2-3 set ref 78* q 000102 automatic pointer dcl 30 set ref 45* 46 47 48 52* 53 54 qualifier 4 based pointer level 2 packed unaligned dcl 2-3 set ref 56* ref_count 0(18) based fixed bin(17,0) level 2 packed unaligned dcl 2-3 set ref 89* reference based structure level 1 dcl 2-3 relocation 12(24) based bit(12) level 2 packed unaligned dcl 2-3 set ref 75* shared 0(11) based bit(1) level 2 packed unaligned dcl 2-3 set ref 87* state_man$flush_address 000024 constant entry external dcl 30 ref 70 state_man$flush_ref 000022 constant entry external dcl 30 ref 71 storage 11(23) based bit(1) level 4 packed unaligned dcl 2-3 set ref 65* store_ins 13(18) based bit(18) level 2 packed unaligned dcl 2-3 set ref 66* string builtin function dcl 37 set ref 70 71 74* 75* 76* 85* 86* symbol 3 based pointer level 2 packed unaligned dcl 2-3 set ref 56* units 0(14) based fixed bin(3,0) level 2 packed unaligned dcl 2-3 set ref 83* value_in 11(09) based structure level 3 packed unaligned dcl 2-3 set ref 71 varying_ref 0(10) based bit(1) level 2 packed unaligned dcl 2-3 set ref 87* word_ constant fixed bin(3,0) initial dcl 3-5 ref 83 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. bit_ internal static fixed bin(3,0) initial dcl 3-5 character_ internal static fixed bin(3,0) initial dcl 3-5 digit_ internal static fixed bin(3,0) initial dcl 3-5 half_ internal static fixed bin(3,0) initial dcl 3-5 max_list_elements internal static fixed bin(17,0) initial dcl 1-12 mod2_ internal static fixed bin(3,0) initial dcl 3-5 mod4_ internal static fixed bin(3,0) initial dcl 3-5 n automatic fixed bin(17,0) dcl 30 NAMES DECLARED BY EXPLICIT CONTEXT. get_reference 000007 constant entry external dcl 28 l1 000135 constant label dcl 74 set ref 49 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 310 336 201 320 Length 560 201 26 205 106 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME get_reference 80 external procedure is an external procedure. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME get_reference 000100 p get_reference 000102 q get_reference THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out return ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. create_list create_reference state_man$flush_address state_man$flush_ref THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. cg_stat$first_ref cg_stat$m_s_p cg_stat$next_ref LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 28 000004 43 000014 45 000020 46 000032 47 000051 48 000055 49 000056 52 000057 53 000062 54 000065 56 000070 61 000075 65 000101 66 000103 68 000105 70 000111 71 000122 74 000135 75 000140 76 000142 78 000144 81 000150 83 000151 85 000155 86 000157 87 000160 89 000166 91 000170 ----------------------------------------------------------- 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