COMPILATION LISTING OF SEGMENT pointer_builtins Compiled by: Multics PL/I Compiler, Release 28d, of September 14, 1983 Compiled at: Honeywell LCPD Phoenix, System M Compiled on: 10/03/83 1653.8 mst Mon Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 /* format: style3 */ 10 11 /* procedure to compile pointer valued operators 12* 13* Initial Version: 19 August 1971 by BLW 14* Modified: 11 February 1973 by RAB 15* Modified: 16 October 1975 by RAB to use all regs 16* Modified: 26 March 1975 by RAB to fix bug 1479 introduced 17* 16 October 1975 18* Modified: 27 April 1976 by RAB to fix 1493 19* Modified: 7 Dec 1976 by RAB to fix 1559 20* Modified: 9 May 1977 by RAB to fix 1617 21* Modified: 10 September 1977 by RAB to fix 1613 by adding 3rd arg to store_bit_address 22* Modified: 29 March 1978 by PCK to add stackframeptr, stackbaseptr, environmentptr, and codeptr 23* Modified: 19 August 1978 by PCK to fix bug 1742 */ 24 25 /* Modified BIM 12/82 to add the Palter builtins (addcharno, setcharno, etc. */ 26 /* Modified BIM 1/83 to un-share the first operand always, since it will */ 27 /* be in the machine state in a PR. This, together with */ 28 /* conversion of many compile_exp$save calls to compile_exp, */ 29 /* removes a bunch of spurious stores. */ 30 /* Modified BIM 6/83 to stop calling get_base in addr. get_base assumes */ 31 /* that ref (2) is a pointer VAR to be dicked with, not an object */ 32 /* whose addr is to be returned. */ 33 /* Modified BIM 9/83 to fix some malingering problems in the new bifs, */ 34 /* including an uninitialized variable in NO_FUNS. */ 35 36 pointer_builtins: 37 proc (pt, store_it); 38 39 dcl pt ptr, /* points at operator node */ 40 store_it bit (1) aligned; /* "1"b if value should be stored */ 41 42 dcl ( 43 p, 44 q, 45 p2, 46 s3, 47 ref (3), 48 b2 49 ) ptr, 50 (i, ibase, macro, mac_1, n, old_changed) 51 fixed bin (15), 52 last_freed fixed bin (18), 53 base bit (3) aligned, 54 op_code bit (9) aligned, 55 ( 56 atom (3), 57 adjust, 58 in_base 59 ) bit (1) aligned; 60 61 dcl ( 62 cg_stat$temp_ref, 63 cg_stat$text_base 64 ) ptr ext, 65 cg_stat$text_pos fixed bin ext, 66 cg_stat$null_value bit (72) aligned ext, 67 cg_stat$cur_level fixed bin ext; 68 69 dcl adjust_ref_count entry (pointer, fixed bin); 70 dcl base_man$load_any_var 71 entry (fixed bin, ptr) returns (bit (3) aligned); 72 dcl prepare_operand entry (ptr, fixed bin (15), bit (1) aligned) returns (ptr), 73 compile_exp$save entry (ptr) returns (ptr), 74 compile_exp entry (ptr), 75 c_a entry (fixed bin (15), fixed bin) returns (ptr), 76 load entry (ptr, fixed bin), 77 ( 78 base_man$load_var, 79 base_man$update_base 80 ) entry (fixed bin, ptr, fixed bin (15)); 81 dcl base_man$load_arg_ptr 82 entry (fixed bin (15), ptr, fixed bin) returns (bit (3) aligned); 83 dcl base_man$load_display 84 entry (fixed bin, bit (3) aligned), 85 generate_constant$bit_string 86 entry (bit (*) aligned, fixed bin) returns (ptr); 87 dcl base_to_core entry (fixed bin (15), ptr), 88 state_man$flush_address 89 entry (ptr), 90 state_man$flush_ref entry (ptr), 91 store_bit_address entry (ptr, ptr, fixed bin (18)), 92 store entry (ptr), 93 expmac$zero entry (fixed bin (15)); 94 dcl type2 fixed bin (17), 95 m_a entry (ptr, bit (2) aligned), 96 cg_error entry (fixed bin, fixed bin (9)); 97 declare cg_stat$cur_statement 98 pointer external; 99 100 dcl ( 101 SETCHARNO init (1), 102 ADDCHARNO init (2), 103 SETBITNO init (3), 104 ADDBITNO init (4) 105 ) fixed bin int static options (constant); 106 107 dcl (abs, addrel, bit, fixed, index, null, string) 108 builtin; 109 110 dcl fix_bin fixed bin based; 111 112 dcl ldfx2 init (8) fixed bin (15) static; 113 114 dcl 1 half aligned based, 115 2 left bit (18) unal, 116 2 right bit (18) unal; 117 118 dcl 1 instruction aligned based, 119 2 base bit (3) unal, 120 2 offset bit (15) unal, 121 2 op_code bit (10) unal, 122 2 skip bit (2) unal, 123 2 tag bit (6) unal; 124 125 dcl ( 126 pointer_mac_const (6) init (326, 0, 652, 653, 654, 655), 127 addrel_mac_const (6) init (327, 0, 656, 657, 658, 659), 128 zero_bo (6) init (642, 0, 684, 685, 686, 687), 129 longbs_to_bs18 init (131), 130 pl1_pointer_easy init (602), 131 pl1_pointer_hard init (604), /* pointer_mac_bs(6) init(212,0,660,662,664,666), */ 132 pointer_mac_fx (6) init (213, 0, 661, 663, 665, 667), 133 /* addrel_mac_bs(6) init(214,0,668,670,672,674), */ 134 addrel_mac_fx (6) init (215, 0, 669, 671, 673, 675), 135 /* baseptr_mac_bs(6) init(216,0,676,678,680,682), */ 136 baseptr_mac_fx (6) init (217, 0, 677, 679, 681, 683) 137 ) fixed bin (15) int static; 138 139 dcl epbx (0:7) 140 init ("0111010001"b, "0111010101"b, "0111110001"b, "0111010010"b, "0111010110"b, 141 "0111110010"b, "0111110110"b, "0111110101"b) bit (10) aligned int static; 142 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 143 2 1 /* BEGIN INCLUDE FILE ... operator.incl.pl1 */ 2 2 2 3 /* Modified: 2 Apr 1980 by PCK to add max_number_of_operands */ 2 4 2 5 /* format: style3 */ 2 6 dcl 1 operator based aligned, 2 7 2 node_type bit (9) unaligned, 2 8 2 op_code bit (9) unaligned, 2 9 2 shared bit (1) unaligned, 2 10 2 processed bit (1) unaligned, 2 11 2 optimized bit (1) unaligned, 2 12 2 number fixed (14) unaligned, 2 13 2 operand dimension (n refer (operator.number)) ptr unaligned; 2 14 2 15 dcl max_number_of_operands 2 16 fixed bin (15) int static options (constant) initial (32767); 2 17 2 18 /* END INCLUDE FILE ... operator.incl.pl1 */ 144 3 1 /* BEGIN INCLUDE FILE ... reference.incl.pl1 */ 3 2 3 3 dcl 1 reference based aligned, 3 4 2 node_type bit(9) unaligned, 3 5 2 array_ref bit(1) unaligned, 3 6 2 varying_ref bit(1) unaligned, 3 7 2 shared bit(1) unaligned, 3 8 2 put_data_sw bit(1) unaligned, 3 9 2 processed bit(1) unaligned, 3 10 2 units fixed(3) unaligned, 3 11 2 ref_count fixed(17) unaligned, 3 12 2 c_offset fixed(24), 3 13 2 c_length fixed(24), 3 14 2 symbol ptr unaligned, 3 15 2 qualifier ptr unaligned, 3 16 2 offset ptr unaligned, 3 17 2 length ptr unaligned, 3 18 2 subscript_list ptr unaligned, 3 19 /* these fields are used by the 645 code generator */ 3 20 2 address structure unaligned, 3 21 3 base bit(3), 3 22 3 offset bit(15), 3 23 3 op bit(9), 3 24 3 no_address bit(1), 3 25 3 inhibit bit(1), 3 26 3 ext_base bit(1), 3 27 3 tag bit(6), 3 28 2 info structure unaligned, 3 29 3 address_in structure, 3 30 4 b dimension(0:7) bit(1), 3 31 4 storage bit(1), 3 32 3 value_in structure, 3 33 4 a bit(1), 3 34 4 q bit(1), 3 35 4 aq bit(1), 3 36 4 string_aq bit(1), 3 37 4 complex_aq bit(1), 3 38 4 decimal_aq bit(1), 3 39 4 b dimension(0:7) bit(1), 3 40 4 storage bit(1), 3 41 4 indicators bit(1), 3 42 4 x dimension(0:7) bit(1), 3 43 3 other structure, 3 44 4 big_offset bit(1), 3 45 4 big_length bit(1), 3 46 4 modword_in_offset bit(1), 3 47 2 data_type fixed(5) unaligned, 3 48 2 bits structure unaligned, 3 49 3 padded_ref bit(1), 3 50 3 aligned_ref bit(1), 3 51 3 long_ref bit(1), 3 52 3 forward_ref bit(1), 3 53 3 ic_ref bit(1), 3 54 3 temp_ref bit(1), 3 55 3 defined_ref bit(1), 3 56 3 evaluated bit(1), 3 57 3 allocate bit(1), 3 58 3 allocated bit(1), 3 59 3 aliasable bit(1), 3 60 3 even bit(1), 3 61 3 perm_address bit(1), 3 62 3 aggregate bit(1), 3 63 3 hit_zero bit(1), 3 64 3 dont_save bit(1), 3 65 3 fo_in_qual bit(1), 3 66 3 hard_to_load bit(1), 3 67 2 relocation bit(12) unaligned, 3 68 2 more_bits structure unaligned, 3 69 3 substr bit(1), 3 70 3 padded_for_store_ref bit(1), 3 71 3 aligned_for_store_ref bit(1), 3 72 3 mbz bit(15), 3 73 2 store_ins bit(18) unaligned; 3 74 3 75 /* END INCLUDE FILE ... reference.incl.pl1 */ 145 4 1 /* BEGIN INCLUDE FILE ... symbol.incl.pl1 */ 4 2 4 3 dcl 1 symbol based aligned, 4 4 2 node_type bit(9) unal, 4 5 2 source_id structure unal, 4 6 3 file_number bit(8), 4 7 3 line_number bit(14), 4 8 3 statement_number bit(5), 4 9 2 location fixed(18) unal unsigned, 4 10 2 allocated bit(1) unal, 4 11 2 dcl_type bit(3) unal, 4 12 2 reserved bit(6) unal, 4 13 2 pix unal, 4 14 3 pic_fixed bit(1) unal, 4 15 3 pic_float bit(1) unal, 4 16 3 pic_char bit(1) unal, 4 17 3 pic_scale fixed(7) unal, 4 18 3 pic_size fixed(7) unal, 4 19 2 level fixed(8) unal, 4 20 2 boundary fixed(3) unal, 4 21 2 size_units fixed(3) unal, 4 22 2 scale fixed(7) unal, 4 23 2 runtime bit(18) unal, 4 24 2 runtime_offset bit(18) unal, 4 25 2 block_node ptr unal, 4 26 2 token ptr unal, 4 27 2 next ptr unal, 4 28 2 multi_use ptr unal, 4 29 2 cross_references ptr unal, 4 30 2 initial ptr unal, 4 31 2 array ptr unal, 4 32 2 descriptor ptr unal, 4 33 2 equivalence ptr unal, 4 34 2 reference ptr unal, 4 35 2 general ptr unal, 4 36 2 father ptr unal, 4 37 2 brother ptr unal, 4 38 2 son ptr unal, 4 39 2 word_size ptr unal, 4 40 2 bit_size ptr unal, 4 41 2 dcl_size ptr unal, 4 42 2 symtab_size ptr unal, 4 43 2 c_word_size fixed(24), 4 44 2 c_bit_size fixed(24), 4 45 2 c_dcl_size fixed(24), 4 46 4 47 2 attributes structure aligned, 4 48 3 data_type structure unal, 4 49 4 structure bit(1) , 4 50 4 fixed bit(1), 4 51 4 float bit(1), 4 52 4 bit bit(1), 4 53 4 char bit(1), 4 54 4 ptr bit(1), 4 55 4 offset bit(1), 4 56 4 area bit(1), 4 57 4 label bit(1), 4 58 4 entry bit(1), 4 59 4 file bit(1), 4 60 4 arg_descriptor bit(1), 4 61 4 storage_block bit(1), 4 62 4 explicit_packed bit(1), /* options(packed) */ 4 63 4 condition bit(1), 4 64 4 format bit(1), 4 65 4 builtin bit(1), 4 66 4 generic bit(1), 4 67 4 picture bit(1), 4 68 4 69 3 misc_attributes structure unal, 4 70 4 dimensioned bit(1), 4 71 4 initialed bit(1), 4 72 4 aligned bit(1), 4 73 4 unaligned bit(1), 4 74 4 signed bit(1), 4 75 4 unsigned bit(1), 4 76 4 precision bit(1), 4 77 4 varying bit(1), 4 78 4 local bit(1), 4 79 4 decimal bit(1), 4 80 4 binary bit(1), 4 81 4 real bit(1), 4 82 4 complex bit(1), 4 83 4 variable bit(1), 4 84 4 reducible bit(1), 4 85 4 irreducible bit(1), 4 86 4 returns bit(1), 4 87 4 position bit(1), 4 88 4 internal bit(1), 4 89 4 external bit(1), 4 90 4 like bit(1), 4 91 4 member bit(1), 4 92 4 non_varying bit(1), 4 93 4 options bit(1), 4 94 4 variable_arg_list bit(1), /* options(variable) */ 4 95 4 alloc_in_text bit(1), /* options(constant) */ 4 96 4 97 3 storage_class structure unal, 4 98 4 auto bit(1), 4 99 4 based bit(1), 4 100 4 static bit(1), 4 101 4 controlled bit(1), 4 102 4 defined bit(1), 4 103 4 parameter bit(1), 4 104 4 param_desc bit(1), 4 105 4 constant bit(1), 4 106 4 temporary bit(1), 4 107 4 return_value bit(1), 4 108 4 109 3 file_attributes structure unal, 4 110 4 print bit(1), 4 111 4 input bit(1), 4 112 4 output bit(1), 4 113 4 update bit(1), 4 114 4 stream bit(1), 4 115 4 reserved_1 bit(1), 4 116 4 record bit(1), 4 117 4 sequential bit(1), 4 118 4 direct bit(1), 4 119 4 interactive bit(1), /* env(interactive) */ 4 120 4 reserved_2 bit(1), 4 121 4 reserved_3 bit(1), 4 122 4 stringvalue bit(1), /* env(stringvalue) */ 4 123 4 keyed bit(1), 4 124 4 reserved_4 bit(1), 4 125 4 environment bit(1), 4 126 4 127 3 compiler_developed structure unal, 4 128 4 aliasable bit(1), 4 129 4 packed bit(1), 4 130 4 passed_as_arg bit(1), 4 131 4 allocate bit(1), 4 132 4 set bit(1), 4 133 4 exp_extents bit(1), 4 134 4 refer_extents bit(1), 4 135 4 star_extents bit(1), 4 136 4 isub bit(1), 4 137 4 put_in_symtab bit(1), 4 138 4 contiguous bit(1), 4 139 4 put_data bit(1), 4 140 4 overlayed bit(1), 4 141 4 error bit(1), 4 142 4 symtab_processed bit(1), 4 143 4 overlayed_by_builtin bit(1), 4 144 4 defaulted bit(1), 4 145 4 connected bit(1); 4 146 4 147 /* END INCLUDE FILE ... symbol.incl.pl1 */ 146 5 1 /* BEGIN INCLUDE FILE ... block.incl.pl1 */ 5 2 /* Modified 22 Ocober 1980 by M. N. Davidoff to increase max block.number to 511 */ 5 3 /* format: style3,idind30 */ 5 4 5 5 declare 1 block aligned based, 5 6 2 node_type bit (9) unaligned, 5 7 2 source_id structure unaligned, 5 8 3 file_number bit (8), 5 9 3 line_number bit (14), 5 10 3 statement_number bit (5), 5 11 2 father ptr unaligned, 5 12 2 brother ptr unaligned, 5 13 2 son ptr unaligned, 5 14 2 declaration ptr unaligned, 5 15 2 end_declaration ptr unaligned, 5 16 2 default ptr unaligned, 5 17 2 end_default ptr unaligned, 5 18 2 context ptr unaligned, 5 19 2 prologue ptr unaligned, 5 20 2 end_prologue ptr unaligned, 5 21 2 main ptr unaligned, 5 22 2 end_main ptr unaligned, 5 23 2 return_values ptr unaligned, 5 24 2 return_count ptr unaligned, 5 25 2 plio_ps ptr unaligned, 5 26 2 plio_fa ptr unaligned, 5 27 2 plio_ffsb ptr unaligned, 5 28 2 plio_ssl ptr unaligned, 5 29 2 plio_fab2 ptr unaligned, 5 30 2 block_type bit (9) unaligned, 5 31 2 prefix bit (12) unaligned, 5 32 2 like_attribute bit (1) unaligned, 5 33 2 no_stack bit (1) unaligned, 5 34 2 get_data bit (1) unaligned, 5 35 2 flush_at_call bit (1) unaligned, 5 36 2 processed bit (1) unaligned, 5 37 2 text_displayed bit (1) unaligned, 5 38 2 number fixed bin (9) unsigned unaligned, 5 39 2 free_temps dimension (3) ptr, /* these fields are used by the code generator */ 5 40 2 temp_list ptr, 5 41 2 entry_list ptr, 5 42 2 o_and_s ptr, 5 43 2 why_nonquick aligned, 5 44 3 auto_adjustable_storage bit (1) unaligned, 5 45 3 returns_star_extents bit (1) unaligned, 5 46 3 stack_extended_by_args bit (1) unaligned, 5 47 3 invoked_by_format bit (1) unaligned, 5 48 3 format_statement bit (1) unaligned, 5 49 3 io_statements bit (1) unaligned, 5 50 3 assigned_to_entry_var bit (1) unaligned, 5 51 3 condition_statements bit (1) unaligned, 5 52 3 no_owner bit (1) unaligned, 5 53 3 recursive_call bit (1) unaligned, 5 54 3 options_non_quick bit (1) unaligned, 5 55 3 options_variable bit (1) unaligned, 5 56 3 never_referenced bit (1) unaligned, 5 57 3 pad_nonquick bit (5) unaligned, 5 58 2 prologue_flag bit (1) unaligned, 5 59 2 options_main bit (1) unaligned, 5 60 2 pad bit (16) unaligned, 5 61 2 number_of_entries fixed bin (17), 5 62 2 level fixed bin (17), 5 63 2 last_auto_loc fixed bin (17), 5 64 2 symbol_block fixed bin (17), 5 65 2 entry_info fixed bin (18), 5 66 2 enter structure unaligned, 5 67 3 start fixed bin (17), 5 68 3 end fixed bin (17), 5 69 2 leave structure unaligned, 5 70 3 start fixed bin (17), 5 71 3 end fixed bin (17), 5 72 2 owner ptr; 5 73 5 74 declare max_block_number fixed bin internal static options (constant) initial (511); 5 75 5 76 /* END INCLUDE FILE ... block.incl.pl1 */ 147 6 1 /* BEGIN INCLUDE FILE ... op_codes.incl.pl1 */ 6 2 6 3 /* Modified: 25 Apr 1979 by PCK 4-bit decimal */ 6 4 /* Modified: 6 Jun 1979 by PG to add rank and byte */ 6 5 /* Modified: 26 Dec 1979 by PCK to add assign_by_name */ 6 6 /* Modified: 26 July 82 BIM wordno, segno */ 6 7 6 8 dcl ( add initial("000010001"b), /* opnd(1) <- opnd(2)+opnd(3) */ 6 9 sub initial("000010010"b), /* opnd(1) <- opnd(2)-opnd(3) */ 6 10 mult initial("000010011"b), /* opnd(1) <- opnd(2)*opnd(3) */ 6 11 div initial("000010100"b), /* opnd(1) <- opnd(2)/opnd(3) */ 6 12 negate initial("000010101"b), /* opnd(1) <- -opnd(2) */ 6 13 exp initial("000010110"b), /* opnd(1) <- opnd(2) ** opnd(3) */ 6 14 6 15 and_bits initial("000100001"b), /* opnd(1) <- opnd(2) & opnd(3) */ 6 16 or_bits initial("000100010"b), /* opnd(1) <- opnd(2)|opnd(3) */ 6 17 xor_bits initial("000100011"b), /* opnd(1) <- opnd(2) xor opnd(3) */ 6 18 not_bits initial("000100100"b), /* opnd(1) <- ^opnd(2) */ 6 19 cat_string initial("000100101"b), /* opnd(1) <- opnd(2)||opnd(3) */ 6 20 bool_fun initial("000100110"b), /* opnd(1) <- bool(opnd(2),opnd(3),opnd(4)) */ 6 21 6 22 assign initial("000110001"b), /* opnd(1) <- opnd(2) */ 6 23 assign_size_ck initial("000110010"b), /* opnd(1) <- opnd(2) */ 6 24 assign_zero initial("000110011"b), /* opnd(1) <- 0 */ 6 25 copy_words initial("000110100"b), /* move opnd(2) to opnd(1) by opnd(3) words */ 6 26 copy_string initial("000110101"b), /* move opnd(2) to opnd(1) by opnd(3) units */ 6 27 make_desc initial("000110110"b), /* opnd(1) <- descriptor(opnd(2),opnd(3)) */ 6 28 assign_round initial("000110111"b), /* opnd(1) <- opnd(2) rounded */ 6 29 pack initial("000111000"b), /* opnd(1) <- encode to picture opnd(2) */ 6 30 unpack initial("000111001"b), /* opnd(1) <- decode from picture opnd(2) */ 6 31 6 32 less_than initial("001000100"b), /* opnd(1) <- opnd(2) < opnd(3) */ 6 33 greater_than initial("001000101"b), /* opnd(1) <- opnd(2) > opnd(3) */ 6 34 equal initial("001000110"b), /* opnd(1) <- opnd(2) = opnd(3) */ 6 35 not_equal initial("001000111"b), /* opnd(1) <- opnd(2) ^= opnd(3) */ 6 36 less_or_equal initial("001001000"b), /* opnd(1) <- opnd(2) <= opnd(3) */ 6 37 greater_or_equal initial("001001001"b), /* opnd(1) <- opnd(2) >= opnd(3) */ 6 38 6 39 jump initial("001010001"b), /* go to opnd(1) unconditionally */ 6 40 jump_true initial("001010010"b), /* go to opnd(1) if opnd(2) is not 0 */ 6 41 jump_false initial("001010011"b), /* go to opnd(1) if opnd(2) is all 0 */ 6 42 jump_if_lt initial("001010100"b), /* go to opnd(1) if opnd(2) < opnd(3) */ 6 43 jump_if_gt initial("001010101"b), /* go to opnd(1) if opnd(2) > opnd(3) */ 6 44 jump_if_eq initial("001010110"b), /* go to opnd(1) if opnd(2) = opnd(3) */ 6 45 jump_if_ne initial("001010111"b), /* go to opnd(1) if opnd(2) ^= opnd(3) */ 6 46 jump_if_le initial("001011000"b), /* go to opnd(1) if opnd(2) <= opnd(3) */ 6 47 jump_if_ge initial("001011001"b), /* go to opnd(1) if opnd(2) >= opnd(3) */ 6 48 6 49 std_arg_list initial("001100001"b), /* opnd(1) <- arglist(opnd(2) desclist(opnd(3))) */ 6 50 return_words initial("001100010"b), /* return aggregate opnd(1), opnd(2) is length in words */ 6 51 std_call initial("001100011"b), /* opnd(1) <- call opnd(2) with opnd(3) */ 6 52 return_bits initial("001100100"b), /* return aggregate opnd(1), opnd(2) is length in bits */ 6 53 std_entry initial("001100101"b), /* entry(opnd(1)... opnd(n)) */ 6 54 return_string initial("001100110"b), /* return string opnd(1) */ 6 55 ex_prologue initial("001100111"b), /* execute the prologue -no operands- */ 6 56 allot_auto initial("001101000"b), /* opnd(1) <- addrel(stack,opnd(2)) */ 6 57 param_ptr initial("001101001"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 6 58 param_desc_ptr initial("001101010"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 6 59 std_return initial("001101011"b), /* return -no arguments- */ 6 60 allot_ctl initial("001101100"b), /* allocate opnd(1) , length in words is opnd(2) */ 6 61 free_ctl initial("001101101"b), /* free opnd(1) */ 6 62 stop initial("001101110"b), /* stop - terminate run unit */ 6 63 6 64 mod_bit initial("001110000"b), /* opnd(1) <- mod(opnd(3),36), 6 65* opnd(2) <- opnd(3) / 36 */ 6 66 mod_byte initial("001110001"b), /* opnd(1) <- mod(opnd(3),4), 6 67* opnd(2) <- opnd(3) / 4 */ 6 68 mod_half initial("001110010"b), /* opnd(1) <- mod(opnd(3),2), 6 69* opnd(2) <- opnd(3) / 2 */ 6 70 mod_word initial("001110011"b), /* TO BE DEFINED BY BLW */ 6 71 6 72 bit_to_char initial("010000000"b), /* opnd(1) <- (opnd(2)+8)/9 */ 6 73 bit_to_word initial("010000001"b), /* opnd(1) <- (opnd(2)+35)/36 */ 6 74 char_to_word initial("010000010"b), /* opnd(1) <- (opnd(2)+3)/4 */ 6 75 half_to_word initial("010000011"b), /* opnd(1) <- (opnd(2)+1)/2 */ 6 76 word_to_mod2 initial("010000100"b), /* opnd(1) <- (opnd(2)+1)/2*2 */ 6 77 word_to_mod4 initial("010000101"b), /* opnd(1) <- (opnd(2)+3)/4*4 */ 6 78 word_to_mod8 initial("010000110"b), /* opnd(1) <- (opnd(2)+7)/8*8 */ 6 79 rel_fun initial("010000111"b), /* opnd(1) <- rel(opnd(2)) */ 6 80 baseno_fun initial("010001000"b), /* opnd(1) <- baseno(opnd(2)) */ 6 81 desc_size initial("010001001"b), /* opnd(1) <- substr(opnd(2),13,24) */ 6 82 bit_pointer initial("010001010"b), /* opnd(1) <- bit offset of opnd(2) */ 6 83 index_before_fun initial("010001011"b), /* opnd(1) <- length of before(opnd(2),opnd(3)) */ 6 84 index_after_fun initial("010001100"b), /* opnd(1) <- offset of after(opnd(2),opnd(3)) in opnd(2) */ 6 85 verify_ltrim_fun initial("010001101"b), /* opnd(1) <- offset of ltrim(opnd(2),opnd(3)) in opnd(2) */ 6 86 verify_rtrim_fun initial("010001110"b), /* opnd(1) <- length(opnd(2))-length(rtrim(opnd(2),opnd(3))) */ 6 87 digit_to_bit initial("010001111"b), /* opnd(1) <- 9*opnd(2)/2 */ 6 88 6 89 ceil_fun initial("010010000"b), /* opnd(1) <- ceil(opnd(2)) */ 6 90 floor_fun initial("010010001"b), /* opnd(1) <- floor(opnd(2)) */ 6 91 round_fun initial("010010010"b), /* opnd(1) <- round(opnd(2)) */ 6 92 sign_fun initial("010010011"b), /* opnd(1) <- sign(opnd(2)) */ 6 93 abs_fun initial("010010100"b), /* opnd(1) <- abs(opnd(2)) */ 6 94 trunc_fun initial("010010101"b), /* opnd(1) <- trunc(opnd(2)) */ 6 95 byte_fun initial("010010110"b), /* opnd(1) <- byte(opnd(2)) */ 6 96 rank_fun initial("010010111"b), /* opnd(1) <- rank(opnd(2)) */ 6 97 index_rev_fun initial("010011000"b), /* opnd(1) <- index(reverse(opnd(2)),reverse(opnd(3))) */ 6 98 search_rev_fun initial("010011001"b), /* opnd(1) <- search(reverse(opnd(2)),opnd(3)) */ 6 99 verify_rev_fun initial("010011010"b), /* opnd(1) <- verify(reverse(opnd(2)),opnd(3)) */ 6 100 wordno_fun initial("010011011"b), /* opnd(1) <- wordno (opnd(2)) */ 6 101 segno_fun initial("010011100"b), /* opnd(1) <- segno (opnd(2)) */ 6 102 bitno_fun initial("010011101"b), /* opnd(1) <- bitno (opnd(2)) */ 6 103 charno_fun initial("010011110"b), /* opnd(1) <- charno (opnd(2)) */ 6 104 6 105 index_fun initial("010100000"b), /* opnd(1) <- index(opnd(2),opnd(3)) */ 6 106 off_fun initial("010100001"b), /* opnd(1) <- offset(opnd(2),opnd(3)) */ 6 107 complex_fun initial("010100010"b), /* opnd(1) <- complex(opnd(2),opnd(3)) */ 6 108 conjg_fun initial("010100011"b), /* opnd(1) <- conjg(opnd(2),opnd(3)) */ 6 109 mod_fun initial("010100100"b), /* opnd(1) <- mod(opnd(2),opnd(3)) */ 6 110 repeat_fun initial("010100101"b), /* opnd(1) <- repeat(opnd(2),opnd(3)) */ 6 111 verify_fun initial("010100110"b), /* opnd(1) <- verify(opnd(2),opnd(3)) */ 6 112 translate_fun initial("010100111"b), /* opnd(1) <- translate(opnd(2),opnd(3))*/ 6 113 real_fun initial("010101001"b), /* opnd(1) <- real(opnd(2)) */ 6 114 imag_fun initial("010101010"b), /* opnd(1) <- imag(opnd(2)) */ 6 115 length_fun initial("010101011"b), /* opnd(1) <- length(opnd(2)) */ 6 116 pl1_mod_fun initial("010101100"b), /* opnd(1) <- mod(opnd(2)) */ 6 117 search_fun initial("010101101"b), /* opnd(1) <- search(opnd(2),opnd(3)) */ 6 118 allocation_fun initial("010101110"b), /* opnd(1) <- allocation(opnd(2)) */ 6 119 reverse_fun initial("010101111"b), /* opnd(1) <- reverse(opnd(2)) */ 6 120 6 121 addr_fun initial("010110000"b), /* opnd(1) <- addr(opnd(2)) */ 6 122 addr_fun_bits initial("010110001"b), /* opnd(1) <- addr(opnd(2)) */ 6 123 ptr_fun initial("010110010"b), /* opnd(1) <- ptr(opnd(2),opnd(3)) */ 6 124 baseptr_fun initial("010110011"b), /* opnd(1) <- baseptr(opnd(2)) */ 6 125 addrel_fun initial("010110100"b), /* opnd(1) <- addrel(opnd(2),opnd(3)) */ 6 126 codeptr_fun initial("010110101"b), /* opnd(1) <- codeptr(opnd(2)) */ 6 127 environmentptr_fun initial("010110110"b), /* opnd(1) <- environmentptr(opnd(2)) */ 6 128 stackbaseptr_fun initial("010110111"b), /* opnd(1) is ptr to base of current stack */ 6 129 stackframeptr_fun initial("010111000"b), /* opnd(1) is ptr to current block's stack frame */ 6 130 setcharno_fun initial("010111001"b), /* opnd(1) <- opnd(2) with charno opnd(3) */ 6 131 addcharno_fun initial("010111010"b), /* opnd(1) <- opnd(2) with charno = charno + opnd(3) */ 6 132 setbitno_fun initial("010111011"b), /* setcharno for bitsno */ 6 133 addbitno_fun initial("010111100"b), /* addcharno for bitno */ 6 134 6 135 min_fun initial("011000000"b), /* opnd(1) <- min(opnd(1),opnd(2),...) */ 6 136 max_fun initial("011000001"b), /* opnd(1) <- max(opnd(1),opnd(2),...) */ 6 137 6 138 stack_ptr initial("011010001"b), /* opnd(1) <- stack frame ptr */ 6 139 empty_area initial("011010010"b), /* empty opnd(1), length in words is opnd(2) */ 6 140 enable_on initial("011010100"b), /* opnd(1) is the cond name 6 141* opnd(2) is the file name 6 142* opnd(3) is the block */ 6 143 revert_on initial("011010101"b), /* opnd(1) is the cond name, 6 144* opnd(2) is the file name */ 6 145 signal_on initial("011010110"b), /* opnd(1) is the cond name 6 146* opnd(2) is the file name */ 6 147 6 148 lock_fun initial("011010111"b), /* opnd(1) <- stac(opnd(2),opnd(3)) */ 6 149 stacq_fun initial("011011000"b), /* opnd(1) is result, opnd(2) is ptr to lock word, 6 150* opnd(3) is old value, (4) is new value. */ 6 151 clock_fun initial("011011001"b), /* opnd(1) is the clock time */ 6 152 vclock_fun initial("011011010"b), /* opnd(1) is the virtual clock time */ 6 153 6 154 bound_ck initial("011100000"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 6 155 range_ck initial("011100001"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 6 156 loop initial("011100010"b), /* do opnd(1) for opnd(2) from opnd(3) to opnd(4) by 1, 6 157* opnd(5) is the list */ 6 158 join initial("011100011"b), /* do opnd(1), opnd(2) ... opnd(n) */ 6 159 allot_based initial("011100100"b), /* allocate opnd(2) words in opnd(3), set opnd(1) */ 6 160 free_based initial("011100101"b), /* free opnd(1) in opnd(3), length is opnd(2) words */ 6 161 6 162 r_parn initial("011110001"b), /* format op code */ 6 163 l_parn initial("011110010"b), 6 164 r_format initial("011110011"b), 6 165 c_format initial("011110100"b), 6 166 f_format initial("011110101"b), 6 167 e_format initial("011110110"b), 6 168 b_format initial("011110111"b), 6 169 a_format initial("011111000"b), 6 170 x_format initial("011111001"b), 6 171 skip_format initial("011111010"b), 6 172 column_format initial("011111011"b), 6 173 page_format initial("011111100"b), 6 174 line_format initial("011111101"b), 6 175 picture_format initial("011111110"b), 6 176 bn_format initial("011111111"b), /* bit format, length(opnd(2)), radix factor(opnd(3)) */ 6 177 6 178 get_list_trans initial("100000000"b), /* getlist(opnd(2) with desc(opnd(1))) */ 6 179 get_edit_trans initial("100000001"b), /* getedit(opnd(2) with desc(opnd(1))) */ 6 180 get_data_trans initial("100000010"b), /* getdata(opnd(1) to opnd(n)) */ 6 181 put_list_trans initial("100000011"b), /* putlist(opnd(2) with desc(opnd(1))) */ 6 182 put_edit_trans initial("100000100"b), /* putedit(opnd(2) with desc(opnd(1))) */ 6 183 put_data_trans initial("100000101"b), /* putdata(opnd(2)) with subscript-list opnd(1) */ 6 184 terminate_trans initial("100000110"b), /* terminate stream transmission */ 6 185 stream_prep initial("100000111"b), /* initiate stream transmission */ 6 186 record_io initial("100001000"b), /* perform record io operation */ 6 187 fortran_read initial("100001001"b), /* A complete read statement */ 6 188 fortran_write initial("100001010"b), /* A complete write statement */ 6 189 ftn_file_manip initial("100001011"b), /* endfile,backspace,rewind,etc. */ 6 190 ftn_trans_loop initial("100001100"b), /* An implied do in i/o list */ 6 191 put_control initial("100001101"b), /* put control opnd(1) opnd(2) times */ 6 192 put_field initial("100001110"b), /* putlist(opnd(2)) of length(opnd(1)) */ 6 193 put_field_chk initial("100001111"b), /* putlist(op(2)) of len(op(1)) check char index(op(3)) */ 6 194 6 195 /* These operators are produced by the parse but are not used as input to the code generator. */ 6 196 /* They are processed by the semantic translator. */ 6 197 6 198 return_value initial("100010010"b), /* return(opnd(1)) */ 6 199 allot_var initial("100010011"b), /* allot opnd(1) in opnd(2) */ 6 200 free_var initial("100010100"b), /* free opnd(1) out of opnd(2) */ 6 201 get_file initial("100010101"b), /* opnd(1) is filename,opnd(2) is copy */ 6 202 /* opnd(3) is skip, opnd(4) is list */ 6 203 get_string initial("100010110"b), /* opnd(1) is string,opnd(2) is list */ 6 204 put_file initial("100010111"b), /* opnd(1) is filename,opnd(2) is page */ 6 205 /* opnd(3) is skip,opnd(4) is line */ 6 206 put_string initial("100011000"b), /* opnd(1) is string,opnd(2) is list */ 6 207 open_file initial("100011001"b), 6 208 close_file initial("100011010"b), 6 209 read_file initial("100011011"b), 6 210 write_file initial("100011100"b), 6 211 locate_file initial("100011101"b), 6 212 do_fun initial("100011110"b), /* opnd(1) is join of a list */ 6 213 /* opnd(2) is control variable ref */ 6 214 /* opnd(3) is specification operator */ 6 215 do_spec initial("100011111"b), /* opnd(1) to opnd(2) by opnd(3) */ 6 216 /* repeat opnd(4) while opnd(5) */ 6 217 /* opnd(6) is next specification */ 6 218 6 219 rewrite_file initial("100100000"b), 6 220 delete_file initial("100100001"b), 6 221 unlock_file initial("100100010"b), 6 222 lock_file initial("100100011"b), 6 223 refer initial("100100101"b), /* opnd(1) refer(opnd(2)) */ 6 224 prefix_plus initial("100100110"b), /* opnd(1) <- +opnd(2) */ 6 225 nop initial("100100111"b), /* no-op */ 6 226 assign_by_name initial("100101000"b), /* opnd(1) <- opnd(2),by name */ 6 227 6 228 /* These operators are produced by the semantic translator in processing the math 6 229* builtin functions and are used as input to the code generator */ 6 230 6 231 sqrt_fun initial("100110000"b), /* opnd(1) <- sqrt(opnd(2)) */ 6 232 sin_fun initial("100110001"b), /* opnd(1) <- sin(opnd(2)) */ 6 233 sind_fun initial("100110010"b), /* opnd(1) <- sind(opnd(2)) */ 6 234 cos_fun initial("100110011"b), /* opnd(1) <- cos(opnd(2)) */ 6 235 cosd_fun initial("100110100"b), /* opnd(1) <- cosd(opnd(2)) */ 6 236 tan_fun initial("100110101"b), /* opnd(1) <- tan(opnd(2)) */ 6 237 tand_fun initial("100110110"b), /* opnd(1) <- tand(opnd(2)) */ 6 238 asin_fun initial("100110111"b), /* opnd(1) <- asin(opnd(2)) */ 6 239 asind_fun initial("100111000"b), /* opnd(1) <- asind(opnd(2)) */ 6 240 acos_fun initial("100111001"b), /* opnd(1) <- acos(opnd(2)) */ 6 241 acosd_fun initial("100111010"b), /* opnd(1) <- acosd(opnd(2)) */ 6 242 atan_fun initial("100111011"b), /* opnd(1) <- atan(opnd(2)[,opnd(3)]) */ 6 243 atand_fun initial("100111100"b), /* opnd(1) <- atand(opnd(2)[,opnd(3)]) */ 6 244 log2_fun initial("100111101"b), /* opnd(1) <- log2(opnd(2)) */ 6 245 log_fun initial("100111110"b), /* opnd(1) <- log(opnd(2)) */ 6 246 log10_fun initial("100111111"b), /* opnd(1) <- log10(opnd(2)) */ 6 247 6 248 exp_fun initial("101000000"b)) /* opnd(1) <- exp(opnd(2)) */ 6 249 6 250 bit(9) aligned internal static options(constant); 6 251 6 252 /* END INCLUDE FILE ... op_codes.incl.pl1 */ 148 7 1 dcl ( real_fix_bin_1 init(1), 7 2 real_fix_bin_2 init(2), 7 3 real_flt_bin_1 init(3), 7 4 real_flt_bin_2 init(4), 7 5 complex_fix_bin_1 init(5), 7 6 complex_fix_bin_2 init(6), 7 7 complex_flt_bin_1 init(7), 7 8 complex_flt_bin_2 init(8), 7 9 real_fix_dec init(9), 7 10 real_flt_dec init(10), 7 11 complex_fix_dec init(11), 7 12 complex_flt_dec init(12), 7 13 char_string init(13), 7 14 bit_string init(14), 7 15 label_constant init(15), 7 16 local_label_variable init(16), 7 17 label_variable init(17), 7 18 entry_variable init(18), 7 19 ext_entry_in init(19), 7 20 ext_entry_out init(20), 7 21 int_entry init(21), 7 22 int_entry_other init(22), 7 23 unpacked_ptr init(23), 7 24 packed_ptr init(24)) fixed bin(15) int static options(constant); 149 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 */ 150 9 1 /* BEGIN INCLUDE FILE ... machine_state.incl.pl1 */ 9 2 9 3 dcl cg_static_$m_s_p ptr ext static, 9 4 m_s_p ptr init(cg_static_$m_s_p); 9 5 9 6 dcl 1 machine_state aligned based(m_s_p), 9 7 2 node_type bit(9), 9 8 2 indicators fixed bin, 9 9 2 next ptr unal, 9 10 2 a_reg, 9 11 3 variable(10) ptr unal, 9 12 3 number fixed bin(17), 9 13 3 size fixed bin(8), 9 14 3 length fixed bin(8), 9 15 3 offset fixed bin(8), 9 16 3 constant fixed bin(24), 9 17 3 changed fixed bin(18), 9 18 3 instruction bit(36), 9 19 3 locked bit(1) aligned, 9 20 3 number_h_o fixed bin, 9 21 3 has_offset(3) ptr unal, 9 22 2 q_reg, 9 23 3 variable(10) ptr unal, 9 24 3 number fixed bin(17), 9 25 3 size fixed bin(8), 9 26 3 length fixed bin(8), 9 27 3 offset fixed bin(8), 9 28 3 constant fixed bin(24), 9 29 3 changed fixed bin(18), 9 30 3 instruction bit(36), 9 31 3 locked bit(1) aligned, 9 32 3 number_h_o fixed bin, 9 33 3 has_offset(3) ptr unal, 9 34 2 string_reg, 9 35 3 variable ptr unal, 9 36 3 size fixed bin(8), 9 37 3 offset fixed bin(8), 9 38 2 complex_reg, 9 39 3 variable ptr unal, 9 40 3 size fixed bin(8), 9 41 3 scale fixed bin(8), 9 42 2 decimal_reg, 9 43 3 variable ptr unal, 9 44 3 size fixed bin(8), 9 45 3 scale fixed bin(8), 9 46 2 index_regs(0:7), 9 47 3 variable ptr unal, 9 48 3 constant fixed bin, 9 49 3 type fixed bin(8), 9 50 3 used fixed bin(18), 9 51 3 changed fixed bin(18), 9 52 3 instruction bit(36), 9 53 3 filler fixed bin, 9 54 2 base_regs(0:7), 9 55 3 variable ptr unal, 9 56 3 constant fixed bin, 9 57 3 type fixed bin(8), 9 58 3 pad (12) fixed bin, /* future...room to make 5 element array for variable, constant, type */ 9 59 3 number fixed bin (17), /* future...number of valid elements in array */ 9 60 3 used fixed bin(18), 9 61 3 changed fixed bin(18), 9 62 3 instruction bit(36), 9 63 3 locked fixed bin(2), 9 64 2 indicators_ref(2:3) ptr unal; 9 65 9 66 /* Permissible values for machine_state.indicators. */ 9 67 9 68 dcl ( ind_known_refs init (-2), /* set by comparison of known, nonzero, references */ 9 69 ind_invalid init (-1), 9 70 ind_string_aq init (0), /* logical value in storage */ 9 71 ind_logical init (1), /* logical value in A or AQ */ 9 72 ind_arithmetic init (2), /* arith value in Q, AQ, or EAQ */ 9 73 ind_x (0:7) init (6, 7, 8, 9, 10, 11, 12, 13), 9 74 ind_decimal_reg init (14) 9 75 ) fixed bin internal static options (constant); 9 76 9 77 /* END INCLUDE FILE ... machine_state.incl.pl1 */ 151 10 1 dcl bases(0:7) bit(3) aligned int static init("000"b, "010"b, "100"b, "001"b, "011"b, "101"b, "111"b,"110"b) 10 2 options(constant); 10 3 10 4 dcl ( ap defined(bases(0)), 10 5 bp defined(bases(1)), 10 6 lp defined(bases(2)), 10 7 sp defined(bases(7))) bit(3) aligned; 10 8 10 9 dcl ( ab defined(bases(3)), 10 10 bb defined(bases(4)), 10 11 lb defined(bases(5)), 10 12 sb defined(bases(6))) bit(3) aligned; 10 13 10 14 dcl which_base(0:7) fixed bin int static init(0,3,1,4,2,5,7,6) options(constant); 152 11 1 /* BEGIN INCLUDE FILE ... temporary.incl.pl1 */ 11 2 11 3 dcl 1 temporary based, 11 4 2 node_type bit(9), /* type is "000001010"b */ 11 5 2 size fixed bin(18), 11 6 2 next ptr, 11 7 2 location fixed bin(18), 11 8 2 ref_count fixed bin, 11 9 2 symbol ptr unal, 11 10 2 last_freed fixed bin(18); 11 11 11 12 /* END INCLUDE FILE ... temporary.incl.pl1 */ 153 154 155 p = pt; 156 p2 = p -> operand (2); 157 158 159 op_code = p -> operator.op_code; 160 161 if op_code = param_ptr 162 then do; 163 i = 0; 164 165 goto l4; 166 end; 167 168 if op_code = param_desc_ptr 169 then do; 170 i = 1; 171 172 l4: 173 ref (1) = prepare_operand ((p -> operand (1)), 1, atom (1)); 174 175 base = 176 base_man$load_arg_ptr (i, (p -> operand (3)), 177 p2 -> reference.symbol -> symbol.initial -> fix_bin); 178 179 ibase = which_base (fixed (base, 3)); 180 goto to_core; 181 end; 182 183 if op_code >= ptr_fun 184 then n = 1; 185 else n = -1; 186 187 do i = 1 to p -> operator.number; 188 ref (i) = prepare_operand ((p -> operand (i)), n, atom (i)); 189 end; 190 191 if op_code = setcharno_fun 192 then call NO_FUNS (SETCHARNO); 193 else if op_code = addcharno_fun 194 then call NO_FUNS (ADDCHARNO); 195 else if op_code = setbitno_fun 196 then call NO_FUNS (SETBITNO); 197 else if op_code = addbitno_fun 198 then call NO_FUNS (ADDBITNO); /* these dont return here */ 199 200 if op_code = addr_fun 201 then do; 202 203 if ^atom (2) 204 then if p2 -> node.type = operator_node 205 then ref (2) = compile_exp$save (p2); 206 /* make addr (expression) work, invalid though it is */ 207 208 adjust, in_base = "0"b; /* of interest only in the varying case */ 209 210 if ref (2) -> reference.varying_ref 211 then do; 212 adjust = "1"b; 213 call adjust_c_offset (-1); 214 end; 215 216 ibase = which_base (bin (base_man$load_any_var (2, ref (2)), 3)); 217 218 if adjust 219 then call reset_c_offset (-1); 220 221 ref (2) -> reference.address_in.b (ibase) = "0"b; 222 /* we cannot remember both addr (ref (2)) and ref (1). */ 223 base_regs (ibase).variable = null; 224 base_regs (ibase).type = 0; 225 to_core: 226 if ref (1) -> reference.allocate 227 then if store_it 228 then call base_to_core (ibase, ref (1)); 229 else ; 230 else call state_man$flush_ref (ref (1)); 231 232 if ibase ^= 7 /* protect pr6 from optimization for stackframeptr */ 233 then call base_man$update_base (1, ref (1), ibase); 234 else call state_man$flush_ref (ref (1)); 235 236 ref (1) -> reference.evaluated = "1"b; /* Cannot be shared at this point */ 237 done: 238 cg_stat$temp_ref = ref (1); 239 return; 240 end; 241 242 if op_code = addr_fun_bits 243 then do; 244 245 if ^atom (2) 246 then if p2 -> node.type = operator_node 247 then ref (2) = compile_exp$save (p2); 248 /* see above */ 249 250 ref (1) -> reference.ref_count = ref (1) -> reference.ref_count + 1; 251 last_freed = 0; 252 if ref (1) -> reference.temp_ref 253 then if ref (1) -> reference.qualifier ^= null 254 then last_freed = ref (1) -> reference.qualifier -> temporary.last_freed; 255 256 if store_it 257 then call store_bit_address (ref (1), ref (2), last_freed); 258 else begin; 259 declare base_bits bit (3) aligned; 260 base_bits = base_man$load_any_var (2 /* addr */, ref (2)); 261 call base_man$update_base (1, ref (1), (which_base (fixed (base_bits, 3)))); 262 end; 263 goto done; 264 end; 265 266 if op_code = ptr_fun 267 then do; 268 269 if ref (2) -> reference.symbol -> symbol.ptr 270 then do; 271 272 /* this is Multics version of ptr builtin */ 273 /* The ref count must be bumped here because the optimiser */ 274 /* does not know that we hit the output temp twice -- once */ 275 /* when we compile it, once when we load it. */ 276 277 if ^atom (2) 278 then if p2 -> node.type = operator_node 279 then do; 280 call adjust_ref_count ((p2 -> operator.operand (1)), +1); 281 call compile_exp (p2); 282 ref (2) = p2 -> operator.operand (1); 283 end; 284 285 if ref (3) -> reference.offset ^= null 286 then goto l1; 287 if ref (3) -> reference.c_offset ^= 0 288 then goto l1; 289 290 s3 = ref (3) -> reference.symbol; 291 if s3 -> symbol.constant 292 then 293 Multics_POINTER_CONSTANT: 294 do; 295 ibase = get_base (); 296 mac_1 = pointer_mac_const (ibase); 297 goto c0; 298 end; 299 300 goto l1; 301 end; 302 303 /* this is PL/1 version of ptr builtin */ 304 305 306 if ^atom (2) 307 then ref (2) = compile_exp$save (p2); 308 309 call load (ref (2), 0); 310 311 q = ref (3) -> reference.symbol; 312 if q -> symbol.internal & (q -> symbol.auto | q -> symbol.static) 313 then macro = pl1_pointer_easy; 314 else macro = pl1_pointer_hard; 315 316 call base_man$load_var (2, ref (3), 1); 317 318 call expmac$zero (macro + ref (1) -> reference.data_type - unpacked_ptr); 319 320 ref (2) -> reference.address_in.b (1) = "0"b; 321 base_regs (1).variable = null; 322 base_regs (1).type = 0; 323 324 /* next 3 lines necessary because store won't always update state */ 325 326 q_reg.variable (1) = ref (1); 327 q_reg.number = 1; 328 ref (1) -> reference.value_in.q = "1"b; 329 330 if ref (1) -> reference.allocate & store_it 331 then call store (ref (1)); 332 333 else do; 334 if ^ref (1) -> reference.allocate 335 then call state_man$flush_ref (ref (1)); 336 337 q_reg.variable (1) = ref (1); 338 q_reg.number = 1; 339 ref (1) -> reference.value_in.q = "1"b; 340 end; 341 342 call base_man$update_base (1, ref (1), 1); 343 344 goto done; 345 end; 346 347 if op_code = addrel_fun 348 then do; 349 350 if ^atom (2) 351 then if p2 -> node.type = operator_node 352 then do; 353 call adjust_ref_count ((p2 -> operator.operand (1)), 1); 354 /* we will call base_man, which costs an extra ref_count hit */ 355 call compile_exp (p2); 356 ref (2) = p2 -> operator.operand (1); 357 end; 358 359 if ref (3) -> reference.offset ^= null 360 then goto l1; 361 if ref (3) -> reference.c_offset ^= 0 362 then goto l1; 363 364 s3 = ref (3) -> reference.symbol; 365 if ^s3 -> symbol.constant 366 then goto l1; 367 368 ibase = get_base (); 369 mac_1 = addrel_mac_const (ibase); 370 371 c0: 372 q = s3 -> symbol.initial; 373 374 if ref (3) -> reference.data_type = bit_string 375 then do; 376 if ref (3) -> reference.long_ref 377 then goto l1; 378 if ref (3) -> reference.c_length > 18 379 then goto l1; 380 end; 381 else if abs (q -> fix_bin) >= 131072 382 then goto l1; 383 384 old_changed = base_regs (ibase).changed; 385 386 call base_man$load_var (1, ref (2), ibase); 387 ref (2) -> reference.value_in.b (ibase) = "0"b; 388 base_regs (ibase).variable = null; 389 base_regs (ibase).type = 0; 390 n = base_regs (ibase).changed; 391 392 if op_code = ptr_fun 393 then if q -> fix_bin = 0 & n ^= old_changed 394 then do; 395 q = addrel (cg_stat$text_base, n); 396 q -> instruction.op_code = epbx (ibase); 397 base_regs (ibase).instruction = string (q -> instruction); 398 goto to_core; 399 end; 400 401 402 call expmac$zero (mac_1); 403 404 p = addrel (cg_stat$text_base, cg_stat$text_pos - 1); 405 406 if ref (3) -> reference.data_type = bit_string 407 then p -> left = q -> left; 408 else do; 409 if q -> fix_bin >= 0 410 then p -> left = bit (fixed (q -> fix_bin, 18), 18); 411 else p -> left = bit (fixed (262144 + q -> fix_bin, 18), 18); 412 end; 413 414 goto to_core; 415 416 l1: 417 if atom (3) 418 then call load (ref (3), 0); 419 else call compile_exp ((p -> operand (3))); 420 421 if ref (3) -> reference.long_ref 422 then call expmac$zero ((longbs_to_bs18)); 423 424 ibase = get_base (); 425 if op_code = ptr_fun 426 then macro = pointer_mac_fx (ibase); 427 else macro = addrel_mac_fx (ibase); 428 429 old_changed = base_regs (ibase).changed; 430 431 call base_man$load_var (1, ref (2), ibase); 432 ref (2) -> reference.value_in.b (ibase) = "0"b; 433 base_regs (ibase).variable = null; 434 base_regs (ibase).type = 0; 435 436 if op_code ^= addrel_fun 437 then do; 438 l2a: 439 call expmac$zero (macro - fixed (ref (3) -> reference.data_type = bit_string, 1)); 440 goto to_core; 441 end; 442 443 n = base_regs (ibase).changed; 444 if n = old_changed 445 then go to l2a; 446 q = addrel (cg_stat$text_base, n); 447 448 if q -> instruction.tag = "000000"b 449 then do; 450 if ref (3) -> reference.data_type = bit_string 451 then do; 452 if a_reg.changed > n 453 then go to l2a; 454 q -> instruction.tag = "000001"b; 455 /* au */ 456 end; 457 else do; 458 if q_reg.changed > n 459 then go to l2a; 460 q -> instruction.tag = "000110"b; 461 /* ql */ 462 end; 463 go to set_inst; 464 end; 465 466 if q -> instruction.tag ^= "010000"b 467 then goto l2a; 468 469 if ref (3) -> reference.data_type = bit_string 470 then do; 471 if a_reg.changed > n 472 then goto l2a; 473 q -> instruction.tag = "110001"b; 474 /* *au */ 475 end; 476 else do; 477 if q_reg.changed > n 478 then goto l2a; 479 q -> instruction.tag = "110110"b; 480 /* *ql */ 481 end; 482 set_inst: 483 base_regs (ibase).instruction = string (q -> instruction); 484 call expmac$zero ((zero_bo (ibase))); 485 goto to_core; 486 end; 487 488 if op_code = baseptr_fun 489 then do; 490 491 if atom (2) 492 then call load (ref (2), 0); 493 else call compile_exp ((p -> operand (2))); 494 if p -> operator.operand (2) -> node.type = operator_node 495 then ref (2) = p -> operator.operand (2) -> operator.operand (1); 496 497 ibase = get_base (); 498 macro = baseptr_mac_fx (ibase); 499 ref (3) = ref (2); 500 501 goto l2a; 502 end; 503 504 if op_code = stackframeptr_fun 505 then do; 506 if ref (1) -> reference.allocate & store_it 507 then do; 508 ibase = which_base (6); 509 goto to_core; 510 end; 511 512 ref (2) = c_a (0, 4); 513 514 ibase = get_base (); 515 516 call base_man$load_var (2, ref (2), ibase); 517 518 ref (2) -> reference.address_in.b (ibase) = "0"b; 519 base_regs (ibase).variable = null; 520 base_regs (ibase).type = 0; 521 goto to_core; 522 end; 523 524 if op_code = stackbaseptr_fun 525 then do; 526 ref (2) = c_a (0, 4); 527 528 ibase = get_base (); 529 530 old_changed = base_regs (ibase).changed; 531 532 call base_man$load_var (2, ref (2), ibase); 533 ref (2) -> reference.address_in.b (ibase) = "0"b; 534 base_regs (ibase).variable = null; 535 base_regs (ibase).type = 0; 536 n = base_regs (ibase).changed; 537 538 if n ^= old_changed 539 then do; 540 q = addrel (cg_stat$text_base, n); 541 q -> instruction.op_code = epbx (ibase); 542 base_regs (ibase).instruction = string (q -> instruction); 543 goto to_core; 544 end; 545 546 call expmac$zero ((pointer_mac_const (ibase))); 547 goto to_core; 548 end; 549 550 if op_code = codeptr_fun 551 then do; 552 553 if ^atom (2) 554 then ref (2) = compile_exp$save (p2); 555 ibase = get_base (); 556 type2 = ref (2) -> reference.data_type; 557 558 if type2 = label_constant | (ext_entry_in <= type2 & type2 <= int_entry_other) 559 then do; /* process label, format, and entry constants */ 560 call base_man$load_var (2, ref (2), ibase); 561 ref (2) -> reference.address_in.b (ibase) = "0"b; 562 end; 563 else do; /* process label, format, and entry variables */ 564 call base_man$load_var (1, ref (2), ibase); 565 ref (2) -> reference.value_in.b (ibase) = "0"b; 566 end; 567 568 base_regs (ibase).variable = null; 569 base_regs (ibase).type = 0; 570 goto to_core; 571 572 end; 573 574 if op_code = environmentptr_fun 575 then do; 576 if ^atom (2) 577 then ref (2) = compile_exp$save (p2); 578 type2 = ref (2) -> reference.data_type; 579 580 if type2 = ext_entry_in | type2 = ext_entry_out 581 then do; /* process external entry constants */ 582 ref (2) = generate_constant$bit_string (cg_stat$null_value, (bits_per_two_words)); 583 ref (2) -> reference.data_type = unpacked_ptr; 584 ibase = get_base (); 585 call base_man$load_var (1, ref (2), ibase); 586 ref (2) -> reference.value_in.b (ibase) = "0"b; 587 base_regs (ibase).variable = null; 588 base_regs (ibase).type = 0; 589 end; 590 591 else if type2 = label_constant | type2 = int_entry | type2 = int_entry_other 592 then do; /* process label, format, and internal entry constants */ 593 b2 = ref (2) -> reference.symbol -> symbol.block_node; 594 if cg_stat$cur_level = b2 -> block.level 595 then do; 596 if ref (1) -> reference.allocate & store_it 597 then do; 598 ibase = which_base (6); 599 goto to_core; 600 end; 601 602 ref (2) = c_a (0, 4); 603 ibase = get_base (); 604 call base_man$load_var (2, ref (2), ibase); 605 ref (2) -> reference.address_in.b (ibase) = "0"b; 606 end; 607 else do; 608 call base_man$load_display (cg_stat$cur_level - b2 -> block.level, base); 609 ibase = which_base (fixed (base, 3)); 610 end; 611 end; 612 613 else do; /* process label, format, and entry variables */ 614 ibase = get_base (); 615 call adjust_c_offset (2); 616 call base_man$load_var (1, ref (2), ibase); 617 call reset_c_offset (2); 618 base_regs (ibase).variable = null; 619 base_regs (ibase).type = 0; 620 621 end; 622 623 goto to_core; 624 625 end; 626 627 err: 628 call cg_error (301, fixed (op_code, 9)); 629 630 631 get_base: 632 proc returns (fixed bin (15)); 633 634 dcl i fixed bin (15); 635 dcl ( 636 first_base init (3), 637 last_base init (6) 638 ) fixed bin (15) int static; 639 640 /* all these functions destroy the PR containing op (2). If this */ 641 /* is of the form a = OP (a, ...) then this is fine, or if we */ 642 /* have no other use for a. Otherwise, copy a into another PR */ 643 /* to keep the original value around */ 644 645 if string (ref (2) -> reference.value_in.b) 646 then if ref (2) -> reference.ref_count = 1 | ref (1) = ref (2) 647 then return (index (string (ref (2) -> reference.value_in.b), "1"b) - 1); 648 else ; 649 else if ref (2) -> reference.data_type >= unpacked_ptr 650 then do; 651 652 /* m_a can load pointer regs */ 653 654 call m_a (ref (2), "00"b); 655 ref (2) -> reference.perm_address = "1"b; 656 /* base_man will turn off */ 657 end; 658 659 do i = 1, first_base to last_base; 660 if base_regs (i).type = 0 661 then return (i); 662 else if base_regs (i).type <= 2 663 then if base_regs (i).variable -> reference.hit_zero | ^base_regs (i).variable -> reference.allocate 664 then return (i); 665 end; 666 667 return (1); 668 end; 669 670 adjust_c_offset: 671 proc (adjust_offset); 672 673 dcl adjust_offset fixed bin; 674 675 ref (2) -> reference.c_offset = ref (2) -> reference.c_offset + adjust_offset; 676 677 if string (ref (2) -> reference.address_in.b) 678 then do; 679 if ref (2) -> reference.address.offset ^= (15)"0"b 680 then call m_a (ref (2), "00"b); 681 call state_man$flush_address (ref (2)); 682 in_base = "1"b; 683 if adjust_offset >= 0 684 then ref (2) -> address.offset = bit (fixed (adjust_offset, 15), 15); 685 else ref (2) -> address.offset = bit (fixed (adjust_offset + 32768, 15), 15); 686 ref (2) -> reference.perm_address = "1"b; 687 ref (2) -> reference.no_address = "0"b; 688 end; 689 else in_base = "0"b; 690 691 end; 692 693 reset_c_offset: 694 proc (adjust_offset); 695 696 dcl adjust_offset fixed bin; 697 698 ref (2) -> reference.c_offset = ref (2) -> reference.c_offset - adjust_offset; 699 700 if in_base 701 then do; 702 ref (2) -> address.offset = (15)"0"b; 703 ref (2) -> reference.perm_address = "0"b; 704 end; 705 706 end; 707 708 709 /* The following uses a different approach from the rest of this program */ 710 /* to avoid the piles and piles of macros used by the pointer and addrel */ 711 /* cases, or the patching of instructions, this just uses a locked base register */ 712 /* to avoid the problem of a pointer qualified second argument */ 713 714 NO_FUNS: 715 procedure (Funx); 716 declare Funx fixed bin; 717 declare base_man$load_var_and_lock 718 entry (fixed bin, ptr, fixed bin (15)); 719 declare base_man$unlock entry (fixed bin (15)); 720 721 declare q pointer; 722 723 declare expmac entry (fixed bin (15), pointer); 724 declare base_bits bit (3) aligned; 725 declare s3_constant bit (1) aligned; 726 declare constant_zero bit (1) aligned; 727 declare constant_value fixed bin (24); 728 declare based_fb_24 fixed bin (24) based; 729 730 declare MACRO (4) fixed bin (15) init (373, 373, 374, 374) int static options (constant); 731 declare binary builtin; 732 733 734 s3_constant = "0"b; /* until proven guilty */ 735 736 s3 = ref (3) -> reference.symbol; /* prepare_operand made ref (3) the output operand if its non-atomic */ 737 if s3 -> symbol.constant 738 then do; 739 s3_constant = "1"b; 740 constant_value = s3 -> symbol.initial -> based_fb_24; 741 end; 742 743 constant_zero = s3_constant & constant_value = 0; 744 745 if constant_zero 746 then if Funx = ADDCHARNO | Funx = ADDBITNO 747 then do; 748 ibase = get_base (); /* find the var in a base */ 749 call base_man$load_var (1, ref (2), ibase); 750 /* in case it was in no register yet */ 751 go to to_core; /* and return it there */ 752 end; 753 754 if ^atom (2) 755 then call compile_exp (p2); 756 757 if s3_constant 758 then do; /* if even number of words, optimize */ 759 if constant_zero 760 then call CONVERT_TO_POINTER_CONSTANT (0); 761 if Funx = SETCHARNO & mod (constant_value, 4) = 0 762 then call CONVERT_TO_POINTER_CONSTANT (divide (constant_value, 4, 24, 0)); 763 else if Funx = SETBITNO & mod (constant_value, 36) = 0 764 then call CONVERT_TO_POINTER_CONSTANT (divide (constant_value, 36, 24, 0)); 765 end; 766 767 q = c_a (0, 1); /* get a constant ref node */ 768 769 ibase = get_base (); 770 base_bits = bases (ibase); 771 call base_man$load_var_and_lock (1, ref (2), ibase); 772 /* will just find and lock if get_base loaded */ 773 774 /* This code could call aq_man$load_any_var, and then set the modifier */ 775 /* on the instruction appropriately. */ 776 777 if ^atom (3) /* atomize 3 */ 778 then call compile_exp ((p -> operator.operand (3))); 779 else call load (ref (3), 0); /* dont negate */ 780 781 q -> reference.address.base = base_bits; 782 q -> reference.address.tag = "06"b3; /* QL */ 783 q -> reference.relocation = ""b; 784 785 if Funx = ADDCHARNO | Funx = ADDBITNO /* add... */ 786 then q -> reference.address.ext_base = "1"b; /* turn on bit 29 */ 787 call expmac (MACRO (Funx), q); 788 call base_man$unlock (ibase); 789 machine_state.base_regs (ibase).variable = null (); 790 machine_state.base_regs (ibase).type = 0; 791 ref (2) -> reference.value_in.b (ibase) = "0"b; 792 go to to_core; /* store if that is the right thing, then return. */ 793 794 CONVERT_TO_POINTER_CONSTANT: 795 procedure (Word_offset); 796 declare Word_offset fixed bin (24); 797 declare declare_constant ext entry (bit (*) aligned, bit (36) aligned, fixed bin (31), fixed bin (31)) 798 returns (pointer); 799 declare size fixed bin (31); 800 declare value bit (36) aligned; 801 declare substr builtin; 802 12 1 /* BEGIN INCLUDE FILE ... mask.incl.pl1 */ 12 2 12 3 dcl ( structure_mask init("100000000000000000000000000000000000"b), 12 4 fixed_mask init("010000000000000000000000000000000000"b), 12 5 float_mask init("001000000000000000000000000000000000"b), 12 6 bit_mask init("000100000000000000000000000000000000"b), 12 7 char_mask init("000010000000000000000000000000000000"b), 12 8 ptr_mask init("000001000000000000000000000000000000"b), 12 9 offset_mask init("000000100000000000000000000000000000"b), 12 10 area_mask init("000000010000000000000000000000000000"b), 12 11 label_mask init("000000001000000000000000000000000000"b), 12 12 entry_mask init("000000000100000000000000000000000000"b), 12 13 file_mask init("000000000010000000000000000000000000"b), 12 14 arg_descriptor_mask init("000000000001000000000000000000000000"b), 12 15 storage_block_mask init("000000000000100000000000000000000000"b), 12 16 lock_mask init("000000000000010000000000000000000000"b), 12 17 condition_mask init("000000000000001000000000000000000000"b), 12 18 format_mask init("000000000000000100000000000000000000"b), 12 19 builtin_mask init("000000000000000010000000000000000000"b), 12 20 generic_mask init("000000000000000001000000000000000000"b), 12 21 picture_mask init("000000000000000000100000000000000000"b), 12 22 dimensioned_mask init("000000000000000000010000000000000000"b), 12 23 initialed_mask init("000000000000000000001000000000000000"b), 12 24 aligned_mask init("000000000000000000000100000000000000"b), 12 25 unaligned_mask init("000000000000000000000010000000000000"b), 12 26 signed_mask init("000000000000000000000001000000000000"b), 12 27 unsigned_mask init("000000000000000000000000100000000000"b), 12 28 precision_mask init("000000000000000000000000010000000000"b), 12 29 varying_mask init("000000000000000000000000001000000000"b), 12 30 local_mask init("000000000000000000000000000100000000"b), 12 31 decimal_mask init("000000000000000000000000000010000000"b), 12 32 binary_mask init("000000000000000000000000000001000000"b), 12 33 real_mask init("000000000000000000000000000000100000"b), 12 34 complex_mask init("000000000000000000000000000000010000"b), 12 35 variable_mask init("000000000000000000000000000000001000"b), 12 36 reducible_mask init("000000000000000000000000000000000100"b), 12 37 irreducible_mask init("000000000000000000000000000000000010"b), 12 38 returns_mask init("000000000000000000000000000000000001"b)) bit(36) aligned int static 12 39 options(constant); 12 40 12 41 dcl ( arithmetic_mask init("011000000000000000000000000011110000"b), 12 42 computational_mask init("011110000000000000100000000011110000"b), 12 43 fixed_binary_real_mask init("010000000000000000000000000001100000"b), 12 44 fixed_decimal_real_mask init("010000000000000000000000000010100000"b), 12 45 float_decimal_real_mask init("001000000000000000000000000010100000"b), 12 46 fixed_decimal_complex_mask init("010000000000000000000000000010010000"b), 12 47 float_decimal_complex_mask init("001000000000000000000000000010010000"b), 12 48 string_mask init("000110000000000000000000000000000000"b), 12 49 undesirable_mask init("111111111111111111100111110111110111"b), 12 50 convert_mask init("011111111111111111100111110111111110"b), 12 51 declare_constant_mask init("111111111111111111100000000011110000"b) 12 52 ) bit(36) aligned int static 12 53 options(constant); 12 54 12 55 /* END INCLUDE FILE ... mask.incl.pl1 */ 803 804 805 /***** This procedure does not patch the tree. Perhaps a better way */ 806 /* would be for something in the semantics to detect these cases, and */ 807 /* have it make the tree start out as pointer (foo, bar), but I */ 808 /* don't know how to do that, and I do know how to do this. --BIM */ 809 810 op_code = ptr_fun; 811 812 size = 18; 813 value = unspec (Word_offset); 814 815 ref (3) = declare_constant (value, fixed_binary_real_mask | unsigned_mask, size, 0); 816 s3 = ref (3) -> reference.symbol; /* global depended on */ 817 go to Multics_POINTER_CONSTANT; 818 end CONVERT_TO_POINTER_CONSTANT; 819 820 821 end NO_FUNS; 822 823 end pointer_builtins; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/03/83 1009.1 pointer_builtins.pl1 >spec>on>pl128d>pointer_builtins.pl1 143 1 10/25/79 1645.8 cgsystem.incl.pl1 >ldd>include>cgsystem.incl.pl1 144 2 07/21/80 1546.3 operator.incl.pl1 >ldd>include>operator.incl.pl1 145 3 07/21/80 1546.3 reference.incl.pl1 >ldd>include>reference.incl.pl1 146 4 10/02/83 0828.4 symbol.incl.pl1 >spec>on>pl128d>symbol.incl.pl1 147 5 08/13/81 2043.5 block.incl.pl1 >ldd>include>block.incl.pl1 148 6 04/07/83 1635.0 op_codes.incl.pl1 >ldd>include>op_codes.incl.pl1 149 7 05/03/76 1320.4 data_types.incl.pl1 >ldd>include>data_types.incl.pl1 150 8 07/21/80 1546.3 nodes.incl.pl1 >ldd>include>nodes.incl.pl1 151 9 11/13/79 1015.8 machine_state.incl.pl1 >ldd>include>machine_state.incl.pl1 152 10 05/03/76 1320.8 bases.incl.pl1 >ldd>include>bases.incl.pl1 153 11 11/30/78 1227.4 temporary.incl.pl1 >ldd>include>temporary.incl.pl1 803 12 11/30/78 1227.5 mask.incl.pl1 >ldd>include>mask.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. ADDBITNO constant fixed bin(17,0) initial dcl 100 set ref 197* 745 785 ADDCHARNO constant fixed bin(17,0) initial dcl 100 set ref 193* 745 785 Funx parameter fixed bin(17,0) dcl 716 ref 714 745 745 761 763 785 785 787 MACRO 000001 constant fixed bin(15,0) initial array dcl 730 set ref 787* SETBITNO constant fixed bin(17,0) initial dcl 100 set ref 195* 763 SETCHARNO constant fixed bin(17,0) initial dcl 100 set ref 191* 761 Word_offset parameter fixed bin(24,0) dcl 796 ref 794 813 a_reg 3 based structure level 2 dcl 9-6 abs builtin function dcl 107 ref 381 addbitno_fun constant bit(9) initial dcl 6-8 ref 197 addcharno_fun constant bit(9) initial dcl 6-8 ref 193 addr_fun constant bit(9) initial dcl 6-8 ref 200 addr_fun_bits constant bit(9) initial dcl 6-8 ref 242 addrel builtin function dcl 107 ref 395 404 446 540 addrel_fun constant bit(9) initial dcl 6-8 ref 347 436 addrel_mac_const 000065 constant fixed bin(15,0) initial array dcl 125 ref 369 addrel_mac_fx 000043 constant fixed bin(15,0) initial array dcl 125 ref 427 address 10 based structure level 2 packed unaligned dcl 3-3 address_in 11 based structure level 3 packed unaligned dcl 3-3 adjust 000134 automatic bit(1) dcl 42 set ref 208* 212* 218 adjust_offset parameter fixed bin(17,0) dcl 696 in procedure "reset_c_offset" ref 693 698 adjust_offset parameter fixed bin(17,0) dcl 673 in procedure "adjust_c_offset" ref 670 675 683 683 685 adjust_ref_count 000022 constant entry external dcl 69 ref 280 353 allocate 12(14) based bit(1) level 3 packed unaligned dcl 3-3 ref 225 330 334 506 596 662 atom 000131 automatic bit(1) array dcl 42 set ref 172* 188* 203 245 277 306 350 416 491 553 576 754 777 attributes 31 based structure level 2 dcl 4-3 auto 32(09) based bit(1) level 4 packed unaligned dcl 4-3 ref 312 b 11 based bit(1) array level 4 in structure "reference" packed unaligned dcl 3-3 in procedure "pointer_builtins" set ref 221* 320* 518* 533* 561* 605* 677 b 11(15) based bit(1) array level 4 in structure "reference" packed unaligned dcl 3-3 in procedure "pointer_builtins" set ref 387* 432* 565* 586* 645 645 791* b2 000116 automatic pointer dcl 42 set ref 593* 594 608 base 10 based bit(3) level 3 in structure "reference" packed unaligned dcl 3-3 in procedure "pointer_builtins" set ref 781* base 000127 automatic bit(3) dcl 42 in procedure "pointer_builtins" set ref 175* 179 608* 609 base_bits 000161 automatic bit(3) dcl 259 in begin block on line 258 set ref 260* 261 base_bits 000222 automatic bit(3) dcl 724 in procedure "NO_FUNS" set ref 770* 781 base_man$load_any_var 000024 constant entry external dcl 70 ref 216 260 base_man$load_arg_ptr 000044 constant entry external dcl 81 ref 175 base_man$load_display 000046 constant entry external dcl 83 ref 608 base_man$load_var 000040 constant entry external dcl 72 ref 316 386 431 516 532 560 564 585 604 616 749 base_man$load_var_and_lock 000074 constant entry external dcl 717 ref 771 base_man$unlock 000076 constant entry external dcl 719 ref 788 base_man$update_base 000042 constant entry external dcl 72 ref 232 261 342 base_regs 160 based structure array level 2 dcl 9-6 base_to_core 000052 constant entry external dcl 87 ref 225 based_fb_24 based fixed bin(24,0) dcl 728 ref 740 baseptr_fun constant bit(9) initial dcl 6-8 ref 488 baseptr_mac_fx 000035 constant fixed bin(15,0) initial array dcl 125 ref 498 bases 000015 constant bit(3) initial array dcl 10-1 ref 770 bit builtin function dcl 107 ref 409 411 683 685 bit_string constant fixed bin(15,0) initial dcl 7-1 ref 374 406 438 450 469 bits 12(06) based structure level 2 packed unaligned dcl 3-3 bits_per_two_words constant fixed bin(8,0) initial dcl 1-5 ref 582 block based structure level 1 dcl 5-5 block_node 4 based pointer level 2 packed unaligned dcl 4-3 ref 593 c_a 000034 constant entry external dcl 72 ref 512 526 602 767 c_length 2 based fixed bin(24,0) level 2 dcl 3-3 ref 378 c_offset 1 based fixed bin(24,0) level 2 dcl 3-3 set ref 287 361 675* 675 698* 698 cg_error 000070 constant entry external dcl 94 ref 627 cg_stat$cur_level 000020 external static fixed bin(17,0) dcl 61 ref 594 608 cg_stat$null_value 000016 external static bit(72) dcl 61 set ref 582* cg_stat$temp_ref 000010 external static pointer dcl 61 set ref 237* cg_stat$text_base 000012 external static pointer dcl 61 ref 395 404 446 540 cg_stat$text_pos 000014 external static fixed bin(17,0) dcl 61 ref 404 cg_static_$m_s_p 000072 external static pointer dcl 9-3 ref 9-3 changed 50 based fixed bin(18,0) level 3 in structure "machine_state" dcl 9-6 in procedure "pointer_builtins" ref 458 477 changed 22 based fixed bin(18,0) level 3 in structure "machine_state" dcl 9-6 in procedure "pointer_builtins" ref 452 471 changed 201 based fixed bin(18,0) array level 3 in structure "machine_state" dcl 9-6 in procedure "pointer_builtins" ref 384 390 429 443 530 536 codeptr_fun constant bit(9) initial dcl 6-8 ref 550 compile_exp 000032 constant entry external dcl 72 ref 281 355 419 493 754 777 compile_exp$save 000030 constant entry external dcl 72 ref 203 245 306 553 576 constant 32(16) based bit(1) level 4 packed unaligned dcl 4-3 ref 291 365 737 constant_value 000225 automatic fixed bin(24,0) dcl 727 set ref 740* 743 761 761 761 763 763 763 constant_zero 000224 automatic bit(1) dcl 726 set ref 743* 745 759 data_type 31 based structure level 3 in structure "symbol" packed unaligned dcl 4-3 in procedure "pointer_builtins" data_type 12 based fixed bin(5,0) level 2 in structure "reference" packed unaligned dcl 3-3 in procedure "pointer_builtins" set ref 318 374 406 438 450 469 556 578 583* 649 declare_constant 000102 constant entry external dcl 797 ref 815 environmentptr_fun constant bit(9) initial dcl 6-8 ref 574 epbx 000025 constant bit(10) initial array dcl 139 ref 396 541 evaluated 12(13) based bit(1) level 3 packed unaligned dcl 3-3 set ref 236* expmac 000100 constant entry external dcl 723 ref 787 expmac$zero 000064 constant entry external dcl 87 ref 318 402 421 438 484 546 ext_base 10(29) based bit(1) level 3 packed unaligned dcl 3-3 set ref 785* ext_entry_in constant fixed bin(15,0) initial dcl 7-1 ref 558 580 ext_entry_out constant fixed bin(15,0) initial dcl 7-1 ref 580 first_base constant fixed bin(15,0) initial dcl 635 ref 659 fix_bin based fixed bin(17,0) dcl 110 set ref 175* 381 392 409 409 411 fixed builtin function dcl 107 ref 179 261 409 411 438 609 627 627 683 685 fixed_binary_real_mask 000000 constant bit(36) initial dcl 12-41 ref 815 generate_constant$bit_string 000050 constant entry external dcl 83 ref 582 half based structure level 1 dcl 114 hit_zero 12(20) based bit(1) level 3 packed unaligned dcl 3-3 ref 662 i 000120 automatic fixed bin(15,0) dcl 42 in procedure "pointer_builtins" set ref 163* 170* 175* 187* 188 188 188* i 000170 automatic fixed bin(15,0) dcl 634 in procedure "get_base" set ref 659* 660 660 662 662 662 662* ibase 000121 automatic fixed bin(15,0) dcl 42 set ref 179* 216* 221 223 224 225* 232 232* 295* 296 368* 369 384 386* 387 388 389 390 396 397 424* 425 427 429 431* 432 433 434 443 482 484 497* 498 508* 514* 516* 518 519 520 528* 530 532* 533 534 535 536 541 542 546 555* 560* 561 564* 565 568 569 584* 585* 586 587 588 598* 603* 604* 605 609* 614* 616* 618 619 748* 749* 769* 770 771* 788* 789 790 791 in_base 000135 automatic bit(1) dcl 42 set ref 208* 682* 689* 700 index builtin function dcl 107 ref 645 info 11 based structure level 2 packed unaligned dcl 3-3 initial 11 based pointer level 2 packed unaligned dcl 4-3 ref 175 371 740 instruction based structure level 1 dcl 118 in procedure "pointer_builtins" set ref 397 482 542 instruction 202 based bit(36) array level 3 in structure "machine_state" dcl 9-6 in procedure "pointer_builtins" set ref 397* 482* 542* int_entry constant fixed bin(15,0) initial dcl 7-1 ref 591 int_entry_other constant fixed bin(15,0) initial dcl 7-1 ref 558 591 internal 32(01) based bit(1) level 4 packed unaligned dcl 4-3 ref 312 label_constant constant fixed bin(15,0) initial dcl 7-1 ref 558 591 last_base constant fixed bin(15,0) initial dcl 635 ref 659 last_freed 7 based fixed bin(18,0) level 2 in structure "temporary" dcl 11-3 in procedure "pointer_builtins" ref 252 last_freed 000126 automatic fixed bin(18,0) dcl 42 in procedure "pointer_builtins" set ref 251* 252* 256* left based bit(18) level 2 packed unaligned dcl 114 set ref 406* 406 409* 411* level 45 based fixed bin(17,0) level 2 dcl 5-5 ref 594 608 load 000036 constant entry external dcl 72 ref 309 416 491 779 long_ref 12(08) based bit(1) level 3 packed unaligned dcl 3-3 ref 376 421 longbs_to_bs18 constant fixed bin(15,0) initial dcl 125 ref 421 m_a 000066 constant entry external dcl 94 ref 654 679 m_s_p 000140 automatic pointer initial dcl 9-3 set ref 223 224 321 322 326 327 337 338 384 388 389 390 397 429 433 434 443 452 458 471 477 482 519 520 530 534 535 536 542 568 569 587 588 618 619 9-3* 660 662 662 662 789 790 mac_1 000123 automatic fixed bin(15,0) dcl 42 set ref 296* 369* 402* machine_state based structure level 1 dcl 9-6 macro 000122 automatic fixed bin(15,0) dcl 42 set ref 312* 314* 318 425* 427* 438 498* misc_attributes 31(19) based structure level 3 packed unaligned dcl 4-3 n 000124 automatic fixed bin(15,0) dcl 42 set ref 183* 185* 188* 390* 392 395 443* 444 446 452 458 471 477 536* 538 540 no_address 10(27) based bit(1) level 3 packed unaligned dcl 3-3 set ref 687* node based structure level 1 dcl 8-27 null builtin function dcl 107 ref 223 252 285 321 359 388 433 519 534 568 587 618 789 number 43 based fixed bin(17,0) level 3 in structure "machine_state" dcl 9-6 in procedure "pointer_builtins" set ref 327* 338* number 0(21) based fixed bin(14,0) level 2 in structure "operator" packed unaligned dcl 2-6 in procedure "pointer_builtins" ref 187 offset 5 based pointer level 2 in structure "reference" packed unaligned dcl 3-3 in procedure "pointer_builtins" ref 285 359 offset 10(03) based bit(15) level 3 in structure "reference" packed unaligned dcl 3-3 in procedure "pointer_builtins" set ref 679 683* 685* 702* old_changed 000125 automatic fixed bin(15,0) dcl 42 set ref 384* 392 429* 444 530* 538 op_code 0(09) based bit(9) level 2 in structure "operator" packed unaligned dcl 2-6 in procedure "pointer_builtins" ref 159 op_code 000130 automatic bit(9) dcl 42 in procedure "pointer_builtins" set ref 159* 161 168 183 191 193 195 197 200 242 266 347 392 425 436 488 504 524 550 574 627 627 810* op_code 0(18) based bit(10) level 2 in structure "instruction" packed unaligned dcl 118 in procedure "pointer_builtins" set ref 396* 541* operand 1 based pointer array level 2 packed unaligned dcl 2-6 ref 156 172 175 188 280 282 353 356 419 493 494 494 494 777 operator based structure level 1 dcl 2-6 operator_node constant bit(9) initial dcl 8-5 ref 203 245 277 350 494 p 000100 automatic pointer dcl 42 set ref 155* 156 159 172 175 187 188 404* 406 409 411 419 493 494 494 777 p2 000104 automatic pointer dcl 42 set ref 156* 175 203 203* 245 245* 277 280 281* 282 306* 350 353 355* 356 553* 576* 754* param_desc_ptr constant bit(9) initial dcl 6-8 ref 168 param_ptr constant bit(9) initial dcl 6-8 ref 161 perm_address 12(18) based bit(1) level 3 packed unaligned dcl 3-3 set ref 655* 686* 703* pl1_pointer_easy constant fixed bin(15,0) initial dcl 125 ref 312 pl1_pointer_hard constant fixed bin(15,0) initial dcl 125 ref 314 pointer_mac_const 000073 constant fixed bin(15,0) initial array dcl 125 ref 296 546 pointer_mac_fx 000051 constant fixed bin(15,0) initial array dcl 125 ref 425 prepare_operand 000026 constant entry external dcl 72 ref 172 188 pt parameter pointer dcl 39 ref 36 155 ptr 31(05) based bit(1) level 4 packed unaligned dcl 4-3 ref 269 ptr_fun constant bit(9) initial dcl 6-8 ref 183 266 392 425 810 q 000220 automatic pointer dcl 721 in procedure "NO_FUNS" set ref 767* 781 782 783 785 787* q 000102 automatic pointer dcl 42 in procedure "pointer_builtins" set ref 311* 312 312 312 371* 381 392 395* 396 397 406 409 409 411 446* 448 454 460 466 473 479 482 540* 541 542 q 11(10) based bit(1) level 4 in structure "reference" packed unaligned dcl 3-3 in procedure "pointer_builtins" set ref 328* 339* q_reg 31 based structure level 2 dcl 9-6 qualifier 4 based pointer level 2 packed unaligned dcl 3-3 ref 252 252 ref 000110 automatic pointer array dcl 42 set ref 172* 188* 203* 210 216* 221 225 225* 230* 232* 234* 236 237 245* 250 250 252 252 252 256* 256* 260* 261* 269 282* 285 287 290 306* 309* 311 316* 318 320 326 328 330 330* 334 334* 337 339 342* 356* 359 361 364 374 376 378 386* 387 406 416* 421 431* 432 438 450 469 491* 494* 499* 499 506 512* 516* 518 526* 532* 533 553* 556 560* 561 564* 565 576* 578 582* 583 585* 586 593 596 602* 604* 605 616* 645 645 645 645 645 649 654* 655 675 675 677 679 679* 681* 683 685 686 687 698 698 702 703 736 749* 771* 779* 791 815* 816 ref_count 0(18) based fixed bin(17,0) level 2 packed unaligned dcl 3-3 set ref 250* 250 645 reference based structure level 1 dcl 3-3 relocation 12(24) based bit(12) level 2 packed unaligned dcl 3-3 set ref 783* s3 000106 automatic pointer dcl 42 set ref 290* 291 364* 365 371 736* 737 740 816* s3_constant 000223 automatic bit(1) dcl 725 set ref 734* 739* 743 757 setbitno_fun constant bit(9) initial dcl 6-8 ref 195 setcharno_fun constant bit(9) initial dcl 6-8 ref 191 size 000234 automatic fixed bin(31,0) dcl 799 set ref 812* 815* stackbaseptr_fun constant bit(9) initial dcl 6-8 ref 524 stackframeptr_fun constant bit(9) initial dcl 6-8 ref 504 state_man$flush_address 000054 constant entry external dcl 87 ref 681 state_man$flush_ref 000056 constant entry external dcl 87 ref 230 234 334 static 32(11) based bit(1) level 4 packed unaligned dcl 4-3 ref 312 storage_class 32(09) based structure level 3 packed unaligned dcl 4-3 store 000062 constant entry external dcl 87 ref 330 store_bit_address 000060 constant entry external dcl 87 ref 256 store_it parameter bit(1) dcl 39 ref 36 225 256 330 506 596 string builtin function dcl 107 ref 397 482 542 645 645 677 symbol based structure level 1 dcl 4-3 in procedure "pointer_builtins" symbol 3 based pointer level 2 in structure "reference" packed unaligned dcl 3-3 in procedure "pointer_builtins" ref 175 269 290 311 364 593 736 816 tag 0(30) based bit(6) level 2 in structure "instruction" packed unaligned dcl 118 in procedure "pointer_builtins" set ref 448 454* 460* 466 473* 479* tag 10(30) based bit(6) level 3 in structure "reference" packed unaligned dcl 3-3 in procedure "pointer_builtins" set ref 782* temp_ref 12(11) based bit(1) level 3 packed unaligned dcl 3-3 ref 252 temporary based structure level 1 unaligned dcl 11-3 type based bit(9) level 2 in structure "node" packed unaligned dcl 8-27 in procedure "pointer_builtins" ref 203 245 277 350 494 type 162 based fixed bin(8,0) array level 3 in structure "machine_state" dcl 9-6 in procedure "pointer_builtins" set ref 224* 322* 389* 434* 520* 535* 569* 588* 619* 660 662 790* type2 000136 automatic fixed bin(17,0) dcl 94 set ref 556* 558 558 558 578* 580 580 591 591 591 unpacked_ptr constant fixed bin(15,0) initial dcl 7-1 ref 318 583 649 unsigned_mask constant bit(36) initial dcl 12-3 ref 815 value 000235 automatic bit(36) dcl 800 set ref 813* 815* value_in 11(09) based structure level 3 packed unaligned dcl 3-3 variable 31 based pointer array level 3 in structure "machine_state" packed unaligned dcl 9-6 in procedure "pointer_builtins" set ref 326* 337* variable 160 based pointer array level 3 in structure "machine_state" packed unaligned dcl 9-6 in procedure "pointer_builtins" set ref 223* 321* 388* 433* 519* 534* 568* 587* 618* 662 662 789* varying_ref 0(10) based bit(1) level 2 packed unaligned dcl 3-3 ref 210 which_base 000005 constant fixed bin(17,0) initial array dcl 10-14 ref 179 216 261 508 598 609 zero_bo 000057 constant fixed bin(15,0) initial array dcl 125 ref 484 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. a_format internal static bit(9) initial dcl 6-8 ab defined bit(3) dcl 10-9 abs_fun internal static bit(9) initial dcl 6-8 acos_fun internal static bit(9) initial dcl 6-8 acosd_fun internal static bit(9) initial dcl 6-8 add internal static bit(9) initial dcl 6-8 aligned_mask internal static bit(36) initial dcl 12-3 allocation_fun internal static bit(9) initial dcl 6-8 allot_auto internal static bit(9) initial dcl 6-8 allot_based internal static bit(9) initial dcl 6-8 allot_ctl internal static bit(9) initial dcl 6-8 allot_var internal static bit(9) initial dcl 6-8 and_bits internal static bit(9) initial dcl 6-8 ap defined bit(3) dcl 10-4 area_mask internal static bit(36) initial dcl 12-3 arg_descriptor_mask internal static bit(36) initial dcl 12-3 arithmetic_mask internal static bit(36) initial dcl 12-41 array_node internal static bit(9) initial dcl 8-5 asin_fun internal static bit(9) initial dcl 6-8 asind_fun internal static bit(9) initial dcl 6-8 assign internal static bit(9) initial dcl 6-8 assign_by_name internal static bit(9) initial dcl 6-8 assign_round internal static bit(9) initial dcl 6-8 assign_size_ck internal static bit(9) initial dcl 6-8 assign_zero internal static bit(9) initial dcl 6-8 atan_fun internal static bit(9) initial dcl 6-8 atand_fun internal static bit(9) initial dcl 6-8 b_format internal static bit(9) initial dcl 6-8 baseno_fun internal static bit(9) initial dcl 6-8 bb defined bit(3) dcl 10-9 binary builtin function dcl 731 binary_mask internal static bit(36) initial dcl 12-3 bit_mask internal static bit(36) initial dcl 12-3 bit_pointer internal static bit(9) initial dcl 6-8 bit_to_char internal static bit(9) initial dcl 6-8 bit_to_word internal static bit(9) initial dcl 6-8 bitno_fun internal static bit(9) initial dcl 6-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_word internal static fixed bin(8,0) initial dcl 1-5 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 6-8 bool_fun internal static bit(9) initial dcl 6-8 bound_ck internal static bit(9) initial dcl 6-8 bound_node internal static bit(9) initial dcl 8-5 bp defined bit(3) dcl 10-4 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 builtin_mask internal static bit(36) initial dcl 12-3 by_name_agg_node internal static bit(9) initial dcl 8-5 byte_fun internal static bit(9) initial dcl 6-8 c_format internal static bit(9) initial dcl 6-8 cat_string internal static bit(9) initial dcl 6-8 ceil_fun internal static bit(9) initial dcl 6-8 cg_stat$cur_statement external static pointer dcl 97 char_mask internal static bit(36) initial dcl 12-3 char_string internal static fixed bin(15,0) initial dcl 7-1 char_to_word internal static bit(9) initial dcl 6-8 charno_fun internal static bit(9) initial dcl 6-8 chars_per_word internal static fixed bin(8,0) initial dcl 1-5 clock_fun internal static bit(9) initial dcl 6-8 close_file internal static bit(9) initial dcl 6-8 column_format internal static bit(9) initial dcl 6-8 complex_fix_bin_1 internal static fixed bin(15,0) initial dcl 7-1 complex_fix_bin_2 internal static fixed bin(15,0) initial dcl 7-1 complex_fix_dec internal static fixed bin(15,0) initial dcl 7-1 complex_flt_bin_1 internal static fixed bin(15,0) initial dcl 7-1 complex_flt_bin_2 internal static fixed bin(15,0) initial dcl 7-1 complex_flt_dec internal static fixed bin(15,0) initial dcl 7-1 complex_fun internal static bit(9) initial dcl 6-8 complex_mask internal static bit(36) initial dcl 12-3 computational_mask internal static bit(36) initial dcl 12-41 condition_mask internal static bit(36) initial dcl 12-3 conjg_fun internal static bit(9) initial dcl 6-8 context_node internal static bit(9) initial dcl 8-5 convert_mask internal static bit(36) initial dcl 12-41 convert_offset internal static fixed bin(8,1) initial array dcl 1-35 convert_size internal static fixed bin(8,0) initial array dcl 1-5 copy_string internal static bit(9) initial dcl 6-8 copy_words internal static bit(9) initial dcl 6-8 cos_fun internal static bit(9) initial dcl 6-8 cosd_fun internal static bit(9) initial dcl 6-8 cross_reference_node internal static bit(9) initial dcl 8-5 decimal_mask internal static bit(36) initial dcl 12-3 declare_constant_mask internal static bit(36) initial dcl 12-41 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 6-8 desc_size internal static bit(9) initial dcl 6-8 digit_to_bit internal static bit(9) initial dcl 6-8 dimensioned_mask internal static bit(36) initial dcl 12-3 div internal static bit(9) initial dcl 6-8 do_fun internal static bit(9) initial dcl 6-8 do_spec internal static bit(9) initial dcl 6-8 e_format internal static bit(9) initial dcl 6-8 empty_area internal static bit(9) initial dcl 6-8 enable_on internal static bit(9) initial dcl 6-8 entry_mask internal static bit(36) initial dcl 12-3 entry_variable internal static fixed bin(15,0) initial dcl 7-1 equal internal static bit(9) initial dcl 6-8 ex_prologue internal static bit(9) initial dcl 6-8 exp internal static bit(9) initial dcl 6-8 exp_fun internal static bit(9) initial dcl 6-8 f_format internal static bit(9) initial dcl 6-8 file_mask internal static bit(36) initial dcl 12-3 fixed_decimal_complex_mask internal static bit(36) initial dcl 12-41 fixed_decimal_real_mask internal static bit(36) initial dcl 12-41 fixed_mask internal static bit(36) initial dcl 12-3 float_decimal_complex_mask internal static bit(36) initial dcl 12-41 float_decimal_real_mask internal static bit(36) initial dcl 12-41 float_mask internal static bit(36) initial dcl 12-3 floor_fun internal static bit(9) initial dcl 6-8 format_mask internal static bit(36) initial dcl 12-3 format_value_node internal static bit(9) initial dcl 8-5 fortran_read internal static bit(9) initial dcl 6-8 fortran_write internal static bit(9) initial dcl 6-8 free_based internal static bit(9) initial dcl 6-8 free_ctl internal static bit(9) initial dcl 6-8 free_var internal static bit(9) initial dcl 6-8 ftn_file_manip internal static bit(9) initial dcl 6-8 ftn_trans_loop internal static bit(9) initial dcl 6-8 generic_mask internal static bit(36) initial dcl 12-3 get_data_trans internal static bit(9) initial dcl 6-8 get_edit_trans internal static bit(9) initial dcl 6-8 get_file internal static bit(9) initial dcl 6-8 get_list_trans internal static bit(9) initial dcl 6-8 get_string internal static bit(9) initial dcl 6-8 greater_or_equal internal static bit(9) initial dcl 6-8 greater_than internal static bit(9) initial dcl 6-8 half_to_word internal static bit(9) initial dcl 6-8 imag_fun internal static bit(9) initial dcl 6-8 ind_arithmetic internal static fixed bin(17,0) initial dcl 9-68 ind_decimal_reg internal static fixed bin(17,0) initial dcl 9-68 ind_invalid internal static fixed bin(17,0) initial dcl 9-68 ind_known_refs internal static fixed bin(17,0) initial dcl 9-68 ind_logical internal static fixed bin(17,0) initial dcl 9-68 ind_string_aq internal static fixed bin(17,0) initial dcl 9-68 ind_x internal static fixed bin(17,0) initial array dcl 9-68 index_after_fun internal static bit(9) initial dcl 6-8 index_before_fun internal static bit(9) initial dcl 6-8 index_fun internal static bit(9) initial dcl 6-8 index_rev_fun internal static bit(9) initial dcl 6-8 initialed_mask internal static bit(36) initial dcl 12-3 irreducible_mask internal static bit(36) initial dcl 12-3 join internal static bit(9) initial dcl 6-8 jump internal static bit(9) initial dcl 6-8 jump_false internal static bit(9) initial dcl 6-8 jump_if_eq internal static bit(9) initial dcl 6-8 jump_if_ge internal static bit(9) initial dcl 6-8 jump_if_gt internal static bit(9) initial dcl 6-8 jump_if_le internal static bit(9) initial dcl 6-8 jump_if_lt internal static bit(9) initial dcl 6-8 jump_if_ne internal static bit(9) initial dcl 6-8 jump_true internal static bit(9) initial dcl 6-8 l_parn internal static bit(9) initial dcl 6-8 label_array_element_node internal static bit(9) initial dcl 8-5 label_mask internal static bit(36) initial dcl 12-3 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 7-1 lb defined bit(3) dcl 10-9 ldfx2 internal static fixed bin(15,0) initial dcl 112 length_fun internal static bit(9) initial dcl 6-8 less_or_equal internal static bit(9) initial dcl 6-8 less_than internal static bit(9) initial dcl 6-8 line_format internal static bit(9) initial dcl 6-8 list_node internal static bit(9) initial dcl 8-5 local_label_variable internal static fixed bin(15,0) initial dcl 7-1 local_mask internal static bit(36) initial dcl 12-3 locate_file internal static bit(9) initial dcl 6-8 lock_file internal static bit(9) initial dcl 6-8 lock_fun internal static bit(9) initial dcl 6-8 lock_mask internal static bit(36) initial dcl 12-3 log10_fun internal static bit(9) initial dcl 6-8 log2_fun internal static bit(9) initial dcl 6-8 log_fun internal static bit(9) initial dcl 6-8 loop internal static bit(9) initial dcl 6-8 lp defined bit(3) dcl 10-4 machine_state_node internal static bit(9) initial dcl 8-5 make_desc internal static bit(9) initial dcl 6-8 max_block_number internal static fixed bin(17,0) initial dcl 5-74 max_dec_scale internal static fixed bin(8,0) initial dcl 1-5 max_fun internal static bit(9) initial dcl 6-8 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_number_of_operands internal static fixed bin(15,0) initial dcl 2-15 max_offset internal static fixed bin(8,0) initial array dcl 1-5 max_p_fix_bin_1 internal static fixed bin(8,0) initial 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 min_dec_scale internal static fixed bin(8,0) initial dcl 1-5 min_fun internal static bit(9) initial dcl 6-8 mod_bit internal static bit(9) initial dcl 6-8 mod_byte internal static bit(9) initial dcl 6-8 mod_fun internal static bit(9) initial dcl 6-8 mod_half internal static bit(9) initial dcl 6-8 mod_word internal static bit(9) initial dcl 6-8 mult internal static bit(9) initial dcl 6-8 negate internal static bit(9) initial dcl 6-8 nop internal static bit(9) initial dcl 6-8 not_bits internal static bit(9) initial dcl 6-8 not_equal internal static bit(9) initial dcl 6-8 off_fun internal static bit(9) initial dcl 6-8 offset_mask internal static bit(36) initial dcl 12-3 open_file internal static bit(9) initial dcl 6-8 or_bits internal static bit(9) initial dcl 6-8 pack internal static bit(9) initial dcl 6-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 7-1 page_format internal static bit(9) initial dcl 6-8 picture_format internal static bit(9) initial dcl 6-8 picture_mask internal static bit(36) initial dcl 12-3 pl1_mod_fun internal static bit(9) initial dcl 6-8 precision_mask internal static bit(36) initial dcl 12-3 prefix_plus internal static bit(9) initial dcl 6-8 ptr_mask internal static bit(36) initial dcl 12-3 put_control internal static bit(9) initial dcl 6-8 put_data_trans internal static bit(9) initial dcl 6-8 put_edit_trans internal static bit(9) initial dcl 6-8 put_field internal static bit(9) initial dcl 6-8 put_field_chk internal static bit(9) initial dcl 6-8 put_file internal static bit(9) initial dcl 6-8 put_list_trans internal static bit(9) initial dcl 6-8 put_string internal static bit(9) initial dcl 6-8 r_format internal static bit(9) initial dcl 6-8 r_parn internal static bit(9) initial dcl 6-8 range_ck internal static bit(9) initial dcl 6-8 rank_fun internal static bit(9) initial dcl 6-8 read_file internal static bit(9) initial dcl 6-8 real_fix_bin_1 internal static fixed bin(15,0) initial dcl 7-1 real_fix_bin_2 internal static fixed bin(15,0) initial dcl 7-1 real_fix_dec internal static fixed bin(15,0) initial dcl 7-1 real_flt_bin_1 internal static fixed bin(15,0) initial dcl 7-1 real_flt_bin_2 internal static fixed bin(15,0) initial dcl 7-1 real_flt_dec internal static fixed bin(15,0) initial dcl 7-1 real_fun internal static bit(9) initial dcl 6-8 real_mask internal static bit(36) initial dcl 12-3 record_io internal static bit(9) initial dcl 6-8 reducible_mask internal static bit(36) initial dcl 12-3 refer internal static bit(9) initial dcl 6-8 reference_node internal static bit(9) initial dcl 8-5 rel_fun internal static bit(9) initial dcl 6-8 repeat_fun internal static bit(9) initial dcl 6-8 return_bits internal static bit(9) initial dcl 6-8 return_string internal static bit(9) initial dcl 6-8 return_value internal static bit(9) initial dcl 6-8 return_words internal static bit(9) initial dcl 6-8 returns_mask internal static bit(36) initial dcl 12-3 reverse_fun internal static bit(9) initial dcl 6-8 revert_on internal static bit(9) initial dcl 6-8 rewrite_file internal static bit(9) initial dcl 6-8 round_fun internal static bit(9) initial dcl 6-8 sb defined bit(3) dcl 10-9 search_fun internal static bit(9) initial dcl 6-8 search_rev_fun internal static bit(9) initial dcl 6-8 segno_fun internal static bit(9) initial dcl 6-8 sf_par_node internal static bit(9) initial dcl 8-5 sign_fun internal static bit(9) initial dcl 6-8 signal_on internal static bit(9) initial dcl 6-8 signed_mask internal static bit(36) initial dcl 12-3 sin_fun internal static bit(9) initial dcl 6-8 sind_fun internal static bit(9) initial dcl 6-8 skip_format internal static bit(9) initial dcl 6-8 source_node internal static bit(9) initial dcl 8-5 sp defined bit(3) dcl 10-4 sqrt_fun internal static bit(9) initial dcl 6-8 stack_ptr internal static bit(9) initial dcl 6-8 stacq_fun internal static bit(9) initial dcl 6-8 statement_node internal static bit(9) initial dcl 8-5 std_arg_list internal static bit(9) initial dcl 6-8 std_call internal static bit(9) initial dcl 6-8 std_entry internal static bit(9) initial dcl 6-8 std_return internal static bit(9) initial dcl 6-8 stop internal static bit(9) initial dcl 6-8 storage_block_mask internal static bit(36) initial dcl 12-3 stream_prep internal static bit(9) initial dcl 6-8 string_mask internal static bit(36) initial dcl 12-41 structure_mask internal static bit(36) initial dcl 12-3 sub internal static bit(9) initial dcl 6-8 substr builtin function dcl 801 symbol_node internal static bit(9) initial dcl 8-5 tan_fun internal static bit(9) initial dcl 6-8 tand_fun internal static bit(9) initial dcl 6-8 temporary_node internal static bit(9) initial dcl 8-5 terminate_trans internal static bit(9) initial dcl 6-8 token_node internal static bit(9) initial dcl 8-5 translate_fun internal static bit(9) initial dcl 6-8 trunc_fun internal static bit(9) initial dcl 6-8 unaligned_mask internal static bit(36) initial dcl 12-3 undesirable_mask internal static bit(36) initial dcl 12-41 units_per_word internal static fixed bin(8,0) initial array dcl 1-5 unlock_file internal static bit(9) initial dcl 6-8 unpack internal static bit(9) initial dcl 6-8 variable_mask internal static bit(36) initial dcl 12-3 varying_mask internal static bit(36) initial dcl 12-3 vclock_fun internal static bit(9) initial dcl 6-8 verify_fun internal static bit(9) initial dcl 6-8 verify_ltrim_fun internal static bit(9) initial dcl 6-8 verify_rev_fun internal static bit(9) initial dcl 6-8 verify_rtrim_fun internal static bit(9) initial dcl 6-8 word_to_mod2 internal static bit(9) initial dcl 6-8 word_to_mod4 internal static bit(9) initial dcl 6-8 word_to_mod8 internal static bit(9) initial dcl 6-8 wordno_fun internal static bit(9) initial dcl 6-8 write_file internal static bit(9) initial dcl 6-8 x_format internal static bit(9) initial dcl 6-8 xor_bits internal static bit(9) initial dcl 6-8 NAMES DECLARED BY EXPLICIT CONTEXT. CONVERT_TO_POINTER_CONSTANT 003241 constant entry internal dcl 794 ref 759 761 763 Multics_POINTER_CONSTANT 000712 constant label dcl 291 set ref 817 NO_FUNS 002750 constant entry internal dcl 714 ref 191 193 195 197 adjust_c_offset 002636 constant entry internal dcl 670 ref 213 615 c0 001200 constant label dcl 371 ref 297 done 000503 constant label dcl 237 ref 263 344 err 002465 constant label dcl 627 get_base 002503 constant entry internal dcl 631 ref 295 368 424 497 514 528 555 584 603 614 748 769 l1 001360 constant label dcl 416 ref 285 287 300 359 361 365 376 378 381 l2a 001503 constant label dcl 438 ref 444 452 458 466 471 477 501 l4 000156 constant label dcl 172 ref 165 pointer_builtins 000124 constant entry external dcl 36 reset_c_offset 002734 constant entry internal dcl 693 ref 218 617 set_inst 001605 constant label dcl 482 ref 463 to_core 000417 constant label dcl 225 ref 180 398 414 440 485 509 521 543 547 570 599 623 751 792 NAMES DECLARED BY CONTEXT OR IMPLICATION. bin builtin function ref 216 divide builtin function ref 761 761 763 763 mod builtin function ref 761 763 unspec builtin function ref 813 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3720 4024 3363 3730 Length 4520 3363 104 460 335 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME pointer_builtins 252 external procedure is an external procedure. begin block on line 258 begin block shares stack frame of external procedure pointer_builtins. get_base internal procedure shares stack frame of external procedure pointer_builtins. adjust_c_offset internal procedure shares stack frame of external procedure pointer_builtins. reset_c_offset internal procedure shares stack frame of external procedure pointer_builtins. NO_FUNS internal procedure shares stack frame of external procedure pointer_builtins. CONVERT_TO_POINTER_CONSTANT internal procedure shares stack frame of external procedure pointer_builtins. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME pointer_builtins 000100 p pointer_builtins 000102 q pointer_builtins 000104 p2 pointer_builtins 000106 s3 pointer_builtins 000110 ref pointer_builtins 000116 b2 pointer_builtins 000120 i pointer_builtins 000121 ibase pointer_builtins 000122 macro pointer_builtins 000123 mac_1 pointer_builtins 000124 n pointer_builtins 000125 old_changed pointer_builtins 000126 last_freed pointer_builtins 000127 base pointer_builtins 000130 op_code pointer_builtins 000131 atom pointer_builtins 000134 adjust pointer_builtins 000135 in_base pointer_builtins 000136 type2 pointer_builtins 000140 m_s_p pointer_builtins 000161 base_bits begin block on line 258 000170 i get_base 000220 q NO_FUNS 000222 base_bits NO_FUNS 000223 s3_constant NO_FUNS 000224 constant_zero NO_FUNS 000225 constant_value NO_FUNS 000234 size CONVERT_TO_POINTER_CONSTANT 000235 value CONVERT_TO_POINTER_CONSTANT THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as call_ext_out_desc call_ext_out return mod_fx1 ext_entry index_bs_1_eis THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. adjust_ref_count base_man$load_any_var base_man$load_arg_ptr base_man$load_display base_man$load_var base_man$load_var_and_lock base_man$unlock base_man$update_base base_to_core c_a cg_error compile_exp compile_exp$save declare_constant expmac expmac$zero generate_constant$bit_string load m_a prepare_operand state_man$flush_address state_man$flush_ref store store_bit_address THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. cg_stat$cur_level cg_stat$null_value cg_stat$temp_ref cg_stat$text_base cg_stat$text_pos cg_static_$m_s_p LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 36 000120 9 3 000131 155 000134 156 000140 159 000142 161 000146 163 000150 165 000151 168 000152 170 000154 172 000156 175 000176 179 000221 180 000225 183 000226 185 000233 187 000235 188 000247 189 000270 191 000272 193 000300 195 000305 197 000312 200 000316 203 000321 208 000341 210 000343 212 000346 213 000350 216 000354 218 000375 221 000403 223 000410 224 000416 225 000417 229 000440 230 000441 232 000450 234 000471 236 000500 237 000503 239 000506 242 000507 245 000511 250 000531 251 000537 252 000540 256 000552 260 000572 261 000607 263 000630 266 000631 269 000633 277 000640 280 000647 281 000665 282 000674 285 000677 287 000703 290 000705 291 000707 295 000712 296 000714 297 000717 300 000720 306 000721 309 000735 311 000747 312 000752 314 000763 316 000765 318 001004 320 001021 321 001024 322 001027 326 001030 327 001032 328 001034 330 001036 334 001057 337 001070 338 001073 339 001075 342 001077 344 001116 347 001117 350 001121 353 001130 355 001146 356 001155 359 001160 361 001164 364 001166 365 001170 368 001173 369 001175 371 001200 374 001203 376 001210 378 001213 380 001216 381 001217 384 001225 386 001232 387 001247 388 001254 389 001262 390 001263 392 001265 395 001276 396 001303 397 001310 398 001312 402 001313 404 001322 406 001331 409 001341 411 001351 414 001357 416 001360 419 001376 421 001410 424 001425 425 001427 427 001436 429 001441 431 001446 432 001463 433 001470 434 001476 436 001477 438 001503 440 001524 443 001525 444 001527 446 001531 448 001536 450 001542 452 001547 454 001552 456 001554 458 001555 460 001560 463 001562 466 001563 469 001565 471 001572 473 001575 475 001577 477 001600 479 001603 482 001605 484 001607 485 001617 488 001620 491 001622 493 001640 494 001652 497 001663 498 001665 499 001670 501 001672 504 001673 506 001675 508 001705 509 001707 512 001710 514 001726 516 001730 518 001745 519 001752 520 001760 521 001761 524 001762 526 001764 528 002002 530 002004 532 002011 533 002026 534 002033 535 002041 536 002042 538 002044 540 002047 541 002054 542 002061 543 002063 546 002064 547 002075 550 002076 553 002100 555 002114 556 002116 558 002122 560 002130 561 002145 562 002152 564 002153 565 002170 568 002175 569 002203 570 002204 574 002205 576 002207 578 002223 580 002227 582 002233 583 002256 584 002261 585 002263 586 002300 587 002305 588 002313 589 002314 591 002315 593 002323 594 002326 596 002332 598 002342 599 002344 602 002345 603 002362 604 002364 605 002401 606 002406 608 002407 609 002421 611 002425 614 002426 615 002430 616 002434 617 002451 618 002455 619 002463 623 002464 627 002465 823 002502 631 002503 645 002505 648 002534 649 002535 654 002541 655 002554 659 002557 660 002563 662 002575 665 002614 667 002632 670 002636 675 002640 677 002643 679 002646 681 002664 682 002673 683 002675 685 002712 686 002724 687 002727 688 002731 689 002732 691 002733 693 002734 698 002736 700 002741 702 002743 703 002745 706 002747 714 002750 734 002752 736 002753 737 002756 739 002761 740 002763 743 002766 745 002772 748 003000 749 003002 751 003017 754 003020 757 003032 759 003034 761 003041 763 003057 767 003073 769 003111 770 003113 771 003116 777 003133 779 003151 781 003163 782 003170 783 003172 785 003174 787 003204 788 003215 789 003224 790 003232 791 003233 792 003240 794 003241 810 003243 812 003245 813 003247 815 003251 816 003304 817 003307 ----------------------------------------------------------- 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