COMPILATION LISTING OF SEGMENT compile_tree Compiled by: Multics PL/I Compiler, Release 28d, of September 14, 1983 Compiled at: Honeywell LCPD Phoenix, System M Compiled on: 10/03/83 1628.4 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 /* Procedure to compile root operator of a statement 12* 13* Initial Version: 16 April 1971 by BLW 14* Modified: 29 December 1972 by BLW 15* Modified: 28 February 1973 by RAB 16* Modified: 18 June 1973 by RAB 17* Modified: 6 October 1973 by RAB for EIS 18* Modified: 23 June 1976 by R. Schoeman for new area package 19* Modified: 24 June 1976 by RAB to centralize use of cg_stat$last_call 20* Modified: 30 January 1977 by RAB to dec ref_count in allot_ctl & free_ctl 21* Modified: 15 April 1979 by RAB to improve code for a = a & b; for 22* based long strings by checking for allowable cases of overlap 23* Modified: 17 August 1979 by RAB to improve code for a = a & ^ b; for long strings. 24* One instruction is generated instead of two or more. 25* Modified 791016 by PG to fix 1856 (multiple assignment code bumped ref count on 26* a shared reference node owned by a top-level bound_ck operator!) 27* Modified 830106 by BIM to align aggregate loops on doubleword 28* boundaries. 29**/ 30 31 compile_tree: proc(pt); 32 33 /* parameters */ 34 35 dcl pt ptr parameter; /* point at an operator node */ 36 37 /* external static */ 38 39 dcl (cg_stat$prol_ent,cg_stat$cur_block,cg_stat$cur_statement,cg_stat$cur_node,cg_stat$cur_tree) ptr ext, 40 cg_stat$text_pos fixed bin(18) ext; 41 42 /* automatic */ 43 44 dcl (p,arg(3),llp,ulp,p1,q1,p2,q2,q3,s1,s2,rand(10),save_cur_node) ptr, 45 macro fixed bin(15), 46 op_code bit(9), 47 (atomic,abset) bit(1) aligned, 48 (i,j,k,loc,n,cfo,d) fixed bin; 49 50 /* based */ 51 52 dcl fix_bin fixed bin based; 53 54 /* defined */ 55 56 dcl op_class bit(5) defined(op_code) pos(1); 57 58 /* entries */ 59 60 dcl (assign_op,compile_tree,compile_exp,move_data, 61 state_man$flush_ref,jump_op,io_op) entry(ptr); 62 dcl m_a entry(ptr,bit(2) aligned); 63 dcl base_man$load_var entry(fixed bin,ptr,fixed bin), 64 base_to_core entry(fixed bin,ptr), 65 base_man$store_ptr_to entry(ptr,ptr), 66 base_man$update_base entry(fixed bin,ptr,fixed bin); 67 dcl compare_expression entry(ptr,ptr) returns(bit(1) aligned) reducible; 68 dcl adjust_ref_count entry(ptr,fixed bin), 69 call_op entry(ptr) returns(ptr), 70 compile_exp$save entry(ptr) returns(ptr), 71 compile_exp$save_exp entry(ptr) returns(ptr), 72 load entry(ptr,fixed bin), 73 create_label entry(ptr,ptr,bit(3) aligned) returns(ptr), 74 store$force entry(ptr), 75 xr_man$load_const entry(fixed bin(31),fixed bin), 76 (state_man$flush,io_op$init_ps) entry, 77 state_man$erase_reg entry(bit(19) aligned), 78 state_man$set_aliasables entry(ptr), 79 c_a entry(fixed bin,fixed bin) returns(ptr), 80 aq_man$clear_q entry, 81 expmac$one entry(fixed bin(15),ptr,fixed bin), 82 expmac$zero entry(fixed bin(15)), 83 expmac$many entry(fixed bin(15),ptr,fixed bin), 84 expmac$two_eis entry(fixed bin(15),ptr,ptr), 85 prepare_operand entry(ptr,fixed bin,bit(1) aligned) returns(ptr), 86 expmac entry(fixed bin(15),ptr), 87 decimal_op$change_target entry(ptr) returns(bit(1) aligned), 88 decimal_op$get_float_temp entry(fixed bin(24),bit(1) aligned) returns(ptr), 89 assign_op$to_dec_scaled entry(ptr,ptr), 90 stack_temp$assign_aggregate entry(ptr); 91 92 /* builtins */ 93 94 dcl (addr,fixed,mod,null) builtin; 95 96 /* internal static */ 97 98 dcl odd_bases bit(19) aligned int static init("0000000000000001111"b); 99 100 dcl ( call_prologue init(204), 101 aos_mac init(309), 102 nop_mac init(528), 103 incr_mac init(310), 104 diff_mac init(311), 105 allot_auto_mac init(114), 106 zero_mac init(308), 107 open_mac init(493), 108 close_mac init(494), 109 make_desc_mac init(275), 110 arl init(245), 111 lrl init(62), 112 signal_mac init(289), 113 io_signal_mac init(321), 114 revert_mac init(290), 115 revert_file init(607), 116 string_mac(33:35) init(43,49,55), 117 long_mac(33:35) init(264,304,341), 118 move_andnot_1 init(392), 119 set_desc_size init(276), 120 alloc_block init(608), 121 free_block init(609), 122 alloc_based_area init(502), 123 alloc_based_mac init(695), 124 free_based_mac init(696), 125 empty_area_mac init(697), 126 push_ctl_data init(610), 127 push_ctl_desc init(611), 128 pop_ctl_data init(612), 129 pop_ctl_desc init(613), 130 loop_end init(397)) fixed bin(15) int static options (constant); 131 132 dcl ( jump_class init("00101"b), 133 ptr_class init("01011"b), 134 io_class init("10000"b)) bit(5) int static options (constant); 135 136 /* include files */ 137 1 1 /* BEGIN INCLUDE FILE ... cgsystem.incl.pl1 */ 1 2 1 3 /* Modified: 25 Apr 1979 by PCK to implement 4-bit decimal */ 1 4 1 5 dcl ( bits_per_char init(9), 1 6 bits_per_half init(18), 1 7 bits_per_word init(36), 1 8 bits_per_two_words init(72), 1 9 bits_per_four_words init(144), 1 10 bits_per_words(2) init(36,72), 1 11 packed_digits_per_char init(2), 1 12 chars_per_word init(4), 1 13 packed_digits_per_word init(8), 1 14 1 15 break_even_bits init(216), 1 16 break_even_words init(6), 1 17 1 18 label_size init(4), 1 19 1 20 convert_size(13:14) init(9,1), 1 21 max_offset(13:14) init(27,35), 1 22 max_short_size(13:14) init(8,72), 1 23 1 24 units_per_word(0:5) init(1,36,8,4,2,1), 1 25 1 26 max_dec_scale init(32), 1 27 min_dec_scale init(-31), 1 28 max_p_xreg init(18), 1 29 max_p_fix_bin_1 init(35), 1 30 max_p_flt_bin_1 init(27), 1 31 max_p_fix_dec init(59), 1 32 max_length_p init(24), 1 33 default_fix_bin_p init(17)) fixed bin(8) int static options(constant); 1 34 1 35 dcl (convert_offset(0:5) init(36,1,4.5,9,18,36), 1 36 bits_per_packed_digit init(4.5)) fixed bin(8,1) int static options(constant); 1 37 1 38 dcl max_index_register_value init(262143) fixed bin(31) int static options(constant); 1 39 1 40 /* END INCLUDE FILE ... cgsystem.incl.pl1 */ 1 41 138 2 1 /* BEGIN INCLUDE FILE ... block.incl.pl1 */ 2 2 /* Modified 22 Ocober 1980 by M. N. Davidoff to increase max block.number to 511 */ 2 3 /* format: style3,idind30 */ 2 4 2 5 declare 1 block aligned based, 2 6 2 node_type bit (9) unaligned, 2 7 2 source_id structure unaligned, 2 8 3 file_number bit (8), 2 9 3 line_number bit (14), 2 10 3 statement_number bit (5), 2 11 2 father ptr unaligned, 2 12 2 brother ptr unaligned, 2 13 2 son ptr unaligned, 2 14 2 declaration ptr unaligned, 2 15 2 end_declaration ptr unaligned, 2 16 2 default ptr unaligned, 2 17 2 end_default ptr unaligned, 2 18 2 context ptr unaligned, 2 19 2 prologue ptr unaligned, 2 20 2 end_prologue ptr unaligned, 2 21 2 main ptr unaligned, 2 22 2 end_main ptr unaligned, 2 23 2 return_values ptr unaligned, 2 24 2 return_count ptr unaligned, 2 25 2 plio_ps ptr unaligned, 2 26 2 plio_fa ptr unaligned, 2 27 2 plio_ffsb ptr unaligned, 2 28 2 plio_ssl ptr unaligned, 2 29 2 plio_fab2 ptr unaligned, 2 30 2 block_type bit (9) unaligned, 2 31 2 prefix bit (12) unaligned, 2 32 2 like_attribute bit (1) unaligned, 2 33 2 no_stack bit (1) unaligned, 2 34 2 get_data bit (1) unaligned, 2 35 2 flush_at_call bit (1) unaligned, 2 36 2 processed bit (1) unaligned, 2 37 2 text_displayed bit (1) unaligned, 2 38 2 number fixed bin (9) unsigned unaligned, 2 39 2 free_temps dimension (3) ptr, /* these fields are used by the code generator */ 2 40 2 temp_list ptr, 2 41 2 entry_list ptr, 2 42 2 o_and_s ptr, 2 43 2 why_nonquick aligned, 2 44 3 auto_adjustable_storage bit (1) unaligned, 2 45 3 returns_star_extents bit (1) unaligned, 2 46 3 stack_extended_by_args bit (1) unaligned, 2 47 3 invoked_by_format bit (1) unaligned, 2 48 3 format_statement bit (1) unaligned, 2 49 3 io_statements bit (1) unaligned, 2 50 3 assigned_to_entry_var bit (1) unaligned, 2 51 3 condition_statements bit (1) unaligned, 2 52 3 no_owner bit (1) unaligned, 2 53 3 recursive_call bit (1) unaligned, 2 54 3 options_non_quick bit (1) unaligned, 2 55 3 options_variable bit (1) unaligned, 2 56 3 never_referenced bit (1) unaligned, 2 57 3 pad_nonquick bit (5) unaligned, 2 58 2 prologue_flag bit (1) unaligned, 2 59 2 options_main bit (1) unaligned, 2 60 2 pad bit (16) unaligned, 2 61 2 number_of_entries fixed bin (17), 2 62 2 level fixed bin (17), 2 63 2 last_auto_loc fixed bin (17), 2 64 2 symbol_block fixed bin (17), 2 65 2 entry_info fixed bin (18), 2 66 2 enter structure unaligned, 2 67 3 start fixed bin (17), 2 68 3 end fixed bin (17), 2 69 2 leave structure unaligned, 2 70 3 start fixed bin (17), 2 71 3 end fixed bin (17), 2 72 2 owner ptr; 2 73 2 74 declare max_block_number fixed bin internal static options (constant) initial (511); 2 75 2 76 /* END INCLUDE FILE ... block.incl.pl1 */ 139 3 1 /* *********************************************************** 3 2* * * 3 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 3 4* * * 3 5* *********************************************************** */ 3 6 /* BEGIN INCLUDE FILE ... statement.incl.pl1 */ 3 7 /* Internal interface of the PL/I compiler */ 3 8 3 9 dcl 1 statement based aligned, 3 10 2 node_type bit(9) unaligned, 3 11 2 source_id structure unaligned, 3 12 3 file_number bit(8), 3 13 3 line_number bit(14), 3 14 3 statement_number bit(5), 3 15 2 next ptr unaligned, 3 16 2 back ptr unaligned, 3 17 2 root ptr unaligned, 3 18 2 labels ptr unaligned, 3 19 2 reference_list ptr unaligned, 3 20 2 state_list ptr unaligned, 3 21 2 reference_count fixed(17) unaligned, 3 22 2 ref_count_copy fixed(17) unaligned, 3 23 2 object structure unaligned, 3 24 3 start fixed(17), 3 25 3 finish fixed(17), 3 26 2 source structure unaligned, 3 27 3 segment fixed(11), 3 28 3 start fixed(23), 3 29 3 length fixed(11), 3 30 2 prefix bit(12) unaligned, 3 31 2 optimized bit(1) unaligned, 3 32 2 free_temps bit(1) unaligned, 3 33 2 LHS_in_RHS bit(1) unaligned, 3 34 2 statement_type bit(9) unaligned, 3 35 2 bits structure unaligned, 3 36 3 processed bit(1) unaligned, 3 37 3 put_in_profile bit(1) unaligned, 3 38 3 generated bit(1) unaligned, 3 39 3 snap bit(1) unaligned, 3 40 3 system bit(1) unaligned, 3 41 3 irreducible bit(1) unaligned, 3 42 3 checked bit(1) unaligned, 3 43 3 save_temps bit(1) unaligned, 3 44 3 suppress_warnings bit(1) unaligned, 3 45 3 force_nonquick bit(1) unaligned, 3 46 3 expanded_by_name bit(1) unaligned, 3 47 3 begins_loop bit(1) unaligned, 3 48 3 pad bit(24) unaligned; 3 49 3 50 /* END INCLUDE FILE ... statement.incl.pl1 */ 140 4 1 /* BEGIN INCLUDE FILE ... operator.incl.pl1 */ 4 2 4 3 /* Modified: 2 Apr 1980 by PCK to add max_number_of_operands */ 4 4 4 5 /* format: style3 */ 4 6 dcl 1 operator based aligned, 4 7 2 node_type bit (9) unaligned, 4 8 2 op_code bit (9) unaligned, 4 9 2 shared bit (1) unaligned, 4 10 2 processed bit (1) unaligned, 4 11 2 optimized bit (1) unaligned, 4 12 2 number fixed (14) unaligned, 4 13 2 operand dimension (n refer (operator.number)) ptr unaligned; 4 14 4 15 dcl max_number_of_operands 4 16 fixed bin (15) int static options (constant) initial (32767); 4 17 4 18 /* END INCLUDE FILE ... operator.incl.pl1 */ 141 5 1 /* BEGIN INCLUDE FILE ... reference.incl.pl1 */ 5 2 5 3 dcl 1 reference based aligned, 5 4 2 node_type bit(9) unaligned, 5 5 2 array_ref bit(1) unaligned, 5 6 2 varying_ref bit(1) unaligned, 5 7 2 shared bit(1) unaligned, 5 8 2 put_data_sw bit(1) unaligned, 5 9 2 processed bit(1) unaligned, 5 10 2 units fixed(3) unaligned, 5 11 2 ref_count fixed(17) unaligned, 5 12 2 c_offset fixed(24), 5 13 2 c_length fixed(24), 5 14 2 symbol ptr unaligned, 5 15 2 qualifier ptr unaligned, 5 16 2 offset ptr unaligned, 5 17 2 length ptr unaligned, 5 18 2 subscript_list ptr unaligned, 5 19 /* these fields are used by the 645 code generator */ 5 20 2 address structure unaligned, 5 21 3 base bit(3), 5 22 3 offset bit(15), 5 23 3 op bit(9), 5 24 3 no_address bit(1), 5 25 3 inhibit bit(1), 5 26 3 ext_base bit(1), 5 27 3 tag bit(6), 5 28 2 info structure unaligned, 5 29 3 address_in structure, 5 30 4 b dimension(0:7) bit(1), 5 31 4 storage bit(1), 5 32 3 value_in structure, 5 33 4 a bit(1), 5 34 4 q bit(1), 5 35 4 aq bit(1), 5 36 4 string_aq bit(1), 5 37 4 complex_aq bit(1), 5 38 4 decimal_aq bit(1), 5 39 4 b dimension(0:7) bit(1), 5 40 4 storage bit(1), 5 41 4 indicators bit(1), 5 42 4 x dimension(0:7) bit(1), 5 43 3 other structure, 5 44 4 big_offset bit(1), 5 45 4 big_length bit(1), 5 46 4 modword_in_offset bit(1), 5 47 2 data_type fixed(5) unaligned, 5 48 2 bits structure unaligned, 5 49 3 padded_ref bit(1), 5 50 3 aligned_ref bit(1), 5 51 3 long_ref bit(1), 5 52 3 forward_ref bit(1), 5 53 3 ic_ref bit(1), 5 54 3 temp_ref bit(1), 5 55 3 defined_ref bit(1), 5 56 3 evaluated bit(1), 5 57 3 allocate bit(1), 5 58 3 allocated bit(1), 5 59 3 aliasable bit(1), 5 60 3 even bit(1), 5 61 3 perm_address bit(1), 5 62 3 aggregate bit(1), 5 63 3 hit_zero bit(1), 5 64 3 dont_save bit(1), 5 65 3 fo_in_qual bit(1), 5 66 3 hard_to_load bit(1), 5 67 2 relocation bit(12) unaligned, 5 68 2 more_bits structure unaligned, 5 69 3 substr bit(1), 5 70 3 padded_for_store_ref bit(1), 5 71 3 aligned_for_store_ref bit(1), 5 72 3 mbz bit(15), 5 73 2 store_ins bit(18) unaligned; 5 74 5 75 /* END INCLUDE FILE ... reference.incl.pl1 */ 142 6 1 /* BEGIN INCLUDE FILE ... symbol.incl.pl1 */ 6 2 6 3 dcl 1 symbol based aligned, 6 4 2 node_type bit(9) unal, 6 5 2 source_id structure unal, 6 6 3 file_number bit(8), 6 7 3 line_number bit(14), 6 8 3 statement_number bit(5), 6 9 2 location fixed(18) unal unsigned, 6 10 2 allocated bit(1) unal, 6 11 2 dcl_type bit(3) unal, 6 12 2 reserved bit(6) unal, 6 13 2 pix unal, 6 14 3 pic_fixed bit(1) unal, 6 15 3 pic_float bit(1) unal, 6 16 3 pic_char bit(1) unal, 6 17 3 pic_scale fixed(7) unal, 6 18 3 pic_size fixed(7) unal, 6 19 2 level fixed(8) unal, 6 20 2 boundary fixed(3) unal, 6 21 2 size_units fixed(3) unal, 6 22 2 scale fixed(7) unal, 6 23 2 runtime bit(18) unal, 6 24 2 runtime_offset bit(18) unal, 6 25 2 block_node ptr unal, 6 26 2 token ptr unal, 6 27 2 next ptr unal, 6 28 2 multi_use ptr unal, 6 29 2 cross_references ptr unal, 6 30 2 initial ptr unal, 6 31 2 array ptr unal, 6 32 2 descriptor ptr unal, 6 33 2 equivalence ptr unal, 6 34 2 reference ptr unal, 6 35 2 general ptr unal, 6 36 2 father ptr unal, 6 37 2 brother ptr unal, 6 38 2 son ptr unal, 6 39 2 word_size ptr unal, 6 40 2 bit_size ptr unal, 6 41 2 dcl_size ptr unal, 6 42 2 symtab_size ptr unal, 6 43 2 c_word_size fixed(24), 6 44 2 c_bit_size fixed(24), 6 45 2 c_dcl_size fixed(24), 6 46 6 47 2 attributes structure aligned, 6 48 3 data_type structure unal, 6 49 4 structure bit(1) , 6 50 4 fixed bit(1), 6 51 4 float bit(1), 6 52 4 bit bit(1), 6 53 4 char bit(1), 6 54 4 ptr bit(1), 6 55 4 offset bit(1), 6 56 4 area bit(1), 6 57 4 label bit(1), 6 58 4 entry bit(1), 6 59 4 file bit(1), 6 60 4 arg_descriptor bit(1), 6 61 4 storage_block bit(1), 6 62 4 explicit_packed bit(1), /* options(packed) */ 6 63 4 condition bit(1), 6 64 4 format bit(1), 6 65 4 builtin bit(1), 6 66 4 generic bit(1), 6 67 4 picture bit(1), 6 68 6 69 3 misc_attributes structure unal, 6 70 4 dimensioned bit(1), 6 71 4 initialed bit(1), 6 72 4 aligned bit(1), 6 73 4 unaligned bit(1), 6 74 4 signed bit(1), 6 75 4 unsigned bit(1), 6 76 4 precision bit(1), 6 77 4 varying bit(1), 6 78 4 local bit(1), 6 79 4 decimal bit(1), 6 80 4 binary bit(1), 6 81 4 real bit(1), 6 82 4 complex bit(1), 6 83 4 variable bit(1), 6 84 4 reducible bit(1), 6 85 4 irreducible bit(1), 6 86 4 returns bit(1), 6 87 4 position bit(1), 6 88 4 internal bit(1), 6 89 4 external bit(1), 6 90 4 like bit(1), 6 91 4 member bit(1), 6 92 4 non_varying bit(1), 6 93 4 options bit(1), 6 94 4 variable_arg_list bit(1), /* options(variable) */ 6 95 4 alloc_in_text bit(1), /* options(constant) */ 6 96 6 97 3 storage_class structure unal, 6 98 4 auto bit(1), 6 99 4 based bit(1), 6 100 4 static bit(1), 6 101 4 controlled bit(1), 6 102 4 defined bit(1), 6 103 4 parameter bit(1), 6 104 4 param_desc bit(1), 6 105 4 constant bit(1), 6 106 4 temporary bit(1), 6 107 4 return_value bit(1), 6 108 6 109 3 file_attributes structure unal, 6 110 4 print bit(1), 6 111 4 input bit(1), 6 112 4 output bit(1), 6 113 4 update bit(1), 6 114 4 stream bit(1), 6 115 4 reserved_1 bit(1), 6 116 4 record bit(1), 6 117 4 sequential bit(1), 6 118 4 direct bit(1), 6 119 4 interactive bit(1), /* env(interactive) */ 6 120 4 reserved_2 bit(1), 6 121 4 reserved_3 bit(1), 6 122 4 stringvalue bit(1), /* env(stringvalue) */ 6 123 4 keyed bit(1), 6 124 4 reserved_4 bit(1), 6 125 4 environment bit(1), 6 126 6 127 3 compiler_developed structure unal, 6 128 4 aliasable bit(1), 6 129 4 packed bit(1), 6 130 4 passed_as_arg bit(1), 6 131 4 allocate bit(1), 6 132 4 set bit(1), 6 133 4 exp_extents bit(1), 6 134 4 refer_extents bit(1), 6 135 4 star_extents bit(1), 6 136 4 isub bit(1), 6 137 4 put_in_symtab bit(1), 6 138 4 contiguous bit(1), 6 139 4 put_data bit(1), 6 140 4 overlayed bit(1), 6 141 4 error bit(1), 6 142 4 symtab_processed bit(1), 6 143 4 overlayed_by_builtin bit(1), 6 144 4 defaulted bit(1), 6 145 4 connected bit(1); 6 146 6 147 /* END INCLUDE FILE ... symbol.incl.pl1 */ 143 7 1 dcl 1 label based aligned, 7 2 2 node_type bit(9) unaligned, 7 3 2 source_id structure unaligned, 7 4 3 file_number bit(8), 7 5 3 line_number bit(14), 7 6 3 statement_number bit(5), 7 7 2 location fixed(17) unaligned, 7 8 2 allocated bit(1) unaligned, 7 9 2 dcl_type bit(3) unaligned, 7 10 2 reserved bit(29) unaligned, 7 11 2 array bit(1) unaligned, 7 12 2 used_as_format bit(1) unaligned, 7 13 2 used_in_goto bit(1) unaligned, 7 14 2 symbol_table bit(18) unaligned, 7 15 2 low_bound fixed(17) unaligned, 7 16 2 high_bound fixed(17) unaligned, 7 17 2 block_node ptr unaligned, 7 18 2 token ptr unaligned, 7 19 2 next ptr unaligned, 7 20 2 multi_use ptr unaligned, 7 21 2 cross_reference ptr unaligned, 7 22 2 statement ptr unaligned; 144 8 1 /* BEGIN INCLUDE FILE ... nodes.incl.pl1 */ 8 2 8 3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */ 8 4 8 5 dcl ( block_node initial("000000001"b), 8 6 statement_node initial("000000010"b), 8 7 operator_node initial("000000011"b), 8 8 reference_node initial("000000100"b), 8 9 token_node initial("000000101"b), 8 10 symbol_node initial("000000110"b), 8 11 context_node initial("000000111"b), 8 12 array_node initial("000001000"b), 8 13 bound_node initial("000001001"b), 8 14 format_value_node initial("000001010"b), 8 15 list_node initial("000001011"b), 8 16 default_node initial("000001100"b), 8 17 machine_state_node initial("000001101"b), 8 18 source_node initial("000001110"b), 8 19 label_node initial("000001111"b), 8 20 cross_reference_node initial("000010000"b), 8 21 sf_par_node initial("000010001"b), 8 22 temporary_node initial("000010010"b), 8 23 label_array_element_node initial("000010011"b), 8 24 by_name_agg_node initial("000010100"b)) 8 25 bit(9) internal static aligned options(constant); 8 26 8 27 dcl 1 node based aligned, 8 28 2 type unal bit(9), 8 29 2 source_id unal structure, 8 30 3 file_number bit(8), 8 31 3 line_number bit(14), 8 32 3 statement_number bit(5); 8 33 8 34 /* END INCLUDE FILE ... nodes.incl.pl1 */ 145 9 1 /* BEGIN INCLUDE FILE ... declare_type.incl.pl1 */ 9 2 9 3 /* Modified: 25 Apr 1979 by PCK to implement 4-bit decimal */ 9 4 9 5 dcl ( by_declare initial("001"b), 9 6 by_explicit_context initial("010"b), 9 7 by_context initial("011"b), 9 8 by_implication initial("100"b), 9 9 by_compiler initial("101"b)) int static bit(3) aligned options(constant); 9 10 9 11 /* END INCLUDE FILE ... declare_type.incl.pl1 */ 146 10 1 /* BEGIN INCLUDE FILE ... op_codes.incl.pl1 */ 10 2 10 3 /* Modified: 25 Apr 1979 by PCK 4-bit decimal */ 10 4 /* Modified: 6 Jun 1979 by PG to add rank and byte */ 10 5 /* Modified: 26 Dec 1979 by PCK to add assign_by_name */ 10 6 /* Modified: 26 July 82 BIM wordno, segno */ 10 7 10 8 dcl ( add initial("000010001"b), /* opnd(1) <- opnd(2)+opnd(3) */ 10 9 sub initial("000010010"b), /* opnd(1) <- opnd(2)-opnd(3) */ 10 10 mult initial("000010011"b), /* opnd(1) <- opnd(2)*opnd(3) */ 10 11 div initial("000010100"b), /* opnd(1) <- opnd(2)/opnd(3) */ 10 12 negate initial("000010101"b), /* opnd(1) <- -opnd(2) */ 10 13 exp initial("000010110"b), /* opnd(1) <- opnd(2) ** opnd(3) */ 10 14 10 15 and_bits initial("000100001"b), /* opnd(1) <- opnd(2) & opnd(3) */ 10 16 or_bits initial("000100010"b), /* opnd(1) <- opnd(2)|opnd(3) */ 10 17 xor_bits initial("000100011"b), /* opnd(1) <- opnd(2) xor opnd(3) */ 10 18 not_bits initial("000100100"b), /* opnd(1) <- ^opnd(2) */ 10 19 cat_string initial("000100101"b), /* opnd(1) <- opnd(2)||opnd(3) */ 10 20 bool_fun initial("000100110"b), /* opnd(1) <- bool(opnd(2),opnd(3),opnd(4)) */ 10 21 10 22 assign initial("000110001"b), /* opnd(1) <- opnd(2) */ 10 23 assign_size_ck initial("000110010"b), /* opnd(1) <- opnd(2) */ 10 24 assign_zero initial("000110011"b), /* opnd(1) <- 0 */ 10 25 copy_words initial("000110100"b), /* move opnd(2) to opnd(1) by opnd(3) words */ 10 26 copy_string initial("000110101"b), /* move opnd(2) to opnd(1) by opnd(3) units */ 10 27 make_desc initial("000110110"b), /* opnd(1) <- descriptor(opnd(2),opnd(3)) */ 10 28 assign_round initial("000110111"b), /* opnd(1) <- opnd(2) rounded */ 10 29 pack initial("000111000"b), /* opnd(1) <- encode to picture opnd(2) */ 10 30 unpack initial("000111001"b), /* opnd(1) <- decode from picture opnd(2) */ 10 31 10 32 less_than initial("001000100"b), /* opnd(1) <- opnd(2) < opnd(3) */ 10 33 greater_than initial("001000101"b), /* opnd(1) <- opnd(2) > opnd(3) */ 10 34 equal initial("001000110"b), /* opnd(1) <- opnd(2) = opnd(3) */ 10 35 not_equal initial("001000111"b), /* opnd(1) <- opnd(2) ^= opnd(3) */ 10 36 less_or_equal initial("001001000"b), /* opnd(1) <- opnd(2) <= opnd(3) */ 10 37 greater_or_equal initial("001001001"b), /* opnd(1) <- opnd(2) >= opnd(3) */ 10 38 10 39 jump initial("001010001"b), /* go to opnd(1) unconditionally */ 10 40 jump_true initial("001010010"b), /* go to opnd(1) if opnd(2) is not 0 */ 10 41 jump_false initial("001010011"b), /* go to opnd(1) if opnd(2) is all 0 */ 10 42 jump_if_lt initial("001010100"b), /* go to opnd(1) if opnd(2) < opnd(3) */ 10 43 jump_if_gt initial("001010101"b), /* go to opnd(1) if opnd(2) > opnd(3) */ 10 44 jump_if_eq initial("001010110"b), /* go to opnd(1) if opnd(2) = opnd(3) */ 10 45 jump_if_ne initial("001010111"b), /* go to opnd(1) if opnd(2) ^= opnd(3) */ 10 46 jump_if_le initial("001011000"b), /* go to opnd(1) if opnd(2) <= opnd(3) */ 10 47 jump_if_ge initial("001011001"b), /* go to opnd(1) if opnd(2) >= opnd(3) */ 10 48 10 49 std_arg_list initial("001100001"b), /* opnd(1) <- arglist(opnd(2) desclist(opnd(3))) */ 10 50 return_words initial("001100010"b), /* return aggregate opnd(1), opnd(2) is length in words */ 10 51 std_call initial("001100011"b), /* opnd(1) <- call opnd(2) with opnd(3) */ 10 52 return_bits initial("001100100"b), /* return aggregate opnd(1), opnd(2) is length in bits */ 10 53 std_entry initial("001100101"b), /* entry(opnd(1)... opnd(n)) */ 10 54 return_string initial("001100110"b), /* return string opnd(1) */ 10 55 ex_prologue initial("001100111"b), /* execute the prologue -no operands- */ 10 56 allot_auto initial("001101000"b), /* opnd(1) <- addrel(stack,opnd(2)) */ 10 57 param_ptr initial("001101001"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 10 58 param_desc_ptr initial("001101010"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 10 59 std_return initial("001101011"b), /* return -no arguments- */ 10 60 allot_ctl initial("001101100"b), /* allocate opnd(1) , length in words is opnd(2) */ 10 61 free_ctl initial("001101101"b), /* free opnd(1) */ 10 62 stop initial("001101110"b), /* stop - terminate run unit */ 10 63 10 64 mod_bit initial("001110000"b), /* opnd(1) <- mod(opnd(3),36), 10 65* opnd(2) <- opnd(3) / 36 */ 10 66 mod_byte initial("001110001"b), /* opnd(1) <- mod(opnd(3),4), 10 67* opnd(2) <- opnd(3) / 4 */ 10 68 mod_half initial("001110010"b), /* opnd(1) <- mod(opnd(3),2), 10 69* opnd(2) <- opnd(3) / 2 */ 10 70 mod_word initial("001110011"b), /* TO BE DEFINED BY BLW */ 10 71 10 72 bit_to_char initial("010000000"b), /* opnd(1) <- (opnd(2)+8)/9 */ 10 73 bit_to_word initial("010000001"b), /* opnd(1) <- (opnd(2)+35)/36 */ 10 74 char_to_word initial("010000010"b), /* opnd(1) <- (opnd(2)+3)/4 */ 10 75 half_to_word initial("010000011"b), /* opnd(1) <- (opnd(2)+1)/2 */ 10 76 word_to_mod2 initial("010000100"b), /* opnd(1) <- (opnd(2)+1)/2*2 */ 10 77 word_to_mod4 initial("010000101"b), /* opnd(1) <- (opnd(2)+3)/4*4 */ 10 78 word_to_mod8 initial("010000110"b), /* opnd(1) <- (opnd(2)+7)/8*8 */ 10 79 rel_fun initial("010000111"b), /* opnd(1) <- rel(opnd(2)) */ 10 80 baseno_fun initial("010001000"b), /* opnd(1) <- baseno(opnd(2)) */ 10 81 desc_size initial("010001001"b), /* opnd(1) <- substr(opnd(2),13,24) */ 10 82 bit_pointer initial("010001010"b), /* opnd(1) <- bit offset of opnd(2) */ 10 83 index_before_fun initial("010001011"b), /* opnd(1) <- length of before(opnd(2),opnd(3)) */ 10 84 index_after_fun initial("010001100"b), /* opnd(1) <- offset of after(opnd(2),opnd(3)) in opnd(2) */ 10 85 verify_ltrim_fun initial("010001101"b), /* opnd(1) <- offset of ltrim(opnd(2),opnd(3)) in opnd(2) */ 10 86 verify_rtrim_fun initial("010001110"b), /* opnd(1) <- length(opnd(2))-length(rtrim(opnd(2),opnd(3))) */ 10 87 digit_to_bit initial("010001111"b), /* opnd(1) <- 9*opnd(2)/2 */ 10 88 10 89 ceil_fun initial("010010000"b), /* opnd(1) <- ceil(opnd(2)) */ 10 90 floor_fun initial("010010001"b), /* opnd(1) <- floor(opnd(2)) */ 10 91 round_fun initial("010010010"b), /* opnd(1) <- round(opnd(2)) */ 10 92 sign_fun initial("010010011"b), /* opnd(1) <- sign(opnd(2)) */ 10 93 abs_fun initial("010010100"b), /* opnd(1) <- abs(opnd(2)) */ 10 94 trunc_fun initial("010010101"b), /* opnd(1) <- trunc(opnd(2)) */ 10 95 byte_fun initial("010010110"b), /* opnd(1) <- byte(opnd(2)) */ 10 96 rank_fun initial("010010111"b), /* opnd(1) <- rank(opnd(2)) */ 10 97 index_rev_fun initial("010011000"b), /* opnd(1) <- index(reverse(opnd(2)),reverse(opnd(3))) */ 10 98 search_rev_fun initial("010011001"b), /* opnd(1) <- search(reverse(opnd(2)),opnd(3)) */ 10 99 verify_rev_fun initial("010011010"b), /* opnd(1) <- verify(reverse(opnd(2)),opnd(3)) */ 10 100 wordno_fun initial("010011011"b), /* opnd(1) <- wordno (opnd(2)) */ 10 101 segno_fun initial("010011100"b), /* opnd(1) <- segno (opnd(2)) */ 10 102 bitno_fun initial("010011101"b), /* opnd(1) <- bitno (opnd(2)) */ 10 103 charno_fun initial("010011110"b), /* opnd(1) <- charno (opnd(2)) */ 10 104 10 105 index_fun initial("010100000"b), /* opnd(1) <- index(opnd(2),opnd(3)) */ 10 106 off_fun initial("010100001"b), /* opnd(1) <- offset(opnd(2),opnd(3)) */ 10 107 complex_fun initial("010100010"b), /* opnd(1) <- complex(opnd(2),opnd(3)) */ 10 108 conjg_fun initial("010100011"b), /* opnd(1) <- conjg(opnd(2),opnd(3)) */ 10 109 mod_fun initial("010100100"b), /* opnd(1) <- mod(opnd(2),opnd(3)) */ 10 110 repeat_fun initial("010100101"b), /* opnd(1) <- repeat(opnd(2),opnd(3)) */ 10 111 verify_fun initial("010100110"b), /* opnd(1) <- verify(opnd(2),opnd(3)) */ 10 112 translate_fun initial("010100111"b), /* opnd(1) <- translate(opnd(2),opnd(3))*/ 10 113 real_fun initial("010101001"b), /* opnd(1) <- real(opnd(2)) */ 10 114 imag_fun initial("010101010"b), /* opnd(1) <- imag(opnd(2)) */ 10 115 length_fun initial("010101011"b), /* opnd(1) <- length(opnd(2)) */ 10 116 pl1_mod_fun initial("010101100"b), /* opnd(1) <- mod(opnd(2)) */ 10 117 search_fun initial("010101101"b), /* opnd(1) <- search(opnd(2),opnd(3)) */ 10 118 allocation_fun initial("010101110"b), /* opnd(1) <- allocation(opnd(2)) */ 10 119 reverse_fun initial("010101111"b), /* opnd(1) <- reverse(opnd(2)) */ 10 120 10 121 addr_fun initial("010110000"b), /* opnd(1) <- addr(opnd(2)) */ 10 122 addr_fun_bits initial("010110001"b), /* opnd(1) <- addr(opnd(2)) */ 10 123 ptr_fun initial("010110010"b), /* opnd(1) <- ptr(opnd(2),opnd(3)) */ 10 124 baseptr_fun initial("010110011"b), /* opnd(1) <- baseptr(opnd(2)) */ 10 125 addrel_fun initial("010110100"b), /* opnd(1) <- addrel(opnd(2),opnd(3)) */ 10 126 codeptr_fun initial("010110101"b), /* opnd(1) <- codeptr(opnd(2)) */ 10 127 environmentptr_fun initial("010110110"b), /* opnd(1) <- environmentptr(opnd(2)) */ 10 128 stackbaseptr_fun initial("010110111"b), /* opnd(1) is ptr to base of current stack */ 10 129 stackframeptr_fun initial("010111000"b), /* opnd(1) is ptr to current block's stack frame */ 10 130 setcharno_fun initial("010111001"b), /* opnd(1) <- opnd(2) with charno opnd(3) */ 10 131 addcharno_fun initial("010111010"b), /* opnd(1) <- opnd(2) with charno = charno + opnd(3) */ 10 132 setbitno_fun initial("010111011"b), /* setcharno for bitsno */ 10 133 addbitno_fun initial("010111100"b), /* addcharno for bitno */ 10 134 10 135 min_fun initial("011000000"b), /* opnd(1) <- min(opnd(1),opnd(2),...) */ 10 136 max_fun initial("011000001"b), /* opnd(1) <- max(opnd(1),opnd(2),...) */ 10 137 10 138 stack_ptr initial("011010001"b), /* opnd(1) <- stack frame ptr */ 10 139 empty_area initial("011010010"b), /* empty opnd(1), length in words is opnd(2) */ 10 140 enable_on initial("011010100"b), /* opnd(1) is the cond name 10 141* opnd(2) is the file name 10 142* opnd(3) is the block */ 10 143 revert_on initial("011010101"b), /* opnd(1) is the cond name, 10 144* opnd(2) is the file name */ 10 145 signal_on initial("011010110"b), /* opnd(1) is the cond name 10 146* opnd(2) is the file name */ 10 147 10 148 lock_fun initial("011010111"b), /* opnd(1) <- stac(opnd(2),opnd(3)) */ 10 149 stacq_fun initial("011011000"b), /* opnd(1) is result, opnd(2) is ptr to lock word, 10 150* opnd(3) is old value, (4) is new value. */ 10 151 clock_fun initial("011011001"b), /* opnd(1) is the clock time */ 10 152 vclock_fun initial("011011010"b), /* opnd(1) is the virtual clock time */ 10 153 10 154 bound_ck initial("011100000"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 10 155 range_ck initial("011100001"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 10 156 loop initial("011100010"b), /* do opnd(1) for opnd(2) from opnd(3) to opnd(4) by 1, 10 157* opnd(5) is the list */ 10 158 join initial("011100011"b), /* do opnd(1), opnd(2) ... opnd(n) */ 10 159 allot_based initial("011100100"b), /* allocate opnd(2) words in opnd(3), set opnd(1) */ 10 160 free_based initial("011100101"b), /* free opnd(1) in opnd(3), length is opnd(2) words */ 10 161 10 162 r_parn initial("011110001"b), /* format op code */ 10 163 l_parn initial("011110010"b), 10 164 r_format initial("011110011"b), 10 165 c_format initial("011110100"b), 10 166 f_format initial("011110101"b), 10 167 e_format initial("011110110"b), 10 168 b_format initial("011110111"b), 10 169 a_format initial("011111000"b), 10 170 x_format initial("011111001"b), 10 171 skip_format initial("011111010"b), 10 172 column_format initial("011111011"b), 10 173 page_format initial("011111100"b), 10 174 line_format initial("011111101"b), 10 175 picture_format initial("011111110"b), 10 176 bn_format initial("011111111"b), /* bit format, length(opnd(2)), radix factor(opnd(3)) */ 10 177 10 178 get_list_trans initial("100000000"b), /* getlist(opnd(2) with desc(opnd(1))) */ 10 179 get_edit_trans initial("100000001"b), /* getedit(opnd(2) with desc(opnd(1))) */ 10 180 get_data_trans initial("100000010"b), /* getdata(opnd(1) to opnd(n)) */ 10 181 put_list_trans initial("100000011"b), /* putlist(opnd(2) with desc(opnd(1))) */ 10 182 put_edit_trans initial("100000100"b), /* putedit(opnd(2) with desc(opnd(1))) */ 10 183 put_data_trans initial("100000101"b), /* putdata(opnd(2)) with subscript-list opnd(1) */ 10 184 terminate_trans initial("100000110"b), /* terminate stream transmission */ 10 185 stream_prep initial("100000111"b), /* initiate stream transmission */ 10 186 record_io initial("100001000"b), /* perform record io operation */ 10 187 fortran_read initial("100001001"b), /* A complete read statement */ 10 188 fortran_write initial("100001010"b), /* A complete write statement */ 10 189 ftn_file_manip initial("100001011"b), /* endfile,backspace,rewind,etc. */ 10 190 ftn_trans_loop initial("100001100"b), /* An implied do in i/o list */ 10 191 put_control initial("100001101"b), /* put control opnd(1) opnd(2) times */ 10 192 put_field initial("100001110"b), /* putlist(opnd(2)) of length(opnd(1)) */ 10 193 put_field_chk initial("100001111"b), /* putlist(op(2)) of len(op(1)) check char index(op(3)) */ 10 194 10 195 /* These operators are produced by the parse but are not used as input to the code generator. */ 10 196 /* They are processed by the semantic translator. */ 10 197 10 198 return_value initial("100010010"b), /* return(opnd(1)) */ 10 199 allot_var initial("100010011"b), /* allot opnd(1) in opnd(2) */ 10 200 free_var initial("100010100"b), /* free opnd(1) out of opnd(2) */ 10 201 get_file initial("100010101"b), /* opnd(1) is filename,opnd(2) is copy */ 10 202 /* opnd(3) is skip, opnd(4) is list */ 10 203 get_string initial("100010110"b), /* opnd(1) is string,opnd(2) is list */ 10 204 put_file initial("100010111"b), /* opnd(1) is filename,opnd(2) is page */ 10 205 /* opnd(3) is skip,opnd(4) is line */ 10 206 put_string initial("100011000"b), /* opnd(1) is string,opnd(2) is list */ 10 207 open_file initial("100011001"b), 10 208 close_file initial("100011010"b), 10 209 read_file initial("100011011"b), 10 210 write_file initial("100011100"b), 10 211 locate_file initial("100011101"b), 10 212 do_fun initial("100011110"b), /* opnd(1) is join of a list */ 10 213 /* opnd(2) is control variable ref */ 10 214 /* opnd(3) is specification operator */ 10 215 do_spec initial("100011111"b), /* opnd(1) to opnd(2) by opnd(3) */ 10 216 /* repeat opnd(4) while opnd(5) */ 10 217 /* opnd(6) is next specification */ 10 218 10 219 rewrite_file initial("100100000"b), 10 220 delete_file initial("100100001"b), 10 221 unlock_file initial("100100010"b), 10 222 lock_file initial("100100011"b), 10 223 refer initial("100100101"b), /* opnd(1) refer(opnd(2)) */ 10 224 prefix_plus initial("100100110"b), /* opnd(1) <- +opnd(2) */ 10 225 nop initial("100100111"b), /* no-op */ 10 226 assign_by_name initial("100101000"b), /* opnd(1) <- opnd(2),by name */ 10 227 10 228 /* These operators are produced by the semantic translator in processing the math 10 229* builtin functions and are used as input to the code generator */ 10 230 10 231 sqrt_fun initial("100110000"b), /* opnd(1) <- sqrt(opnd(2)) */ 10 232 sin_fun initial("100110001"b), /* opnd(1) <- sin(opnd(2)) */ 10 233 sind_fun initial("100110010"b), /* opnd(1) <- sind(opnd(2)) */ 10 234 cos_fun initial("100110011"b), /* opnd(1) <- cos(opnd(2)) */ 10 235 cosd_fun initial("100110100"b), /* opnd(1) <- cosd(opnd(2)) */ 10 236 tan_fun initial("100110101"b), /* opnd(1) <- tan(opnd(2)) */ 10 237 tand_fun initial("100110110"b), /* opnd(1) <- tand(opnd(2)) */ 10 238 asin_fun initial("100110111"b), /* opnd(1) <- asin(opnd(2)) */ 10 239 asind_fun initial("100111000"b), /* opnd(1) <- asind(opnd(2)) */ 10 240 acos_fun initial("100111001"b), /* opnd(1) <- acos(opnd(2)) */ 10 241 acosd_fun initial("100111010"b), /* opnd(1) <- acosd(opnd(2)) */ 10 242 atan_fun initial("100111011"b), /* opnd(1) <- atan(opnd(2)[,opnd(3)]) */ 10 243 atand_fun initial("100111100"b), /* opnd(1) <- atand(opnd(2)[,opnd(3)]) */ 10 244 log2_fun initial("100111101"b), /* opnd(1) <- log2(opnd(2)) */ 10 245 log_fun initial("100111110"b), /* opnd(1) <- log(opnd(2)) */ 10 246 log10_fun initial("100111111"b), /* opnd(1) <- log10(opnd(2)) */ 10 247 10 248 exp_fun initial("101000000"b)) /* opnd(1) <- exp(opnd(2)) */ 10 249 10 250 bit(9) aligned internal static options(constant); 10 251 10 252 /* END INCLUDE FILE ... op_codes.incl.pl1 */ 147 11 1 dcl ( real_fix_bin_1 init(1), 11 2 real_fix_bin_2 init(2), 11 3 real_flt_bin_1 init(3), 11 4 real_flt_bin_2 init(4), 11 5 complex_fix_bin_1 init(5), 11 6 complex_fix_bin_2 init(6), 11 7 complex_flt_bin_1 init(7), 11 8 complex_flt_bin_2 init(8), 11 9 real_fix_dec init(9), 11 10 real_flt_dec init(10), 11 11 complex_fix_dec init(11), 11 12 complex_flt_dec init(12), 11 13 char_string init(13), 11 14 bit_string init(14), 11 15 label_constant init(15), 11 16 local_label_variable init(16), 11 17 label_variable init(17), 11 18 entry_variable init(18), 11 19 ext_entry_in init(19), 11 20 ext_entry_out init(20), 11 21 int_entry init(21), 11 22 int_entry_other init(22), 11 23 unpacked_ptr init(23), 11 24 packed_ptr init(24)) fixed bin(15) int static options(constant); 148 12 1 /* BEGIN INCLUDE FILE ... boundary.incl.pl1 */ 12 2 12 3 /* Modified: 26 Apr 1979 by PCK to implement 4-bit decimal */ 12 4 12 5 dcl ( bit_ init(1), 12 6 digit_ init(2), 12 7 character_ init(3), 12 8 half_ init(4), 12 9 word_ init(5), 12 10 mod2_ init(6), 12 11 mod4_ init(7)) fixed bin(3) int static options(constant); 12 12 12 13 /* END INCLUDE FILE ... boundary.incl.pl1 */ 149 13 1 /* BEGIN INCLUDE FILE ... list.incl.pl1 */ 13 2 13 3 /* Modified 26 June 81 by EBush to add max_list_elements */ 13 4 13 5 13 6 dcl 1 list based aligned, 13 7 2 node_type bit(9) unaligned, 13 8 2 reserved bit(12) unaligned, 13 9 2 number fixed(14) unaligned, 13 10 2 element dimension(n refer(list.number)) ptr unaligned; 13 11 13 12 dcl max_list_elements fixed bin(17) internal static options (constant) 13 13 init(16383); 13 14 13 15 /* END INCLUDE FILE ... list.incl.pl1 */ 150 151 152 /* program */ 153 154 p, cg_stat$cur_tree = pt; 155 op_code = p -> operator.op_code; 156 157 if op_code = join 158 then do; 159 160 do i = 1 to p -> operator.number; 161 call compile_tree((p -> operand(i))); 162 end; 163 164 return; 165 end; 166 167 if op_class = jump_class 168 then do; 169 call jump_op(pt); 170 return; 171 end; 172 173 do i = 1 to p -> operator.number; 174 rand(i) = p -> operand(i); 175 end; 176 177 if p -> operator.number > 1 178 then if rand(1) ^= null 179 then if rand(1) -> node.type = reference_node 180 then if rand(1) -> reference.evaluated 181 then if ^ rand(1) -> reference.shared 182 then do; 183 call adjust_ref_count(rand(1),-1); 184 return; 185 end; 186 187 if op_code = std_call 188 then do; 189 p = call_op(p); 190 return; 191 end; 192 193 if op_code = assign_zero 194 then do; 195 p = prepare_operand(rand(1),1,atomic); 196 call state_man$flush_ref(p); 197 call expmac((zero_mac),p); 198 if p -> reference.aliasable 199 then call state_man$set_aliasables(p); 200 return; 201 end; 202 203 if op_code = ex_prologue 204 then do; 205 206 p = cg_stat$cur_block; 207 if p -> block.number_of_entries = 1 208 then do; 209 210 /* instead of compiling the prologue as a subroutine, we'll 211* hook all of the prologue statements into the main list 212* after the current statement */ 213 214 if p -> block.plio_ps ^= null then call io_op$init_ps; 215 216 arg(1) = cg_stat$cur_statement; 217 arg(2) = p -> block.end_prologue; 218 if arg(2) = null then return; 219 arg(2) -> statement.next = arg(1) -> statement.next; 220 arg(2) -> statement.next -> statement.back = arg(2); 221 arg(2) = p -> block.prologue; 222 arg(1) -> statement.next = arg(2); 223 arg(2) -> statement.back = arg(1); 224 p -> block.prologue, p -> block.end_prologue = null; 225 end; 226 227 else if cg_stat$prol_ent ^= null 228 then do; 229 call state_man$erase_reg((odd_bases)); 230 call expmac((call_prologue),prepare_operand(cg_stat$prol_ent,1,atomic)); 231 end; 232 233 return; 234 end; 235 236 if op_code = loop 237 then do; 238 239 call check_aggregate(rand(1)); 240 241 arg(2) = prepare_operand(rand(2),1,atomic); 242 243 ulp = prepare_operand(rand(4),1,atomic); 244 if ^ atomic then ulp = compile_exp$save(rand(4)); 245 246 if ulp -> reference.data_type = real_fix_bin_2 then ulp -> reference.c_offset = ulp -> reference.c_offset + 1; 247 248 llp = prepare_operand(rand(3),1,atomic); 249 if atomic then call load(llp,0); else call compile_exp(rand(3)); 250 251 call store$force(arg(2)); 252 253 call state_man$flush; 254 255 if mod (cg_stat$text_pos, 2) ^= 0 256 then call expmac$zero (nop_mac); 257 arg(1) = create_label(cg_stat$cur_block,null,(by_compiler)); 258 arg(1) -> label.location = cg_stat$text_pos; 259 arg(1) -> label.allocated = "1"b; 260 arg(1) = prepare_operand(arg(1),1,atomic); 261 262 call compile_tree(rand(1)); 263 264 arg(3) = ulp; 265 call expmac$many((loop_end),addr(arg),3); 266 267 if ulp -> reference.data_type = real_fix_bin_2 then ulp -> reference.c_offset = ulp -> reference.c_offset - 1; 268 269 /* release scalar expressions pulled outside of loop as optimization */ 270 271 do p1 = rand(5) repeat p1 -> element(1) while(p1 ^= null); 272 call adjust_ref_count((p1 -> element(2)),-1); 273 end; 274 275 return; 276 end; 277 278 if op_code = allot_auto 279 then do; 280 q2 = prepare_operand(rand(2),1,atomic); 281 if atomic then call load(q2,0); else call compile_exp(rand(2)); 282 call expmac((allot_auto_mac),rand(1)); 283 call base_man$update_base(1,rand(1),1); 284 return; 285 end; 286 287 if op_code = make_desc 288 then do; 289 290 do i = 1 to 3; 291 arg(i) = prepare_operand(rand(i),1,atomic); 292 end; 293 294 if atomic then call load(arg(3),0); else call compile_exp(rand(3)); 295 296 if arg(1) ^= arg(2) then call expmac$many((make_desc_mac),addr(arg),2); 297 else do; 298 call m_a(arg(1),"0"b); 299 arg(1) -> reference.perm_address = "1"b; 300 301 if arg(1) -> address.tag 302 then do; 303 call base_man$load_var(2,arg(1),1); 304 arg(1) -> reference.perm_address = "1"b; 305 end; 306 307 arg(1) -> address.tag = "001111"b; 308 call expmac((set_desc_size),arg(1)); 309 end; 310 311 return; 312 end; 313 314 if op_code = copy_words 315 then do; 316 l4: call move_data(p); 317 abset = "0"b; 318 call set_structure(rand(1)); 319 return; 320 end; 321 322 if op_code = copy_string then goto l4; 323 324 if op_class = io_class 325 then do; 326 save_cur_node = cg_stat$cur_node; 327 cg_stat$cur_node = pt; 328 call io_op(pt); 329 cg_stat$cur_node = save_cur_node; 330 call state_man$set_aliasables(null); 331 return; 332 end; 333 334 if op_code = open_file 335 then do; 336 macro = open_mac; 337 goto l6; 338 end; 339 340 if op_code = close_file 341 then do; 342 macro = close_mac; 343 344 l6: call state_man$erase_reg((odd_bases)); 345 call expmac$zero(macro); 346 call state_man$set_aliasables(null); 347 return; 348 end; 349 350 if op_code = signal_on 351 then do; 352 353 if rand(2) = null then macro = signal_mac; 354 else do; 355 p2 = prepare_operand(rand(2),1,atomic); 356 call base_man$store_ptr_to(p2,c_a(40,4)); 357 macro = io_signal_mac; 358 end; 359 360 p1 = prepare_operand((rand(1) -> reference.symbol -> symbol.general),1,atomic); 361 call xr_man$load_const((p1 -> reference.c_length),6); 362 call expmac(macro,p1); 363 call state_man$flush; 364 return; 365 end; 366 367 if op_code = revert_on 368 then do; 369 if rand(2) = null 370 then call expmac((revert_mac),c_a((rand(1) -> reference.symbol -> symbol.location),4)); 371 else do; 372 arg(1) = prepare_operand((rand(1) -> reference.symbol -> symbol.general),1,atomic); 373 arg(2) = prepare_operand(rand(2),1,atomic); 374 call expmac$many((revert_file),addr(arg),2); 375 end; 376 377 return; 378 end; 379 380 if op_code = nop 381 then do; 382 call expmac$zero((nop_mac)); 383 return; 384 end; 385 386 s1 = rand(1) -> reference.symbol; 387 388 if op_code = allot_ctl 389 then do; 390 q2 = prepare_operand(rand(2),1,atomic); 391 if atomic 392 then call load(q2,0); 393 else call compile_exp(rand(2)); 394 if s1->symbol.arg_descriptor 395 then macro = push_ctl_desc; 396 else if s1->symbol.exp_extents 397 then macro = alloc_block; 398 else macro = push_ctl_data; 399 go to ca; 400 end; 401 402 if op_code = free_ctl 403 then do; 404 if s1->symbol.arg_descriptor 405 then macro = pop_ctl_desc; 406 else if s1->symbol.exp_extents 407 then macro = free_block; 408 else macro = pop_ctl_data; 409 ca: loc = s1->symbol.location; 410 if s1->symbol.internal 411 then do; 412 n = 13; 413 if s1->symbol.arg_descriptor 414 then loc = loc - 2; 415 end; 416 else n = 9; 417 q1 = c_a(loc,n); 418 call state_man$erase_reg((odd_bases)); 419 call expmac(macro,q1); 420 if ^ rand(1) -> reference.shared 421 then call adjust_ref_count(rand(1),-1); 422 call state_man$set_aliasables(null); 423 abset = "1"b; 424 call set_structure(rand(1)); 425 return; 426 end; 427 428 /* The schematic code sequence for allot_based */ 429 /* is as follows: */ 430 /* */ 431 /* */ 432 /*RE-TRY: */ 433 /* (if it exists) */ 434 /* */ 435 /* epp2 area (if it exists) */ 436 /* */ 437 /* tsx0 pr0|alloc_based if area given, */ 438 /* or tsx0 pr0|alloc_based_storage if area not given */ 439 /* tra RE-TRY */ 440 /* spri2 _p_t_r (to area) */ 441 442 if op_code = allot_based 443 then do; 444 q1 = prepare_operand(rand(1),1,atomic); 445 446 call state_man$flush; 447 loc = cg_stat$text_pos; 448 449 if rand(3)^= null 450 then q3 = prepare_operand(rand(3),1,atomic); 451 452 q2 = prepare_operand(rand(2),1,atomic); 453 if atomic 454 then call load(q2,0); 455 else call compile_exp(rand(2)); 456 457 p1 = c_a(loc,10); 458 if rand(3) ^= null 459 then do; 460 call base_man$load_var(2,q3,1); 461 macro = alloc_based_area; 462 end; 463 else macro = alloc_based_mac; 464 465 call state_man$flush; 466 467 call expmac(macro,p1); 468 call base_to_core(1,q1); 469 470 return; 471 end; 472 473 /* The schematic code sequence for free_based is: */ 474 /* */ 475 /* */ 476 /* epp5 qualifier_of_based_var */ 477 /* */ 478 /* tsx0 pr0|free_based */ 479 480 if op_code = free_based 481 then do; 482 q2 = prepare_operand(rand(2),1,atomic); 483 if ^atomic 484 then call compile_exp(rand(2)); 485 else call adjust_ref_count(q2,-1); 486 487 if rand(3) ^= null 488 then do; 489 q3 = prepare_operand(rand(3),1,atomic); 490 if ^atomic 491 then call compile_exp(rand(3)); 492 else call adjust_ref_count(q3,-1); 493 494 end; 495 496 q1 = prepare_operand(rand(1),-1,atomic); 497 498 p2 = q1->reference.qualifier; 499 500 if p2->node.type = operator_node 501 then do; 502 503 /* check for evaluated because addr_fun handled specially */ 504 505 if ^ p2 -> operand(1) -> reference.evaluated 506 then p2 = compile_exp$save(p2); 507 else p2 = p2 -> operand(1); 508 end; 509 510 if ^ p2 -> reference.shared 511 then p2->reference.ref_count = p2->reference.ref_count + 1; 512 call base_man$load_var(2,p2,5); 513 514 call state_man$flush; 515 516 call expmac$zero((free_based_mac)); 517 518 call adjust_ref_count(q1,-1); 519 520 return; 521 522 end; 523 524 /* The schematic code sequence for free_based is : */ 525 /* */ 526 /* epp2 area */ 527 /* */ 528 /* tsx0 pr0|empty */ 529 530 if op_code = empty_area 531 then do; 532 q1 = prepare_operand(rand(1),1,atomic); 533 534 q2 = prepare_operand(rand(2),1,atomic); 535 if ^atomic 536 then call compile_exp(rand(2)); 537 else call load(q2,0); 538 539 call base_man$load_var(2,q1,1); 540 541 call state_man$flush; 542 543 call expmac$zero((empty_area_mac)); 544 545 return; 546 547 end; 548 549 if op_class = ptr_class then goto ce; 550 551 /* All of the code from here to the call to compile_exp is here to handle 552* the special-cases that arise from operator_semantics eliminating assign 553* operators at the top of the tree. However, the following code is general 554* in that is it safe to perform these optimizations no matter what the 555* origin of the tree. */ 556 557 /* The following code adjusts the reference count on T in the case 558* T = right_hand_side 559* a = T 560* b = T 561* which arises from the multiple assignment 562* a,b = right_hand_side 563* or from the assignment 564* bit_string = unspec(right_hand_side) */ 565 566 if s1 -> symbol.temporary & ^rand(1) -> reference.shared 567 then if rand (1) -> reference.ref_count > 1 568 then rand (1) -> reference.ref_count = rand (1) -> reference.ref_count - 1; 569 570 if (op_code = assign) | (op_code = assign_size_ck) 571 then do; 572 if op_code = assign_size_ck 573 then go to l0; 574 575 /* The following uses the fact the all decimal operations are done by special hardware and 576* most complex binary operations are done via calls to procedures both of which are 577* able to accept an output operand whose attributes are different than 578* those required by the PL/I precision rules. The fact that the 579* semantic translator generated an assigment operator means that 580* the attributes of the LHS do not match those of the RHS. If RHS 581* is an expression which has not been optimized or previously 582* evaluated, we will attempt to eliminate the assign operator ourselves 583* if the runtime routines can handle the attribute mismatch that will 584* result. This eliminates the need for an extra procedure call at 585* runtime to move the result of the computation into LHS */ 586 587 if rand(2) -> node.type ^= operator_node then goto l0; 588 589 p1 = rand(2) -> operand(1); 590 if p1 -> reference.evaluated then goto l0; 591 if p1 -> reference.ref_count > 0 then goto l0; 592 593 s2 = p1 -> reference.symbol; 594 595 /* Both sides have to have same value for complex and decimal attributes */ 596 597 if s1 -> symbol.complex ^= s2 -> symbol.complex then goto l0; 598 if s2 -> symbol.decimal ^= s1 -> symbol.decimal then goto l0; 599 600 if s1 -> symbol.decimal 601 then do; 602 603 /* Make sure scales are within hardware limits */ 604 605 if s1 -> symbol.scale > max_dec_scale then go to l0; 606 if s1 -> symbol.scale < min_dec_scale then go to l0; 607 if s2 -> symbol.scale > max_dec_scale then go to l0; 608 if s2 -> symbol.scale < min_dec_scale then go to l0; 609 610 /* some operators require results with special characteristics */ 611 612 if rand(2) -> operator.op_code = trunc_fun 613 then if s1 -> symbol.scale ^= 0 | (s1 -> symbol.float & s2 -> symbol.fixed) 614 then go to l0; 615 if rand(2) -> operator.op_code = assign 616 then do; 617 if s1 -> symbol.float & s2 -> symbol.fixed 618 then go to l0; 619 if s1 -> symbol.fixed & s2 -> symbol.fixed 620 then if s1 -> symbol.scale ^= s2 -> symbol.scale 621 then go to l0; 622 if s1 -> symbol.c_dcl_size > s2 -> symbol.c_dcl_size 623 then go to l0; 624 end; 625 if rand(2) -> operator.op_code = round_fun then go to l0; 626 if rand(2) -> operator.op_code = min_fun then go to l0; 627 if rand(2) -> operator.op_code = max_fun then go to l0; 628 if rand(2) -> operator.op_code = unpack then go to l0; 629 630 /* any real decimal can be replaced by any other real decimal 631* and similarly for complex decimals */ 632 633 switch: rand(2) -> operand(1) = rand(1); 634 p = rand(2); 635 goto ce; 636 end; 637 638 if ^ s1 -> symbol.complex then goto l0; 639 640 /* If output of RHS is float binary single, we only want to 641* replace it if LHS is float binary single aligned. Otherwise, 642* we can replace a complex float binary with any other 643* complex float binary and similarly for complex fixed binary */ 644 645 if s2 -> symbol.float 646 then if s2 -> symbol.c_word_size = 1 647 then do; 648 if ^ s1 -> symbol.float then goto l0; 649 if s1 -> symbol.c_word_size ^= 1 then goto l0; 650 if s1 -> symbol.packed then goto l0; 651 652 if rand(1) -> reference.units ^= 0 653 then if rand(1) -> reference.units ^= word_ 654 then goto l0; 655 656 goto switch; 657 end; 658 659 if s2 -> symbol.float = s1 -> symbol.float then goto switch; 660 661 /* could not eliminate the assignment */ 662 663 l0: call assign_op(p); 664 go to set; 665 end; 666 667 /* the following code checks for decimal expressions whose scale 668* is outside of machine limits */ 669 670 if s1 -> symbol.decimal 671 then if s1 -> symbol.fixed 672 then if p -> operator.number >= 3 673 then if op_code ^= round_fun 674 then if op_code ^= complex_fun 675 then do; 676 if s1 -> symbol.scale < min_dec_scale | s1 -> symbol.scale > max_dec_scale 677 then do; 678 if decimal_op$change_target(p) 679 then do; 680 p -> operand(1) = decimal_op$get_float_temp(s1 -> symbol.c_dcl_size,(s1 -> symbol.complex)); 681 p1 = compile_exp$save(p); 682 rand(1) = prepare_operand(rand(1),1,atomic); 683 call assign_op$to_dec_scaled(rand(1),p1); 684 p -> operand(1) = rand(1); 685 go to set; 686 end; 687 end; 688 go to ce; 689 end; 690 691 /* machine-dependent optimizations follow */ 692 693 if op_code = add | op_code = sub 694 then do; 695 696 /* if operand(1) is single fixed binary, we may be able to generate 697* a shorter code sequence if two of the operands are the same */ 698 699 700 if s1 -> symbol.complex then goto ce; 701 if s1 -> symbol.float then goto ce; 702 if s1 -> symbol.unaligned then goto ce; 703 704 if s1 -> symbol.c_dcl_size > max_p_fix_bin_1 then goto ce; 705 706 if ^ search_arithmetic() then go to ce; 707 708 q1 = prepare_operand(rand(1),1,atomic); 709 710 call drop_count; 711 712 if i = 2 then j = 3; else j = 2; 713 714 p2 = p -> operand(j); 715 q2 = prepare_operand(p2,1,atomic); 716 717 if op_code = sub then goto l2; 718 719 if atomic 720 then do; 721 s2 = q2 -> reference.symbol; 722 if s2 -> symbol.constant 723 then if q2 -> reference.offset = null 724 then if q2 -> reference.c_offset = 0 725 then if s2 -> symbol.initial -> fix_bin = 1 726 then do; 727 macro = aos_mac; 728 goto l3; 729 end; 730 731 call load(q2,0); 732 end; 733 else call compile_exp(p2); 734 735 l1a: macro = incr_mac; 736 goto l3; 737 738 l2: if i = 2 739 then do; 740 if ^ atomic then q2 = compile_exp$save(p2); 741 call load(q2,1); 742 goto l1a; 743 end; 744 745 if atomic then call load(q2,0); else call compile_exp(p2); 746 747 macro = diff_mac; 748 749 l3: call state_man$flush_ref(q1); 750 call expmac(macro,q1); 751 go to set; 752 end; 753 754 if op_class = "00010"b /* and, or, not, etc */ 755 then do; 756 if op_code > xor_bits then goto ce; 757 758 /* have &, |, or xor operator */ 759 760 if rand(1) -> reference.length ^= null | rand(1) -> reference.c_length > bits_per_two_words 761 then do; 762 if ^ search() then go to ce; 763 764 macro = long_mac(fixed(op_code,9)); 765 766 if i = 2 then j = 3; else j = 2; 767 768 q1 = prepare_operand(rand(1),1,atomic); 769 p2 = prepare_operand(rand(j),1,atomic); 770 771 if rand(j) -> node.type = reference_node 772 then if overlaps(q1,p2) 773 then go to ce; 774 else; 775 776 else if can_do_andnot(rand(j)) 777 then do; 778 779 /* op_code is and_bits, rand(j) is not_bits */ 780 781 p2 = prepare_operand((rand(j) -> operand(2)),1,atomic); 782 783 if ^ atomic 784 then p2 = compile_exp$save_exp((rand(j) -> operand(2))); 785 786 call adjust_ref_count((rand(j) -> operand(1)), -1); 787 788 macro = move_andnot_1; 789 end; 790 791 else p2 = compile_exp$save(rand(j)); 792 793 call drop_count; 794 795 call expmac$two_eis(macro,q1,p2); 796 go to set; 797 end; 798 799 if rand(1) -> reference.offset ^= null then goto ce; 800 if rand(1) -> reference.fo_in_qual then goto ce; 801 802 cfo = mod(rand(1) -> reference.c_offset * convert_offset(rand(1) -> reference.units),bits_per_word); 803 k = cfo + rand(1) -> reference.c_length; 804 if k > bits_per_two_words then goto ce; 805 806 if ^ search() then go to ce; 807 808 q1 = prepare_operand(rand(1),1,atomic); 809 810 if ^ (q1 -> reference.aligned_ref | op_code = or_bits) then goto ce; 811 812 call drop_count; 813 814 if i = 2 then j = 3; else j = 2; 815 p2 = rand(j); 816 q2 = prepare_operand(p2,1,atomic); 817 818 d = fixed(k > bits_per_word,1); 819 820 if atomic then call load(q2,d); else call compile_exp(p2); 821 822 i = q2 -> reference.c_length; 823 if op_code = and_bits 824 then if fixed(i > bits_per_word,1) < d 825 then do; 826 call aq_man$clear_q; 827 i = bits_per_two_words; 828 end; 829 830 i = cfo + i; 831 d = fixed(i > bits_per_word,1); 832 833 if cfo ^= 0 834 then do; 835 if d = 0 then macro = arl; else macro = lrl; 836 call expmac(macro,c_a(cfo,1)); 837 end; 838 839 call state_man$flush_ref(q1); 840 call expmac$one((string_mac(fixed(op_code,9))),q1,d); 841 go to set; 842 end; 843 844 ce: call compile_exp(p); 845 846 set: if rand(1) -> reference.aliasable 847 then call state_man$set_aliasables(rand(1)); 848 else if rand(1) -> reference.defined_ref 849 then do; 850 abset = "0"b; 851 call set_structure((rand(1) -> reference.qualifier)); 852 end; 853 854 return; 855 856 search: proc returns(bit(1) aligned) irreducible; 857 858 if rand(1) -> reference.units = 0 859 then rand(1) -> reference.units = word_; 860 861 do i = 2 to 3; 862 q1 = rand(i); 863 if rand(1) = q1 then return("1"b); 864 if q1 -> node.type = reference_node 865 then do; 866 if q1 -> reference.units = 0 867 then q1 -> reference.units = word_; 868 if rand(1) -> reference.symbol = q1 -> reference.symbol 869 then if compare_expression(rand(1),q1) 870 then return("1"b); 871 end; 872 end; 873 874 return("0"b); 875 876 end; 877 878 search_arithmetic: proc returns(bit(1) aligned) irreducible; 879 880 /* we cannot use compare_expression directly because some operands 881* may be prepared while others may not, thus c_length may be invalid. 882* compare_expression is used at all because if one operand is a call, 883* the optimizer might be prevented from commoning the offsets and 884* qualifiers of the other operands. */ 885 886 do i = 2 to 3; 887 q1 = rand(i); 888 if rand(1) = q1 then return("1"b); 889 if q1 -> node.type = reference_node 890 then if rand(1) -> reference.symbol = q1 -> reference.symbol 891 then if rand(1) -> reference.c_offset = q1 -> reference.c_offset 892 then do; 893 if rand(1) -> reference.qualifier ^= q1 -> reference.qualifier 894 then if ^ compare_expression((rand(1) -> reference.qualifier),(q1 -> reference.qualifier)) 895 then go to step; 896 if rand(1) -> reference.offset ^= q1 -> reference.offset 897 then if ^ compare_expression((rand(1) -> reference.offset),(q1 -> reference.offset)) 898 then go to step; 899 return("1"b); 900 end; 901 step: 902 end; 903 904 return("0"b); 905 906 end; 907 908 drop_count: proc; 909 910 if ^ rand(i) -> reference.shared 911 then call adjust_ref_count(rand(i),-1); 912 913 end; 914 915 overlaps: proc(q1,p2) returns(bit(1) aligned); 916 917 /* checks to see if two reference nodes reference overlapping but not matching storage. 918* At least one of the reference nodes MUST be a non-temporary. */ 919 920 dcl (q1,p2) ptr; 921 922 if q1 -> reference.symbol = p2 -> reference.symbol 923 | (q1 -> reference.aliasable & p2 -> reference.aliasable) 924 & q1 -> reference.symbol -> symbol.aligned = p2 -> reference.symbol -> symbol.aligned 925 & q1 -> reference.symbol -> symbol.varying = p2 -> reference.symbol -> symbol.varying 926 then if q1 -> reference.substr 927 | p2 -> reference.substr 928 | ^ (q1 -> reference.symbol -> symbol.aligned | q1 -> reference.symbol -> symbol.varying) 929 then return("1"b); 930 931 return("0"b); 932 933 end /* overlaps */; 934 935 set_structure: proc(pt); 936 937 /* We must flush the non-aggregate shared members of the structure from the machine state */ 938 939 dcl (adam,pt,r,s) ptr; 940 941 adam = pt -> reference.symbol; 942 943 s = adam; 944 945 loop: do while(s -> symbol.structure); 946 s = s -> symbol.son; 947 end; 948 949 r = s -> symbol.reference; 950 if ^ r -> reference.array_ref 951 then do; 952 if r -> reference.qualifier = null 953 then if r -> reference.offset = null 954 then if r -> reference.length = null 955 then call state_man$flush_ref(r); 956 957 if ^ abset 958 then if s -> symbol.aliasable | r -> reference.aliasable 959 then call state_man$set_aliasables(r); 960 end; 961 962 if s = adam then return; 963 964 do while(s -> symbol.brother = null); 965 s = s -> symbol.father; 966 if s = adam then return; 967 end; 968 969 s = s -> symbol.brother; 970 go to loop; 971 end; 972 973 check_aggregate: proc(pt); 974 975 /* check_aggregate makes sure that aggregate temporaries get allocated 976* outside of the loop in which they might appear */ 977 978 dcl (p,pt,s) ptr; 979 dcl i fixed bin; 980 dcl op_code bit(9) aligned; 981 982 p = pt; 983 if p = null then return; 984 if p -> node.type ^= operator_node then return; 985 986 op_code = p -> operator.op_code; 987 988 if op_code = loop 989 then do; 990 call check_aggregate((p -> operand(1))); 991 return; 992 end; 993 994 if op_code = join 995 then do; 996 do i = 1 to p -> operator.number; 997 call check_aggregate((p -> operand(i))); 998 end; 999 return; 1000 end; 1001 1002 if p -> operator.number = 0 then return; 1003 if p -> operand(1) = null then return; 1004 p = p -> operand(1); 1005 if p -> node.type ^= reference_node then return; 1006 s = p -> reference.symbol; 1007 if s -> node.type ^= symbol_node then return; 1008 1009 if s -> symbol.temporary 1010 then if s -> symbol.member | s -> symbol.dimensioned | s -> symbol.structure | s -> symbol.arg_descriptor 1011 then do; 1012 do while(s -> symbol.father ^= null); 1013 s = s -> symbol.father; 1014 end; 1015 1016 if s -> symbol.initial = null 1017 then call stack_temp$assign_aggregate(s); 1018 end; 1019 1020 end /* check_aggregate */; 1021 1022 can_do_andnot: proc(p_o) returns(bit(1) aligned); 1023 1024 /* Sees whether a = a & ^ b; can be done in one instruction. */ 1025 1026 dcl (o,p_o) ptr; /* operator which might be not_bits */ 1027 1028 dcl p2 ptr; 1029 dcl useless bit(1) aligned; 1030 1031 o = p_o; 1032 1033 if op_code = and_bits 1034 & o -> operator.op_code = not_bits 1035 & o -> operand(1) -> reference.ref_count <= 1 1036 & ^ o -> operand(1) -> reference.evaluated 1037 then do; 1038 p2 = o -> operand(2); 1039 1040 if p2 -> node.type = reference_node 1041 then do; 1042 p2 = prepare_operand(p2,0,useless); /* set reference.aliasable */ 1043 p2 -> reference.data_type = 0; /* for future prepare_operand call */ 1044 1045 if overlaps(rand(1),p2) 1046 then return("0"b); 1047 end; 1048 1049 return("1"b); 1050 end; 1051 1052 return("0"b); 1053 1054 end /* can_do_andnot */; 1055 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/03/83 1008.1 compile_tree.pl1 >spec>on>pl128d>compile_tree.pl1 138 1 10/25/79 1645.8 cgsystem.incl.pl1 >ldd>include>cgsystem.incl.pl1 139 2 08/13/81 2043.5 block.incl.pl1 >ldd>include>block.incl.pl1 140 3 04/07/83 1635.0 statement.incl.pl1 >ldd>include>statement.incl.pl1 141 4 07/21/80 1546.3 operator.incl.pl1 >ldd>include>operator.incl.pl1 142 5 07/21/80 1546.3 reference.incl.pl1 >ldd>include>reference.incl.pl1 143 6 10/02/83 0828.4 symbol.incl.pl1 >spec>on>pl128d>symbol.incl.pl1 144 7 05/06/74 1742.1 label.incl.pl1 >ldd>include>label.incl.pl1 145 8 07/21/80 1546.3 nodes.incl.pl1 >ldd>include>nodes.incl.pl1 146 9 10/25/79 1645.8 declare_type.incl.pl1 >ldd>include>declare_type.incl.pl1 147 10 04/07/83 1635.0 op_codes.incl.pl1 >ldd>include>op_codes.incl.pl1 148 11 05/03/76 1320.4 data_types.incl.pl1 >ldd>include>data_types.incl.pl1 149 12 10/25/79 1645.8 boundary.incl.pl1 >ldd>include>boundary.incl.pl1 150 13 08/13/81 2211.5 list.incl.pl1 >ldd>include>list.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. abset 000163 automatic bit(1) dcl 44 set ref 317* 423* 850* 957 adam 000270 automatic pointer dcl 939 set ref 941* 943 962 966 add constant bit(9) initial dcl 10-8 ref 693 addr builtin function dcl 94 ref 265 265 296 296 374 374 address 10 based structure level 2 packed unaligned dcl 5-3 adjust_ref_count 000056 constant entry external dcl 68 ref 183 272 420 485 492 518 786 910 aliasable 12(16) based bit(1) level 3 in structure "reference" packed unaligned dcl 5-3 in procedure "compile_tree" ref 198 846 922 922 957 aliasable 32(35) based bit(1) level 4 in structure "symbol" packed unaligned dcl 6-3 in procedure "compile_tree" ref 957 aligned 31(21) based bit(1) level 4 packed unaligned dcl 6-3 ref 922 922 922 aligned_ref 12(07) based bit(1) level 3 packed unaligned dcl 5-3 ref 810 alloc_based_area constant fixed bin(15,0) initial dcl 100 ref 461 alloc_based_mac constant fixed bin(15,0) initial dcl 100 ref 463 alloc_block constant fixed bin(15,0) initial dcl 100 ref 396 allocated 1(18) based bit(1) level 2 packed unaligned dcl 7-1 set ref 259* allot_auto constant bit(9) initial dcl 10-8 ref 278 allot_auto_mac constant fixed bin(15,0) initial dcl 100 ref 282 allot_based constant bit(9) initial dcl 10-8 ref 442 allot_ctl constant bit(9) initial dcl 10-8 ref 388 and_bits constant bit(9) initial dcl 10-8 ref 823 1033 aos_mac constant fixed bin(15,0) initial dcl 100 ref 727 aq_man$clear_q 000110 constant entry external dcl 68 ref 826 arg 000102 automatic pointer array dcl 44 set ref 216* 217* 218 219 219 220 220 221* 222 222 223 223 241* 251* 257* 258 259 260* 260* 264* 265 265 291* 294* 296 296 296 296 298* 299 301 303* 304 307 308* 372* 373* 374 374 arg_descriptor 31(11) based bit(1) level 4 packed unaligned dcl 6-3 ref 394 404 413 1009 arl constant fixed bin(15,0) initial dcl 100 ref 835 array_ref 0(09) based bit(1) level 2 packed unaligned dcl 5-3 ref 950 assign constant bit(9) initial dcl 10-8 ref 570 615 assign_op 000024 constant entry external dcl 60 ref 663 assign_op$to_dec_scaled 000132 constant entry external dcl 68 ref 683 assign_size_ck constant bit(9) initial dcl 10-8 ref 570 572 assign_zero constant bit(9) initial dcl 10-8 ref 193 atomic 000162 automatic bit(1) dcl 44 set ref 195* 230* 230* 241* 243* 244 248* 249 260* 280* 281 291* 294 355* 360* 372* 373* 390* 391 444* 449* 452* 453 482* 483 489* 490 496* 532* 534* 535 682* 708* 715* 719 740 745 768* 769* 781* 783 808* 816* 820 attributes 31 based structure level 2 dcl 6-3 back 2 based pointer level 2 packed unaligned dcl 3-9 set ref 220* 223* base_man$load_var 000044 constant entry external dcl 63 ref 303 460 512 539 base_man$store_ptr_to 000050 constant entry external dcl 63 ref 356 base_man$update_base 000052 constant entry external dcl 63 ref 283 base_to_core 000046 constant entry external dcl 63 ref 468 bits 12(06) based structure level 2 packed unaligned dcl 5-3 bits_per_two_words constant fixed bin(8,0) initial dcl 1-5 ref 760 804 827 bits_per_word 005326 constant fixed bin(8,0) initial dcl 1-5 ref 802 818 823 831 block based structure level 1 dcl 2-5 brother 20 based pointer level 2 packed unaligned dcl 6-3 ref 964 969 by_compiler constant bit(3) initial dcl 9-5 ref 257 c_a 000106 constant entry external dcl 68 ref 356 356 369 369 417 457 836 836 c_dcl_size 30 based fixed bin(24,0) level 2 dcl 6-3 set ref 622 622 680* 704 c_length 2 based fixed bin(24,0) level 2 dcl 5-3 ref 361 760 803 822 c_offset 1 based fixed bin(24,0) level 2 dcl 5-3 set ref 246* 246 267* 267 722 802 889 889 c_word_size 26 based fixed bin(24,0) level 2 dcl 6-3 ref 645 649 call_op 000060 constant entry external dcl 68 ref 189 call_prologue constant fixed bin(15,0) initial dcl 100 ref 230 cfo 000171 automatic fixed bin(17,0) dcl 44 set ref 802* 803 830 833 836* 836* cg_stat$cur_block 000012 external static pointer dcl 39 set ref 206 257* cg_stat$cur_node 000016 external static pointer dcl 39 set ref 326 327* 329* cg_stat$cur_statement 000014 external static pointer dcl 39 ref 216 cg_stat$cur_tree 000020 external static pointer dcl 39 set ref 154* cg_stat$prol_ent 000010 external static pointer dcl 39 set ref 227 230* 230* cg_stat$text_pos 000022 external static fixed bin(18,0) dcl 39 ref 255 258 447 close_file constant bit(9) initial dcl 10-8 ref 340 close_mac constant fixed bin(15,0) initial dcl 100 ref 342 compare_expression 000054 constant entry external dcl 67 ref 868 893 896 compile_exp 000030 constant entry external dcl 60 ref 249 281 294 393 455 483 490 535 733 745 820 844 compile_exp$save 000062 constant entry external dcl 68 ref 244 505 681 740 791 compile_exp$save_exp 000064 constant entry external dcl 68 ref 783 compile_tree 000026 constant entry external dcl 60 ref 161 262 compiler_developed 32(35) based structure level 3 packed unaligned dcl 6-3 complex 31(31) based bit(1) level 4 packed unaligned dcl 6-3 ref 597 597 638 680 700 complex_fun constant bit(9) initial dcl 10-8 ref 670 constant 32(16) based bit(1) level 4 packed unaligned dcl 6-3 ref 722 convert_offset 000000 constant fixed bin(8,1) initial array dcl 1-35 ref 802 copy_string constant bit(9) initial dcl 10-8 ref 322 copy_words constant bit(9) initial dcl 10-8 ref 314 create_label 000070 constant entry external dcl 68 ref 257 d 000172 automatic fixed bin(17,0) dcl 44 set ref 818* 820* 823 831* 835 840* data_type 12 based fixed bin(5,0) level 2 in structure "reference" packed unaligned dcl 5-3 in procedure "compile_tree" set ref 246 267 1043* data_type 31 based structure level 3 in structure "symbol" packed unaligned dcl 6-3 in procedure "compile_tree" decimal 31(28) based bit(1) level 4 packed unaligned dcl 6-3 ref 598 598 600 670 decimal_op$change_target 000126 constant entry external dcl 68 ref 678 decimal_op$get_float_temp 000130 constant entry external dcl 68 ref 680 defined_ref 12(12) based bit(1) level 3 packed unaligned dcl 5-3 ref 848 diff_mac constant fixed bin(15,0) initial dcl 100 ref 747 dimensioned 31(19) based bit(1) level 4 packed unaligned dcl 6-3 ref 1009 element 1 based pointer array level 2 packed unaligned dcl 13-6 ref 272 273 empty_area constant bit(9) initial dcl 10-8 ref 530 empty_area_mac constant fixed bin(15,0) initial dcl 100 ref 543 end_prologue 12 based pointer level 2 packed unaligned dcl 2-5 set ref 217 224* evaluated 12(13) based bit(1) level 3 packed unaligned dcl 5-3 ref 177 505 590 1033 ex_prologue constant bit(9) initial dcl 10-8 ref 203 exp_extents 33(04) based bit(1) level 4 packed unaligned dcl 6-3 ref 396 406 expmac 000124 constant entry external dcl 68 ref 197 230 282 308 362 369 419 467 750 836 expmac$many 000116 constant entry external dcl 68 ref 265 296 374 expmac$one 000112 constant entry external dcl 68 ref 840 expmac$two_eis 000120 constant entry external dcl 68 ref 795 expmac$zero 000114 constant entry external dcl 68 ref 255 345 382 516 543 father 17 based pointer level 2 packed unaligned dcl 6-3 ref 965 1012 1013 fix_bin based fixed bin(17,0) dcl 52 ref 722 fixed builtin function dcl 94 in procedure "compile_tree" ref 764 818 823 831 840 fixed 31(01) based bit(1) level 4 in structure "symbol" packed unaligned dcl 6-3 in procedure "compile_tree" ref 612 617 619 619 670 float 31(02) based bit(1) level 4 packed unaligned dcl 6-3 ref 612 617 645 648 659 659 701 fo_in_qual 12(22) based bit(1) level 3 packed unaligned dcl 5-3 ref 800 free_based constant bit(9) initial dcl 10-8 ref 480 free_based_mac constant fixed bin(15,0) initial dcl 100 ref 516 free_block constant fixed bin(15,0) initial dcl 100 ref 406 free_ctl constant bit(9) initial dcl 10-8 ref 402 general 16 based pointer level 2 packed unaligned dcl 6-3 ref 360 372 i 000104 automatic fixed bin(17,0) dcl 979 in procedure "check_aggregate" set ref 996* 997* i 000164 automatic fixed bin(17,0) dcl 44 in procedure "compile_tree" set ref 160* 161* 173* 174 174* 290* 291 291* 712 738 766 814 822* 823 827* 830* 830 831 861* 862* 886* 887* 910 910 incr_mac constant fixed bin(15,0) initial dcl 100 ref 735 initial 11 based pointer level 2 packed unaligned dcl 6-3 ref 722 1016 internal 32(01) based bit(1) level 4 packed unaligned dcl 6-3 ref 410 io_class constant bit(5) initial unaligned dcl 132 ref 324 io_op 000040 constant entry external dcl 60 ref 328 io_op$init_ps 000100 constant entry external dcl 68 ref 214 io_signal_mac constant fixed bin(15,0) initial dcl 100 ref 357 j 000165 automatic fixed bin(17,0) dcl 44 set ref 712* 712* 714 766* 766* 769 771 776 781 783 786 791 814* 814* 815 join constant bit(9) initial dcl 10-8 ref 157 994 jump_class constant bit(5) initial unaligned dcl 132 ref 167 jump_op 000036 constant entry external dcl 60 ref 169 k 000166 automatic fixed bin(17,0) dcl 44 set ref 803* 804 818 label based structure level 1 dcl 7-1 length 6 based pointer level 2 packed unaligned dcl 5-3 ref 760 952 list based structure level 1 dcl 13-6 llp 000110 automatic pointer dcl 44 set ref 248* 249* load 000066 constant entry external dcl 68 ref 249 281 294 391 453 537 731 741 745 820 loc 000167 automatic fixed bin(17,0) dcl 44 set ref 409* 413* 413 417* 447* 457* location 1 based fixed bin(17,0) level 2 in structure "label" packed unaligned dcl 7-1 in procedure "compile_tree" set ref 258* location 1 based fixed bin(18,0) level 2 in structure "symbol" packed unsigned unaligned dcl 6-3 in procedure "compile_tree" ref 369 369 409 long_mac 000006 constant fixed bin(15,0) initial array dcl 100 ref 764 loop constant bit(9) initial dcl 10-8 ref 236 988 loop_end constant fixed bin(15,0) initial dcl 100 ref 265 lrl constant fixed bin(15,0) initial dcl 100 ref 835 m_a 000042 constant entry external dcl 62 ref 298 macro 000160 automatic fixed bin(15,0) dcl 44 set ref 336* 342* 345* 353* 357* 362* 394* 396* 398* 404* 406* 408* 419* 461* 463* 467* 727* 735* 747* 750* 764* 788* 795* 835* 835* 836* make_desc constant bit(9) initial dcl 10-8 ref 287 make_desc_mac constant fixed bin(15,0) initial dcl 100 ref 296 max_dec_scale constant fixed bin(8,0) initial dcl 1-5 ref 605 607 676 max_fun constant bit(9) initial dcl 10-8 ref 627 max_p_fix_bin_1 constant fixed bin(8,0) initial dcl 1-5 ref 704 member 32(04) based bit(1) level 4 packed unaligned dcl 6-3 ref 1009 min_dec_scale 005325 constant fixed bin(8,0) initial dcl 1-5 ref 606 608 676 min_fun constant bit(9) initial dcl 10-8 ref 626 misc_attributes 31(19) based structure level 3 packed unaligned dcl 6-3 mod builtin function dcl 94 ref 255 802 more_bits 13 based structure level 2 packed unaligned dcl 5-3 move_andnot_1 constant fixed bin(15,0) initial dcl 100 ref 788 move_data 000032 constant entry external dcl 60 ref 316 n 000170 automatic fixed bin(17,0) dcl 44 set ref 412* 416* 417* next 1 based pointer level 2 packed unaligned dcl 3-9 set ref 219* 219 220 222* node based structure level 1 dcl 8-27 nop constant bit(9) initial dcl 10-8 ref 380 nop_mac 000014 constant fixed bin(15,0) initial dcl 100 set ref 255* 382 not_bits constant bit(9) initial dcl 10-8 ref 1033 null builtin function dcl 94 ref 177 214 218 224 227 257 257 271 330 330 346 346 353 369 422 422 449 458 487 722 760 799 952 952 952 964 983 1003 1012 1016 number 0(21) based fixed bin(14,0) level 2 packed unaligned dcl 4-6 ref 160 173 177 670 996 1002 number_of_entries 44 based fixed bin(17,0) level 2 dcl 2-5 ref 207 o 000304 automatic pointer dcl 1026 set ref 1031* 1033 1033 1033 1038 odd_bases 000015 constant bit(19) initial dcl 98 ref 229 344 418 offset 5 based pointer level 2 packed unaligned dcl 5-3 ref 722 799 896 896 896 896 952 op_class defined bit(5) unaligned dcl 56 ref 167 324 549 754 op_code 000161 automatic bit(9) unaligned dcl 44 in procedure "compile_tree" set ref 155* 157 167 167 187 193 203 236 278 287 314 322 324 324 334 340 350 367 380 388 402 442 480 530 549 549 570 570 572 670 670 693 693 717 754 754 756 764 810 823 840 1033 op_code 000105 automatic bit(9) dcl 980 in procedure "check_aggregate" set ref 986* 988 994 op_code 0(09) based bit(9) level 2 in structure "operator" packed unaligned dcl 4-6 in procedure "compile_tree" ref 155 612 615 625 626 627 628 986 1033 open_file constant bit(9) initial dcl 10-8 ref 334 open_mac constant fixed bin(15,0) initial dcl 100 ref 336 operand 1 based pointer array level 2 packed unaligned dcl 4-6 set ref 161 174 505 507 589 633* 680* 684* 714 781 783 786 990 997 1003 1004 1033 1033 1038 operator based structure level 1 dcl 4-6 operator_node constant bit(9) initial dcl 8-5 ref 500 587 984 or_bits constant bit(9) initial dcl 10-8 ref 810 p 000100 automatic pointer dcl 44 in procedure "compile_tree" set ref 154* 155 160 161 173 174 177 189* 189* 195* 196* 197* 198 198* 206* 207 214 217 221 224 224 316* 634* 663* 670 678* 680 681* 684 714 844* p 000100 automatic pointer dcl 978 in procedure "check_aggregate" set ref 982* 983 984 986 990 996 997 1002 1003 1004* 1004 1005 1006 p1 000114 automatic pointer dcl 44 set ref 271* 271* 272* 273 360* 361 362* 457* 467* 589* 590 591 593 681* 683* p2 parameter pointer dcl 920 in procedure "overlaps" ref 915 922 922 922 922 922 p2 000120 automatic pointer dcl 44 in procedure "compile_tree" set ref 355* 356* 498* 500 505 505* 505* 507* 507 510 510 510 512* 714* 715* 733* 740* 745* 769* 771* 781* 783* 791* 795* 815* 816* 820* p2 000306 automatic pointer dcl 1028 in procedure "can_do_andnot" set ref 1038* 1040 1042* 1042* 1043 1045* p_o parameter pointer dcl 1026 ref 1022 1031 packed 33 based bit(1) level 4 packed unaligned dcl 6-3 ref 650 perm_address 12(18) based bit(1) level 3 packed unaligned dcl 5-3 set ref 299* 304* plio_ps 17 based pointer level 2 packed unaligned dcl 2-5 ref 214 pop_ctl_data constant fixed bin(15,0) initial dcl 100 ref 408 pop_ctl_desc constant fixed bin(15,0) initial dcl 100 ref 404 prepare_operand 000122 constant entry external dcl 68 ref 195 230 230 241 243 248 260 280 291 355 360 372 373 390 444 449 452 482 489 496 532 534 682 708 715 768 769 781 808 816 1042 prologue 11 based pointer level 2 packed unaligned dcl 2-5 set ref 221 224* pt parameter pointer dcl 978 in procedure "check_aggregate" ref 973 982 pt parameter pointer dcl 939 in procedure "set_structure" ref 935 941 pt parameter pointer dcl 35 in procedure "compile_tree" set ref 31 154 169* 327 328* ptr_class constant bit(5) initial unaligned dcl 132 ref 549 push_ctl_data constant fixed bin(15,0) initial dcl 100 ref 398 push_ctl_desc constant fixed bin(15,0) initial dcl 100 ref 394 q1 000116 automatic pointer dcl 44 in procedure "compile_tree" set ref 417* 419* 444* 468* 496* 498 518* 532* 539* 708* 749* 750* 768* 771* 795* 808* 810 839* 840* 862* 863 864 866 866 868 868* 887* 888 889 889 889 893 893 896 896 q1 parameter pointer dcl 920 in procedure "overlaps" ref 915 922 922 922 922 922 922 922 q2 000122 automatic pointer dcl 44 set ref 280* 281* 390* 391* 452* 453* 482* 485* 534* 537* 715* 721 722 722 731* 740* 741* 745* 816* 820* 822 q3 000124 automatic pointer dcl 44 set ref 449* 460* 489* 492* qualifier 4 based pointer level 2 packed unaligned dcl 5-3 ref 498 851 893 893 893 893 952 r 000272 automatic pointer dcl 939 set ref 949* 950 952 952 952 952* 957 957* rand 000132 automatic pointer array dcl 44 set ref 174* 177 177 177 177 183* 195* 239* 241* 243* 244* 248* 249* 262* 271 280* 281* 282* 283* 291* 294* 318* 353 355* 360 369 369 369 372 373* 386 390* 393* 420 420* 424* 444* 449 449* 452* 455* 458 482* 483* 487 489* 490* 496* 532* 534* 535* 566 566 566 566 587 589 612 615 625 626 627 628 633 633 634 652 652 682* 682* 683* 684 708* 760 760 768* 769* 771 776* 781 783 786 791* 799 800 802 802 803 808* 815 846 846* 848 851 858 858 862 863 868 868* 887 888 889 889 893 893 896 896 910 910* 1045* real_fix_bin_2 constant fixed bin(15,0) initial dcl 11-1 ref 246 267 ref_count 0(18) based fixed bin(17,0) level 2 packed unaligned dcl 5-3 set ref 510* 510 566 566* 566 591 1033 reference based structure level 1 dcl 5-3 in procedure "compile_tree" reference 15 based pointer level 2 in structure "symbol" packed unaligned dcl 6-3 in procedure "compile_tree" ref 949 reference_node constant bit(9) initial dcl 8-5 ref 177 771 864 889 1005 1040 revert_file constant fixed bin(15,0) initial dcl 100 ref 374 revert_mac constant fixed bin(15,0) initial dcl 100 ref 369 revert_on constant bit(9) initial dcl 10-8 ref 367 round_fun constant bit(9) initial dcl 10-8 ref 625 670 s 000274 automatic pointer dcl 939 in procedure "set_structure" set ref 943* 945 946* 946 949 957 962 964 965* 965 966 969* 969 s 000102 automatic pointer dcl 978 in procedure "check_aggregate" set ref 1006* 1007 1009 1009 1009 1009 1009 1012 1013* 1013 1016 1016* s1 000126 automatic pointer dcl 44 set ref 386* 394 396 404 406 409 410 413 566 597 598 600 605 606 612 612 617 619 619 622 638 648 649 650 659 670 670 676 676 680 680 700 701 702 704 s2 000130 automatic pointer dcl 44 set ref 593* 597 598 607 608 612 617 619 619 622 645 645 659 721* 722 722 save_cur_node 000156 automatic pointer dcl 44 set ref 326* 329 scale 2(28) based fixed bin(7,0) level 2 packed unaligned dcl 6-3 ref 605 606 607 608 612 619 619 676 676 set_desc_size constant fixed bin(15,0) initial dcl 100 ref 308 shared 0(11) based bit(1) level 2 packed unaligned dcl 5-3 ref 177 420 510 566 910 signal_mac constant fixed bin(15,0) initial dcl 100 ref 353 signal_on constant bit(9) initial dcl 10-8 ref 350 son 21 based pointer level 2 packed unaligned dcl 6-3 ref 946 stack_temp$assign_aggregate 000134 constant entry external dcl 68 ref 1016 state_man$erase_reg 000102 constant entry external dcl 68 ref 229 344 418 state_man$flush 000076 constant entry external dcl 68 ref 253 363 446 465 514 541 state_man$flush_ref 000034 constant entry external dcl 60 ref 196 749 839 952 state_man$set_aliasables 000104 constant entry external dcl 68 ref 198 330 346 422 846 957 statement based structure level 1 dcl 3-9 std_call constant bit(9) initial dcl 10-8 ref 187 storage_class 32(09) based structure level 3 packed unaligned dcl 6-3 store$force 000072 constant entry external dcl 68 ref 251 string_mac 000011 constant fixed bin(15,0) initial array dcl 100 ref 840 structure 31 based bit(1) level 4 packed unaligned dcl 6-3 ref 945 1009 sub constant bit(9) initial dcl 10-8 ref 693 717 substr 13 based bit(1) level 3 packed unaligned dcl 5-3 ref 922 922 symbol 3 based pointer level 2 in structure "reference" packed unaligned dcl 5-3 in procedure "compile_tree" ref 360 369 369 372 386 593 721 868 868 889 889 922 922 922 922 922 922 922 922 941 1006 symbol based structure level 1 dcl 6-3 in procedure "compile_tree" symbol_node constant bit(9) initial dcl 8-5 ref 1007 tag 10(30) based bit(6) level 3 packed unaligned dcl 5-3 set ref 301 307* temporary 32(17) based bit(1) level 4 packed unaligned dcl 6-3 ref 566 1009 trunc_fun constant bit(9) initial dcl 10-8 ref 612 type based bit(9) level 2 packed unaligned dcl 8-27 ref 177 500 587 771 864 889 984 1005 1007 1040 ulp 000112 automatic pointer dcl 44 set ref 243* 244* 246 246 246 264 267 267 267 unaligned 31(22) based bit(1) level 4 packed unaligned dcl 6-3 ref 702 units 0(14) based fixed bin(3,0) level 2 packed unaligned dcl 5-3 set ref 652 652 802 858 858* 866 866* unpack constant bit(9) initial dcl 10-8 ref 628 useless 000310 automatic bit(1) dcl 1029 set ref 1042* varying 31(26) based bit(1) level 4 packed unaligned dcl 6-3 ref 922 922 922 word_ constant fixed bin(3,0) initial dcl 12-5 ref 652 858 866 xor_bits constant bit(9) initial dcl 10-8 ref 756 xr_man$load_const 000074 constant entry external dcl 68 ref 361 zero_mac constant fixed bin(15,0) initial dcl 100 ref 197 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. a_format internal static bit(9) initial dcl 10-8 abs_fun internal static bit(9) initial dcl 10-8 acos_fun internal static bit(9) initial dcl 10-8 acosd_fun internal static bit(9) initial dcl 10-8 addbitno_fun internal static bit(9) initial dcl 10-8 addcharno_fun internal static bit(9) initial dcl 10-8 addr_fun internal static bit(9) initial dcl 10-8 addr_fun_bits internal static bit(9) initial dcl 10-8 addrel_fun internal static bit(9) initial dcl 10-8 allocation_fun internal static bit(9) initial dcl 10-8 allot_var internal static bit(9) initial dcl 10-8 array_node internal static bit(9) initial dcl 8-5 asin_fun internal static bit(9) initial dcl 10-8 asind_fun internal static bit(9) initial dcl 10-8 assign_by_name internal static bit(9) initial dcl 10-8 assign_round internal static bit(9) initial dcl 10-8 atan_fun internal static bit(9) initial dcl 10-8 atand_fun internal static bit(9) initial dcl 10-8 b_format internal static bit(9) initial dcl 10-8 baseno_fun internal static bit(9) initial dcl 10-8 baseptr_fun internal static bit(9) initial dcl 10-8 bit_ internal static fixed bin(3,0) initial dcl 12-5 bit_pointer internal static bit(9) initial dcl 10-8 bit_string internal static fixed bin(15,0) initial dcl 11-1 bit_to_char internal static bit(9) initial dcl 10-8 bit_to_word internal static bit(9) initial dcl 10-8 bitno_fun internal static bit(9) initial dcl 10-8 bits_per_char internal static fixed bin(8,0) initial dcl 1-5 bits_per_four_words internal static fixed bin(8,0) initial dcl 1-5 bits_per_half internal static fixed bin(8,0) initial dcl 1-5 bits_per_packed_digit internal static fixed bin(8,1) initial dcl 1-35 bits_per_words internal static fixed bin(8,0) initial array dcl 1-5 block_node internal static bit(9) initial dcl 8-5 bn_format internal static bit(9) initial dcl 10-8 bool_fun internal static bit(9) initial dcl 10-8 bound_ck internal static bit(9) initial dcl 10-8 bound_node internal static bit(9) initial dcl 8-5 break_even_bits internal static fixed bin(8,0) initial dcl 1-5 break_even_words internal static fixed bin(8,0) initial dcl 1-5 by_context internal static bit(3) initial dcl 9-5 by_declare internal static bit(3) initial dcl 9-5 by_explicit_context internal static bit(3) initial dcl 9-5 by_implication internal static bit(3) initial dcl 9-5 by_name_agg_node internal static bit(9) initial dcl 8-5 byte_fun internal static bit(9) initial dcl 10-8 c_format internal static bit(9) initial dcl 10-8 cat_string internal static bit(9) initial dcl 10-8 ceil_fun internal static bit(9) initial dcl 10-8 char_string internal static fixed bin(15,0) initial dcl 11-1 char_to_word internal static bit(9) initial dcl 10-8 character_ internal static fixed bin(3,0) initial dcl 12-5 charno_fun internal static bit(9) initial dcl 10-8 chars_per_word internal static fixed bin(8,0) initial dcl 1-5 clock_fun internal static bit(9) initial dcl 10-8 codeptr_fun internal static bit(9) initial dcl 10-8 column_format internal static bit(9) initial dcl 10-8 complex_fix_bin_1 internal static fixed bin(15,0) initial dcl 11-1 complex_fix_bin_2 internal static fixed bin(15,0) initial dcl 11-1 complex_fix_dec internal static fixed bin(15,0) initial dcl 11-1 complex_flt_bin_1 internal static fixed bin(15,0) initial dcl 11-1 complex_flt_bin_2 internal static fixed bin(15,0) initial dcl 11-1 complex_flt_dec internal static fixed bin(15,0) initial dcl 11-1 conjg_fun internal static bit(9) initial dcl 10-8 context_node internal static bit(9) initial dcl 8-5 convert_size internal static fixed bin(8,0) initial array dcl 1-5 cos_fun internal static bit(9) initial dcl 10-8 cosd_fun internal static bit(9) initial dcl 10-8 cross_reference_node internal static bit(9) initial dcl 8-5 default_fix_bin_p internal static fixed bin(8,0) initial dcl 1-5 default_node internal static bit(9) initial dcl 8-5 delete_file internal static bit(9) initial dcl 10-8 desc_size internal static bit(9) initial dcl 10-8 digit_ internal static fixed bin(3,0) initial dcl 12-5 digit_to_bit internal static bit(9) initial dcl 10-8 div internal static bit(9) initial dcl 10-8 do_fun internal static bit(9) initial dcl 10-8 do_spec internal static bit(9) initial dcl 10-8 e_format internal static bit(9) initial dcl 10-8 enable_on internal static bit(9) initial dcl 10-8 entry_variable internal static fixed bin(15,0) initial dcl 11-1 environmentptr_fun internal static bit(9) initial dcl 10-8 equal internal static bit(9) initial dcl 10-8 exp internal static bit(9) initial dcl 10-8 exp_fun internal static bit(9) initial dcl 10-8 ext_entry_in internal static fixed bin(15,0) initial dcl 11-1 ext_entry_out internal static fixed bin(15,0) initial dcl 11-1 f_format internal static bit(9) initial dcl 10-8 floor_fun internal static bit(9) initial dcl 10-8 format_value_node internal static bit(9) initial dcl 8-5 fortran_read internal static bit(9) initial dcl 10-8 fortran_write internal static bit(9) initial dcl 10-8 free_var internal static bit(9) initial dcl 10-8 ftn_file_manip internal static bit(9) initial dcl 10-8 ftn_trans_loop internal static bit(9) initial dcl 10-8 get_data_trans internal static bit(9) initial dcl 10-8 get_edit_trans internal static bit(9) initial dcl 10-8 get_file internal static bit(9) initial dcl 10-8 get_list_trans internal static bit(9) initial dcl 10-8 get_string internal static bit(9) initial dcl 10-8 greater_or_equal internal static bit(9) initial dcl 10-8 greater_than internal static bit(9) initial dcl 10-8 half_ internal static fixed bin(3,0) initial dcl 12-5 half_to_word internal static bit(9) initial dcl 10-8 imag_fun internal static bit(9) initial dcl 10-8 index_after_fun internal static bit(9) initial dcl 10-8 index_before_fun internal static bit(9) initial dcl 10-8 index_fun internal static bit(9) initial dcl 10-8 index_rev_fun internal static bit(9) initial dcl 10-8 int_entry internal static fixed bin(15,0) initial dcl 11-1 int_entry_other internal static fixed bin(15,0) initial dcl 11-1 jump internal static bit(9) initial dcl 10-8 jump_false internal static bit(9) initial dcl 10-8 jump_if_eq internal static bit(9) initial dcl 10-8 jump_if_ge internal static bit(9) initial dcl 10-8 jump_if_gt internal static bit(9) initial dcl 10-8 jump_if_le internal static bit(9) initial dcl 10-8 jump_if_lt internal static bit(9) initial dcl 10-8 jump_if_ne internal static bit(9) initial dcl 10-8 jump_true internal static bit(9) initial dcl 10-8 l_parn internal static bit(9) initial dcl 10-8 label_array_element_node internal static bit(9) initial dcl 8-5 label_constant internal static fixed bin(15,0) initial dcl 11-1 label_node internal static bit(9) initial dcl 8-5 label_size internal static fixed bin(8,0) initial dcl 1-5 label_variable internal static fixed bin(15,0) initial dcl 11-1 length_fun internal static bit(9) initial dcl 10-8 less_or_equal internal static bit(9) initial dcl 10-8 less_than internal static bit(9) initial dcl 10-8 line_format internal static bit(9) initial dcl 10-8 list_node internal static bit(9) initial dcl 8-5 local_label_variable internal static fixed bin(15,0) initial dcl 11-1 locate_file internal static bit(9) initial dcl 10-8 lock_file internal static bit(9) initial dcl 10-8 lock_fun internal static bit(9) initial dcl 10-8 log10_fun internal static bit(9) initial dcl 10-8 log2_fun internal static bit(9) initial dcl 10-8 log_fun internal static bit(9) initial dcl 10-8 machine_state_node internal static bit(9) initial dcl 8-5 max_block_number internal static fixed bin(17,0) initial dcl 2-74 max_index_register_value internal static fixed bin(31,0) initial dcl 1-38 max_length_p internal static fixed bin(8,0) initial dcl 1-5 max_list_elements internal static fixed bin(17,0) initial dcl 13-12 max_number_of_operands internal static fixed bin(15,0) initial dcl 4-15 max_offset internal static fixed bin(8,0) initial array dcl 1-5 max_p_fix_dec internal static fixed bin(8,0) initial dcl 1-5 max_p_flt_bin_1 internal static fixed bin(8,0) initial dcl 1-5 max_p_xreg internal static fixed bin(8,0) initial dcl 1-5 max_short_size internal static fixed bin(8,0) initial array dcl 1-5 mod2_ internal static fixed bin(3,0) initial dcl 12-5 mod4_ internal static fixed bin(3,0) initial dcl 12-5 mod_bit internal static bit(9) initial dcl 10-8 mod_byte internal static bit(9) initial dcl 10-8 mod_fun internal static bit(9) initial dcl 10-8 mod_half internal static bit(9) initial dcl 10-8 mod_word internal static bit(9) initial dcl 10-8 mult internal static bit(9) initial dcl 10-8 negate internal static bit(9) initial dcl 10-8 not_equal internal static bit(9) initial dcl 10-8 off_fun internal static bit(9) initial dcl 10-8 pack internal static bit(9) initial dcl 10-8 packed_digits_per_char internal static fixed bin(8,0) initial dcl 1-5 packed_digits_per_word internal static fixed bin(8,0) initial dcl 1-5 packed_ptr internal static fixed bin(15,0) initial dcl 11-1 page_format internal static bit(9) initial dcl 10-8 param_desc_ptr internal static bit(9) initial dcl 10-8 param_ptr internal static bit(9) initial dcl 10-8 picture_format internal static bit(9) initial dcl 10-8 pl1_mod_fun internal static bit(9) initial dcl 10-8 prefix_plus internal static bit(9) initial dcl 10-8 ptr_fun internal static bit(9) initial dcl 10-8 put_control internal static bit(9) initial dcl 10-8 put_data_trans internal static bit(9) initial dcl 10-8 put_edit_trans internal static bit(9) initial dcl 10-8 put_field internal static bit(9) initial dcl 10-8 put_field_chk internal static bit(9) initial dcl 10-8 put_file internal static bit(9) initial dcl 10-8 put_list_trans internal static bit(9) initial dcl 10-8 put_string internal static bit(9) initial dcl 10-8 r_format internal static bit(9) initial dcl 10-8 r_parn internal static bit(9) initial dcl 10-8 range_ck internal static bit(9) initial dcl 10-8 rank_fun internal static bit(9) initial dcl 10-8 read_file internal static bit(9) initial dcl 10-8 real_fix_bin_1 internal static fixed bin(15,0) initial dcl 11-1 real_fix_dec internal static fixed bin(15,0) initial dcl 11-1 real_flt_bin_1 internal static fixed bin(15,0) initial dcl 11-1 real_flt_bin_2 internal static fixed bin(15,0) initial dcl 11-1 real_flt_dec internal static fixed bin(15,0) initial dcl 11-1 real_fun internal static bit(9) initial dcl 10-8 record_io internal static bit(9) initial dcl 10-8 refer internal static bit(9) initial dcl 10-8 rel_fun internal static bit(9) initial dcl 10-8 repeat_fun internal static bit(9) initial dcl 10-8 return_bits internal static bit(9) initial dcl 10-8 return_string internal static bit(9) initial dcl 10-8 return_value internal static bit(9) initial dcl 10-8 return_words internal static bit(9) initial dcl 10-8 reverse_fun internal static bit(9) initial dcl 10-8 rewrite_file internal static bit(9) initial dcl 10-8 search_fun internal static bit(9) initial dcl 10-8 search_rev_fun internal static bit(9) initial dcl 10-8 segno_fun internal static bit(9) initial dcl 10-8 setbitno_fun internal static bit(9) initial dcl 10-8 setcharno_fun internal static bit(9) initial dcl 10-8 sf_par_node internal static bit(9) initial dcl 8-5 sign_fun internal static bit(9) initial dcl 10-8 sin_fun internal static bit(9) initial dcl 10-8 sind_fun internal static bit(9) initial dcl 10-8 skip_format internal static bit(9) initial dcl 10-8 source_node internal static bit(9) initial dcl 8-5 sqrt_fun internal static bit(9) initial dcl 10-8 stack_ptr internal static bit(9) initial dcl 10-8 stackbaseptr_fun internal static bit(9) initial dcl 10-8 stackframeptr_fun internal static bit(9) initial dcl 10-8 stacq_fun internal static bit(9) initial dcl 10-8 statement_node internal static bit(9) initial dcl 8-5 std_arg_list internal static bit(9) initial dcl 10-8 std_entry internal static bit(9) initial dcl 10-8 std_return internal static bit(9) initial dcl 10-8 stop internal static bit(9) initial dcl 10-8 stream_prep internal static bit(9) initial dcl 10-8 tan_fun internal static bit(9) initial dcl 10-8 tand_fun internal static bit(9) initial dcl 10-8 temporary_node internal static bit(9) initial dcl 8-5 terminate_trans internal static bit(9) initial dcl 10-8 token_node internal static bit(9) initial dcl 8-5 translate_fun internal static bit(9) initial dcl 10-8 units_per_word internal static fixed bin(8,0) initial array dcl 1-5 unlock_file internal static bit(9) initial dcl 10-8 unpacked_ptr internal static fixed bin(15,0) initial dcl 11-1 vclock_fun internal static bit(9) initial dcl 10-8 verify_fun internal static bit(9) initial dcl 10-8 verify_ltrim_fun internal static bit(9) initial dcl 10-8 verify_rev_fun internal static bit(9) initial dcl 10-8 verify_rtrim_fun internal static bit(9) initial dcl 10-8 word_to_mod2 internal static bit(9) initial dcl 10-8 word_to_mod4 internal static bit(9) initial dcl 10-8 word_to_mod8 internal static bit(9) initial dcl 10-8 wordno_fun internal static bit(9) initial dcl 10-8 write_file internal static bit(9) initial dcl 10-8 x_format internal static bit(9) initial dcl 10-8 NAMES DECLARED BY EXPLICIT CONTEXT. ca 001760 constant label dcl 409 ref 399 can_do_andnot 005166 constant entry internal dcl 1022 ref 776 ce 004315 constant label dcl 844 ref 549 635 688 700 701 702 704 706 756 762 771 799 800 804 806 810 check_aggregate 005016 constant entry internal dcl 973 ref 239 990 997 compile_tree 000025 constant entry external dcl 31 drop_count 004576 constant entry internal dcl 908 ref 710 793 812 l0 003140 constant label dcl 663 ref 572 587 590 591 597 598 605 606 607 608 612 617 619 622 625 626 627 628 638 648 649 650 652 l1a 003455 constant label dcl 735 ref 742 l2 003460 constant label dcl 738 ref 717 l3 003542 constant label dcl 749 ref 728 736 l4 001221 constant label dcl 316 ref 322 l6 001307 constant label dcl 344 ref 337 loop 004714 constant label dcl 945 ref 970 overlaps 004622 constant entry internal dcl 915 ref 771 1045 search 004351 constant entry internal dcl 856 ref 762 806 search_arithmetic 004453 constant entry internal dcl 878 ref 706 set 004324 constant label dcl 846 ref 664 685 751 796 841 set_structure 004705 constant entry internal dcl 935 ref 318 424 851 step 004571 constant label dcl 901 ref 893 896 switch 003074 constant label dcl 633 ref 656 659 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 6004 6142 5330 6014 Length 6732 5330 136 554 453 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME compile_tree 286 external procedure is an external procedure. search internal procedure shares stack frame of external procedure compile_tree. search_arithmetic internal procedure shares stack frame of external procedure compile_tree. drop_count internal procedure shares stack frame of external procedure compile_tree. overlaps internal procedure shares stack frame of external procedure compile_tree. set_structure internal procedure shares stack frame of external procedure compile_tree. check_aggregate 94 internal procedure calls itself recursively. can_do_andnot internal procedure shares stack frame of external procedure compile_tree. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME check_aggregate 000100 p check_aggregate 000102 s check_aggregate 000104 i check_aggregate 000105 op_code check_aggregate compile_tree 000100 p compile_tree 000102 arg compile_tree 000110 llp compile_tree 000112 ulp compile_tree 000114 p1 compile_tree 000116 q1 compile_tree 000120 p2 compile_tree 000122 q2 compile_tree 000124 q3 compile_tree 000126 s1 compile_tree 000130 s2 compile_tree 000132 rand compile_tree 000156 save_cur_node compile_tree 000160 macro compile_tree 000161 op_code compile_tree 000162 atomic compile_tree 000163 abset compile_tree 000164 i compile_tree 000165 j compile_tree 000166 k compile_tree 000167 loc compile_tree 000170 n compile_tree 000171 cfo compile_tree 000172 d compile_tree 000270 adam set_structure 000272 r set_structure 000274 s set_structure 000304 o can_do_andnot 000306 p2 can_do_andnot 000310 useless can_do_andnot THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_g_a call_ext_out call_int_this call_int_other return mod_fx1 ext_entry int_entry trunc_fx1 scaled_mod_fx1 THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. adjust_ref_count aq_man$clear_q assign_op assign_op$to_dec_scaled base_man$load_var base_man$store_ptr_to base_man$update_base base_to_core c_a call_op compare_expression compile_exp compile_exp$save compile_exp$save_exp compile_tree create_label decimal_op$change_target decimal_op$get_float_temp expmac expmac$many expmac$one expmac$two_eis expmac$zero io_op io_op$init_ps jump_op load m_a move_data prepare_operand stack_temp$assign_aggregate state_man$erase_reg state_man$flush state_man$flush_ref state_man$set_aliasables store$force xr_man$load_const THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. cg_stat$cur_block cg_stat$cur_node cg_stat$cur_statement cg_stat$cur_tree cg_stat$prol_ent cg_stat$text_pos LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 31 000022 154 000032 155 000037 157 000043 160 000045 161 000057 162 000070 164 000072 167 000073 169 000077 170 000105 173 000106 174 000117 175 000123 177 000125 183 000152 184 000165 187 000166 189 000171 190 000201 193 000202 195 000204 196 000223 197 000232 198 000245 200 000260 203 000261 206 000263 207 000267 214 000273 216 000302 217 000306 218 000311 219 000315 220 000320 221 000322 222 000325 223 000327 224 000330 225 000334 227 000335 229 000341 230 000351 233 000403 236 000404 239 000406 241 000414 243 000433 244 000452 246 000466 248 000474 249 000513 249 000531 251 000540 253 000547 255 000554 257 000567 258 000610 259 000615 260 000617 262 000635 264 000644 265 000646 267 000667 271 000676 272 000704 273 000722 275 000726 278 000727 280 000731 281 000750 281 000766 282 000775 283 001010 284 001026 287 001027 290 001031 291 001037 292 001060 294 001062 294 001100 296 001107 298 001135 299 001150 301 001153 303 001156 304 001175 307 001200 308 001203 311 001216 314 001217 316 001221 317 001230 318 001231 319 001233 322 001234 324 001236 326 001243 327 001247 328 001253 329 001261 330 001264 331 001274 334 001275 336 001300 337 001302 340 001303 342 001305 344 001307 345 001320 346 001327 347 001340 350 001341 353 001343 355 001352 356 001371 357 001421 360 001423 361 001446 362 001464 363 001475 364 001502 367 001503 369 001505 372 001547 373 001572 374 001611 377 001632 380 001633 382 001635 383 001646 386 001647 388 001652 390 001654 391 001673 393 001711 394 001720 396 001727 398 001735 399 001737 402 001740 404 001742 406 001750 408 001756 409 001760 410 001764 412 001767 413 001771 415 001776 416 001777 417 002001 418 002014 419 002025 420 002036 422 002054 423 002065 424 002067 425 002071 442 002072 444 002074 446 002113 447 002120 449 002123 452 002145 453 002164 455 002202 457 002211 458 002226 460 002232 461 002251 462 002253 463 002254 465 002256 467 002263 468 002274 470 002307 480 002310 482 002312 483 002331 485 002344 487 002357 489 002363 490 002402 492 002415 496 002430 498 002447 500 002452 505 002456 507 002473 510 002475 512 002506 514 002525 516 002532 518 002543 520 002556 530 002557 532 002561 534 002600 535 002617 537 002632 539 002644 541 002663 543 002670 545 002701 549 002702 566 002705 570 002722 572 002727 587 002731 589 002735 590 002740 591 002743 593 002747 597 002751 598 002763 600 002775 605 002777 606 003004 607 003006 608 003014 612 003016 615 003035 617 003040 619 003050 622 003060 625 003063 626 003066 627 003070 628 003072 633 003074 634 003077 635 003100 638 003101 645 003103 648 003113 649 003116 650 003121 652 003124 656 003132 659 003133 663 003140 664 003147 670 003150 676 003166 678 003176 680 003212 681 003235 682 003246 683 003265 684 003276 685 003301 688 003302 693 003303 700 003310 701 003313 702 003316 704 003321 706 003324 708 003331 710 003350 712 003351 712 003357 714 003361 715 003363 717 003402 719 003405 721 003410 722 003413 727 003430 728 003432 731 003433 732 003445 733 003446 735 003455 736 003457 738 003460 740 003463 741 003477 742 003512 745 003513 745 003531 747 003540 749 003542 750 003551 751 003562 754 003563 756 003566 760 003572 762 003600 764 003605 766 003611 766 003617 768 003621 769 003640 771 003663 774 003675 776 003676 781 003711 783 003736 786 003756 788 003775 789 003777 791 004000 793 004013 795 004014 796 004027 799 004030 800 004033 802 004036 803 004053 804 004055 806 004057 808 004064 810 004103 812 004112 814 004113 814 004121 815 004123 816 004126 818 004145 820 004152 820 004167 822 004176 823 004201 826 004211 827 004216 830 004220 831 004222 833 004227 835 004231 835 004236 836 004240 839 004266 840 004275 841 004314 844 004315 846 004324 848 004340 850 004343 851 004344 854 004350 856 004351 858 004353 861 004363 862 004371 863 004374 864 004404 866 004410 868 004420 872 004446 874 004450 878 004453 886 004455 887 004463 888 004466 889 004476 893 004511 896 004536 899 004565 901 004571 904 004573 908 004576 910 004577 913 004621 915 004622 922 004624 931 004703 935 004705 941 004707 943 004713 945 004714 946 004720 947 004722 949 004723 950 004725 952 004730 957 004750 962 004771 964 004776 965 005002 966 005004 967 005011 969 005012 970 005014 973 005015 982 005023 983 005027 984 005033 986 005037 988 005043 990 005045 991 005056 994 005057 996 005061 997 005073 998 005104 999 005106 1002 005107 1003 005113 1004 005116 1005 005120 1006 005124 1007 005126 1009 005132 1012 005143 1013 005150 1014 005152 1016 005153 1020 005165 1022 005166 1031 005170 1033 005173 1038 005215 1040 005217 1042 005223 1043 005241 1045 005244 1049 005254 1052 005260 ----------------------------------------------------------- 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