THIS FILE IS DAMAGED COMPILATION LISTING OF SEGMENT fort_optimizer Compiled by: Multics PL/I Compiler, Release 31a, of October 12, 1988 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 11/10/88 1352.3 mst Thu Options: optimize map 1 /****^ ****************************************************** 2* * * 3* * Copyright, (C) Honeywell Limited, 1983 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* ****************************************************** */ 9 10 11 12 /****^ HISTORY COMMENTS: 13* 1) change(86-07-14,BWong), approve(86-07-14,MCR7442), audit(86-07-17,Ginter), 14* install(86-07-28,MR12.0-1105): 15* Fix fortran bug 488. 16* END HISTORY COMMENTS */ 17 18 19 /* format: style4,delnl,insnl,^ifthendo,indnoniterend,inditerdo,indend,^indproc,indcom,declareind5 */ 20 fort_optimizer: 21 procedure (pt1); 22 23 /****^ 24*Written: 24 January 1978 by Richard A. Barnes 25* 26*Modified: 16 Apr 86, AFG - 488: Set "used" bit for symbols used as variable 27* offsets in folded array_ref's. 28*Modified: 18 Sep 84, HH - 441: Temporarily bypass bug by disabling 'constant_assign'. 29*Modified: 22 Jun 84, MM - Install typeless functions support. 30*Modified: 28 Mar 84, HH - Install HFP support. 31*Modified: 27 Jul 83, HH - 391: Fix substrings of 'constant_value' variables. 32*Modified: 17 Jun 83, HH - 383: Add support for 'process_param_list_op'. 33*Modified: 31 Jan 83: HH - Install LA/VLA support. 34*Modified: 20 Dec 1982, 359: TO - read_namelist needs processing in 35* 'optimize_flow_unit' to give its namelist variables a 'set' 36* context. 37*Modified: 29 May 1982, TO - 'build_flow_units' was not calling 38* 'connect_jump_assigned' unless both an 'assign' and a 'goto' 39* were seen. It should have been either. 40*Modified: 13 April 1982, TO - Modify message 384 call to include range of 41* lines which are being removed. 42*Modified: 15 March 1981, HH - Fix bug 263: make 'constant_expression' trap 43* arithmetic exceptions during constant folding. 44*Modified: 28 October 1981, CRD - Support for the inquire statement. 45*Modified: 20 October 1981, CRD - Internal files. 46*Modified: 3 September 1981, CRD - Fix bug 337. Changed reduce not to drop ref 47* counts when unthreading, but rather have reduce_strength do it later. 48* If the expression is freed in the interim, the reference counts will 49* not have been spuriously decremented. 50*Modified: 2 September 1981, CRD - Fix bug 334 by eliminating special case for 51* equal_op and not_equal_op in analyze_loop_index_values. The special 52* case was apparently added (by RAB on 1 December 1979) to improve 53* object code, but it also introduces a bug. Since no one remembers 54* the intent of the special case, it is being removed at the risk of 55* losing some optimization. 56*Modified: 31 August 1981, CRD - Change make_jump_to to insert another 57* opt_statement, so that derive_insert_for_bt does not use the 58* previous flow unit by mistake. 59*Modified: 31 July 1981, CRD - Remove optimize_jump. Logic will be placed in 60* cg macros, to avoid problems with discarded machine states. 61*Modified: 28 July 1981, CRD - Change handling of assing_label operator in 62* build_flow_units -- operand is not always an executable label. 63*Modified: 14 July 1981, CRD - Fix bug in which reduce_strength uses the wrong 64* induction variable when eliminating sub_index operators. 65*Modified: 12 May 1981, CRD - Add equiv_op, not_equiv_op. 66*Modified: 13 April 1981, CRD - Fix unreported bug in which opt_subscripts are 67* not properly reduced to constants if the constant is a result of 68* folding and there is no sub_index operator. 69*Modified: 25 February 1981, CRD - Minor auditing changes. 70*Modified: 21 January 1981, CRD - Remove the pseudo-recursive free_expression 71* subroutine introduced in the fix to bug 271. Fix bug 271 instead by 72* freeing the operator associated with a strength reduction frame if 73* its output has a zero reference count. This fixes bug 304. 74*Modified: 5 January 1981, CRD - Remove some invalid PL/I in 75* constant_expression and constant_assign. 76*Modified: 17 December 1980, CRD - Fix bug 280. This was motivated 77* by the addition of block IF statements. 78*Modified: 11 December 1980, CRD - Fix bug 299. New back targets 79* created by the optimizer did not have flow_unit.has_label 80* set. 81*Modified: 9 December 1980, CRD to extend arrays for new block_if, 82* else_if, and else operators. 83*Modified: 1 December 1980, CRD to fix a bug in index_value_analysis 84* in which the input to an increment operator was not 85* disqualified if the output was not eligible. 86*Modified: 25 November 1980, CRD to fix a bug in process_frozen_for_do 87* in which the assignment was erroneously eliminated if the 88* rhs was a symbol whose sets were moved out of the loop. 89*Modified: 24 November 1980, CRD to permit constant_expression to fold 90* relational operators, and to add optimize_jump. 91*Modified: 8 October 1980 by CRD to fix bugs 262 and 264. The special 92* handling of "symbol = constant" is now done by 93* constant_assign. Character constants are now treated 94* properly. 95*Modified: 1 October 1980 by CRD to add free_expression, and to change 96* reduce_strength to call it when an equivalent induction 97* variable has been found. 98*Modified: 16 September 1980 by CRD to properly free operators that 99* are unthreaded by reduce and whose operators are in loop 100* end lists. 101*Modified: 16 September 1980 by CRD to change search_for_equivalent to 102* not use the global variable which, and to change 103* record_secondaries to not record symbols with coordinate 0. 104*Modified: 28 July 1980 by CRD to fix use_inputs not to replace the 105* first operand of an opt_subscript operator with a constant, 106* and to make it set the allocate bit for the constant node. 107*Modified: 22 July 1980 by CRD to fix optimize_flow_unit not to 108* replace the first operand of an opt_subscript operator with 109* a constant. 110*Modified: 18 June 1980 by CRD to make constant_expression work on 111* sub_index operators that are not offsets of opt_subscript 112* operators. 113*Modified: 16 June 1980 by CRD to fix bug 261 (machine state not 114* cleared before loop entry flow units). 115*Modified: 14 March 1980 by RAB to add case to try to calculate range 116* by considering vars that assign to the var in question. 117* Also unreferenced vars in fort_optimizer were cleaned out, 118* and print_hash_bucket_meters was moved to after the include 119* files. 120*Modified: 17 February 1980 to make hash use addition rather than 121* exclusive or to derive mod_2_sum. 122*Modified: 13 February 1980 by RAB to allow for optional metering of 123* the primary list hash buckets. 124*Modified: 9 February 1980 by RAB to change index_value_analysis to 125* allow induction variables that are busy_on_exit from a loop 126* to be kept in an index register if they are known to be 127* non-negative. 128*Modified: 2 February 1980 by RAB to recognize LHS of assignment of 129* form i = j as possible induction variable. Add ass_chain. 130*Modified: 31 January 1980 by RAB to add is_suitable_loop_exit to improve 131* check made in calculate_range_for_counter. 132*Modified: 26 January 1980 by RAB to add calculate_range_for_counter and to 133* fix minor glitch in remove_dead_assignments. 134*Modified: 9 January 1980 by RAB - to fix bug caused when flow_unit.n_in_loop_end 135* exceeds 127 -- reference counts get left too high because size condition 136* occurs on operator.number. 137*Modified: 30 December 1979 by RAB to turn on the induction variable 138* bit for all new induction variables found by add_potential_induction_var. 139*Modified: 27 December 1979 by RAB to allow induction variables that 140* are incremented by a non_constant to be kept in an index 141* register as long as they are not used in a comparison for 142* other than equality. 143*Modified: 18 December 1979 by RAB to complete register optimizer 144* changes and to pool free lists by size for those containing 145* items of size 2 - 4. 146*Modified: 1 December 1979 by RAB to not bother calculating range info 147* for induction vars involved in equals or not_equals comparisons 148* and to require that induction_vars involved in jump_arithmetic 149* be fixed bin(17) in order to be kept in an index register. 150*Modified: 24 September 1979 by RAB to improve fix to bug 237. 151*Modified: 20 September 1979 by RAB to add index_value_analysis for register optimizer. 152*Modified: 17 September 1979 by RAB - to make first set of changes in 153* preparation for register optimization. 154*Modified: 13 September 1979 by RAB - to fix bug 237 in which the optimizer 155* does not realize that real and complex variables may be equivalenced 156* together and be simultaneously defined. This is the only case 157* of mixed data type aliasing in the language. 158*Modified: 1 September 1979 by RAB - to fix 234 in which the optimizer 159* mistakenly assumes that the encode statements completely sets 160* its target buffer, and so will mistakenly remove preceding 161* assignments to the buffer if it is not referenced in between. 162*Modified: 14 August 1979 by RAB - to implement most of Fortran 77 char mode. 163* Data flow analysis has been greatly simplified by using flow_unit.always_completely_set. 164* flow_unit.dim_or_alias_or_not_set has been removed along with various masks. 165*Modified: 13 August 1979 by RAB to change last_assigned_op from 95 to 97. This 166* adds cat_op and substr_op but does not completely implement substr_op. 167*Modified: 4 July 1979 by RAB to fix 218 in which the loop_end_chains were 168* not necessarily built after the bodies of all contained loops. 169* This was fixed by moving loop_end_chain info from loop node 170* to flow_unit node, by making sure loop.last_unit was good 171* for all contained loops as well as for this loop, and 172* by placing in loop_end list for the current loop all 173* temps used_across_loops in the bt_list that are already 174* in a loop_end list for an inner loop. 175*Modified: 28 June 1979 by RAB - to speed up compute_busy_on_exit with 176* flow_unit.dim_or_alias_or_not_set. 177*Modified: 27 June 1979 by RAB - to optimize goto a goto statement. 178*Modified: 20 June 1979 by RAB to fix 214 in which the optimizer 179* builds incorrect flow information for err=, end=, and 180* assigned goto's. 181*Modified: 20 June 1979 by RAB to improve the busy_on_exit algorithm 182* so that dimensioned static variables are not considered 183* busy_on_exit from a subprogram unless they are used 184* in the subprogram. 185*Modified: 20 June 1979 by RAB to improve the busy_on_exit algorithm so that 186* scalar static variables are not considered busy_on_exit from a 187* subprogram unless they might be used in a future invocation of the 188* subprogram before they are set. 189*Modified: 2 June 1979 by RAB to greatly speed up intersection by 190* use of flow_unit.is_active_operator -> obits and 191* operator.coordinate 192*Modified: 27 May 1979 by RAB to diagnose a loop without an exit 193*Modified: 25 May 1979 by RAB to fix bug in redirect_edge 194*Modified: 19 May 1979 by RAB to improve remove_loop 195*Modified: 16 May 1979 by RAB to initialize loop.has_side_effects 196*Modified: 8 April 1979 by RAB to make minor improvements in strength 197* reduction and to note why commoning MUST occur while 198* candidates for strength reduction are being found 199*Modified: 26 March 1979 by RAB to recompute usage information before 200* removing dead assignments 201*Modified: 1 March 1979 by RAB to remove all assignment made dead 202* by constant propagation. 203*Modified: 10 December 1978 by RAB - to change named constant test 204* from symbol.initialed to symbol.initial ^= 0 because of 205* parse's special handling of zero. 206*Modified: 06 December 1978 by PES - for %options and %globals. 207*Modified: 25 October 1978 by PES- for large common and arrays. 208*Modified: 27 September 1978 by RAB to improve fix to 187 209*Modified: 23 September 1978 by RAB to fix 187 210* (back_target not necessarily before every flow_unit in a loop) 211*****/ 212 213 dcl pt1 pointer; /* ptr to shared_globals */ 214 215 dcl adam_loop pointer; /* ptr to non_iterative loop representing the subprogram */ 216 dcl alias_mask bit (7) aligned internal static options (constant) initial ((7)"1"b); 217 dcl aliasable_mask (0:7) bit (max_sym) aligned based (aliasable_mask_p); 218 dcl aliasable_mask_p pointer; /* ptr to aliasable_mask */ 219 dcl assignment_class fixed binary (18) internal static initial (4); 220 dcl always_safe_to_move_class fixed binary (18); /* ops in this and lower classes may be moved from 221* nonarticulation blocks */ 222 dcl cannot_fault_class fixed binary (18) internal static initial (1); 223 dcl cs pointer; /* ptr to cur_subprogram */ 224 dcl consolidating bit (1) aligned; /* "1"b -- consolidate_subprogram running */ 225 dcl do_timings bit (1) aligned; /* "1"b -- timing info shd be printed */ 226 dcl entry_unit pointer; /* ptr to dummy entry flow unit */ 227 dcl exit_unit pointer; /* ptr to dummy exit flow unit */ 228 dcl flow_unit_vector_p pointer; /* ptr to flow_unit_vector */ 229 dcl free (2:4) pointer; /* ptr to free lists by size */ 230 dcl freefu pointer; /* ptr to free list of flow_units */ 231 dcl freei pointer; /* ptr to free list of input_to nodes */ 232 dcl freep pointer; /* ptr to list of partially freed primaries */ 233 dcl freep_tail pointer; /* ptr to end of list of partially freed primaries */ 234 dcl freesrv pointer; /* ptr to chain of free strength reduction variable nodes */ 235 dcl full_strength_reduction bit (1) aligned; /* ON if we should include induction vars updated by 236* nonincrements */ 237 dcl function_class fixed binary (18) static initial (6); 238 dcl hash_mask bit (4297) aligned; /* mask used to speed up search for expressions available 239* for commoning */ 240 dcl highest_reducible_class fixed binary (18) internal static initial (4); 241 dcl i fixed binary (18); 242 dcl init_frame pointer; /* ptr to initial frame used in reduce_strength */ 243 dcl init_lp_frame pointer; /* ptr to initial frame used in optimize_subprogram */ 244 dcl integer_scalar_mask bit (max_sym) aligned based (integer_scalar_mask_p); 245 dcl integer_scalar_mask_p pointer; /* -> integer_scalar_mask */ 246 dcl loop_entry_list pointer; /* ptr to chain of loop entry units */ 247 dcl loop_vector_p pointer; /* ptr to loop vector */ 248 dcl max_flow_units fixed binary (18); /* length of flow_unit_vector */ 249 dcl max_operands fixed binary; /* maximum value of operator.number */ 250 dcl max_operators fixed binary (18); /* length of obits */ 251 dcl max_sym fixed binary (18); /* maximum length of bit vectors */ 252 dcl meter_hash_buckets bit (1) aligned; 253 dcl n_flow_units fixed binary (18); /* number of flow units created */ 254 dcl n_loops fixed binary (18); /* number of loops created */ 255 dcl n_operators fixed binary (18); /* number of operators given coordinates in obits */ 256 dcl n_sym fixed binary (18); /* number of symbols in bit vectors */ 257 dcl need_consolidation_pass bit (1) aligned; /* "1"b -- reoptimize after all other optimizations done */ 258 dcl non_auto_mask bit (max_sym) aligned based (non_auto_mask_p); 259 dcl non_auto_mask_p pointer; /* -> non_auto_mask */ 260 dcl one fixed binary (18); /* operand for integer constant 1 */ 261 dcl onep pointer; /* ptr to one */ 262 dcl operand_base pointer; /* ptr to operand region */ 263 dcl operand_max_len fixed binary (19); /* maximum length of operand region */ 264 dcl opt_base pointer; /* ptr to optimizer's region */ 265 dcl opt_max_len fixed binary (19); /* maximum length of optimizer's region */ 266 dcl polish_base pointer; /* ptr to polish region */ 267 dcl polish_max_len fixed binary (19); /* maximum length of polish region */ 268 dcl quad_max_len fixed binary (19); /* maximum length of quad (tuple) region */ 269 dcl quadruple_base pointer; /* ptr to quad (tuple) region */ 270 dcl s_list pointer; /* ptr to secondary list */ 271 dcl scan_bits_p pointer; /* ptr to scan_bits */ 272 dcl scan_vector_p pointer; /* ptr to scan_vector */ 273 dcl shared_struc_ptr pointer; /* ptr to shared_globals */ 274 dcl state_discarded bit (1) aligned; /* "1"b -- no current machine state */ 275 dcl temp_bits_p pointer; /* ptr to temp_bits */ 276 dcl unlikely_to_fault_class fixed binary (18) internal static initial (2); 277 dcl zero fixed binary (18); /* operand for integer constant 0 */ 278 279 /* experiments seem to show that 11 is the best hash_table size, 280* although 23 looks good in some cases. */ 281 282 dcl 1 bt_list_st (0:10) automatic aligned, /* hash table for back target's primary list */ 283 2 bt_list pointer unaligned; 284 285 dcl 1 p_list_st (0:10) automatic aligned, /* hash table for primary list */ 286 2 p_list pointer unaligned; 287 288 dcl hash_counter (0:10) fixed binary; /* used for metering p_list & bt_list. */ 289 290 dcl ( 291 full_optimization initial (1), 292 common_only initial (2) 293 ) fixed binary (18) internal static options (constant); 294 295 dcl ( 296 complete_fu initial (1), 297 partial_fu initial (2) 298 ) fixed binary (18) internal static options (constant); 299 300 /* op_class: 301* 0 invalid 302* 1 reducible, no chance of exception 303* 2 reducible, small chance of exception 304* 3 reducible, large chance of exception 305* 4 reducible assignment 306* 5 irreducible assignment 307* 6 call or func_ref 308* 7 entry point 309* 8 jump 310* 9 jump_arithmetic 311* 10 jump_computed 312* 11 jump_assigned 313* 12 jump_true, jump_false 314* 13 return, stop 315* 14 error_label, end_label 316* 15 irreducible, no special case 317* 16 assign_label 318* 17 end_unit 319* 18 read_namelist 320* 19 write_namelist 321* 20 non_executable, no_op 322* 21 irreducible, partially sets 323* 22 inquire 324* */ 325 326 dcl op_class (109) fixed binary internal static initial (4, 2, 2, 2, 3, 3, 2, 1, 1, 1, 327 /* 1 - 10 */ 328 1, 1, 1, 1, 1, 1, 8, 0, 9, 10, /* 11 - 20 */ 329 11, 16, 15, 15, 15, 14, 14, 15, 15, 15, /* 21 - 30 */ 330 (10) 15, /* 31 - 40 */ 331 13, 15, 13, 0, 0, 0, 0, 3, 0, 0, /* 41 - 50 */ 332 0, 6, 7, 0, 7, 7, 7, 0, 0, 6, /* 51 - 60 */ 333 15, 17, 21, 21, 1, 1, 1, 1, 4, 5, /* 61 - 70 */ 334 5, 5, 5, 0, 15, 15, 15, 2, 1, 1, /* 71 - 80 */ 335 1, 15, 15, 15, 15, 15, 15, 12, 12, 1, /* 81 - 90 */ 336 15, 18, 19, 15, 21, 1, 3, 0, 0, 0, /* 91 - 100 */ 337 0, 0, 1, 1, 15, 21, 22, 7, 5); /* 101 - 109 */ 338 339 /* xop_class: 340* 1 opt_subscript 341* 2 incrementing 342* 3 relational 343* 4 jump_arithmetic 344* 5 assign 345* 6 write_namelist 346* 7 most operators 347* 8 cat 348* */ 349 350 dcl xop_class (109) fixed binary internal static initial (5, 7, 7, 7, 7, 7, 7, 3, 3, 3, 351 /* 1 - 10 */ 352 3, 3, 3, 7, 7, 7, 7, 7, 4, 7, /* 11 - 20 */ 353 (10) 7, /* 21 - 30 */ 354 (10) 7, /* 31 - 40 */ 355 (10) 7, /* 41 - 50 */ 356 (10) 7, /* 51 - 60 */ 357 7, 7, 7, 7, 7, 1, 7, 7, 7, 2, /* 61 - 70 */ 358 7, 2, 2, 7, 7, 7, 7, 7, 7, 7, /* 71 - 80 */ 359 (10) 7, /* 81 - 90 */ 360 7, 7, 6, 7, 7, 8, 7, 7, 7, 7, /* 91 - 100 */ 361 7, 7, 7, 7, 7, 7, 7, 7, 7); /* 101 - 109 */ 362 363 dcl scan_bits bit (max_flow_units) aligned based (scan_bits_p); 364 /* bit string used in scanning flow units */ 365 dcl temp_bits bit (max_sym) aligned based (temp_bits_p); /* bit string used in busy_on_exit calculation */ 366 367 368 dcl 1 flow_unit_vector_st based (flow_unit_vector_p) aligned, 369 2 flow_unit_vector (max_flow_units) pointer unaligned; 370 /* vector of flow_units in ascending order by level number */ 371 372 dcl 1 loop_vector_st based (loop_vector_p) aligned, 373 2 loop_vector (n_loops) pointer unaligned; /* vector of loops in descending order by nesting depth 374* and front to back */ 375 376 dcl 1 scan_vector_st aligned based (scan_vector_p), 377 2 scan_vector (max_flow_units) pointer unaligned; /* vector used in scanning flow_units */ 378 379 dcl bits bit (max_sym) aligned based; /* one bit per symbol */ 380 dcl dbits bit (max_flow_units) aligned based; /* one bit per flow_unit */ 381 dcl lbits bit (n_loops) aligned based; /* one bit per loop */ 382 dcl obits bit (max_operators) aligned based; /* one bit per operator */ 383 384 dcl opt (0:opt_max_len - 1) fixed binary (35) aligned based (opt_base); 385 386 dcl rands (0:operand_max_len - 1) fixed binary (18) aligned based (operand_base); 387 388 dcl polish (0:polish_max_len - 1) fixed binary (18) aligned based (polish_base); 389 390 dcl quad (0:quad_max_len - 1) fixed binary (18) aligned based (quadruple_base); 391 392 dcl 1 secondary based aligned, /* must be same size as primary */ 393 2 next pointer unaligned, /* must overlay primary.next */ 394 2 last pointer unaligned, /* must overlay primary.last */ 395 2 symbol pointer unaligned, 396 2 primary pointer unaligned; 397 398 dcl 1 sr_cand based aligned, /* strength reduction candidate node */ 399 2 next pointer unaligned, 400 2 operator pointer unaligned, /* strength reduction candidate */ 401 2 which fixed binary (18), /* operand number of induction variable */ 402 2 statement pointer unaligned; /* opt_statement in which operator appeared */ 403 404 dcl 1 sr_var based aligned, /* strength reduction variable node */ 405 2 next pointer unaligned, 406 2 variable fixed binary (18), /* newly created variable */ 407 2 all_constant bit (1) aligned, /* all terms of initialization code are constant */ 408 2 sign_differs bit (1) aligned, /* sign of increment differs from sign of original */ 409 2 sign_unknown bit (1) aligned, /* sign of increment has unknown relationship to 410* sign of original */ 411 2 updated_by pointer unaligned, /* -> operator updating its value inside the loop */ 412 2 used_in pointer unaligned, /* -> mask indicating in which loops this has been used */ 413 2 ninst fixed binary (18), /* number of tuples in initializing code */ 414 2 tuple (8) structure aligned, 415 3 operator pointer unaligned, 416 3 which fixed binary (18); 417 418 dcl 1 incr based aligned, /* increment node */ 419 2 next pointer unaligned, 420 2 value pointer unaligned, /* -> increment operator */ 421 2 statement pointer unaligned, /* -> increment statement */ 422 2 var_chain pointer unaligned; /* -> chain of new induction vars */ 423 424 dcl 1 dead_assign_cand based aligned, /* dead assignment candidate node */ 425 2 next pointer unaligned, 426 2 variable fixed binary (18), 427 2 flow_unit pointer unaligned; 428 429 dcl 1 equiv_array based aligned, /* equivalenced array info -- must be same size as INPUT_TO */ 430 2 next pointer unaligned, 431 2 lowest fixed binary (18), 432 2 highest fixed binary (18); 433 434 dcl 1 lp_frame based aligned, 435 2 next pointer unaligned, 436 2 back pointer unaligned, 437 2 data structure aligned, 438 3 this_fu pointer unaligned, 439 3 last_fu pointer unaligned, 440 3 next_lp pointer unaligned, 441 3 hold_p_list pointer unaligned, 442 3 hold_bt_list pointer unaligned, 443 3 hold_incr_chain pointer unaligned, 444 3 hold_sr_chain pointer unaligned, 445 3 hold_sr_tail pointer unaligned, 446 3 hold_ass_chain pointer unaligned, 447 3 resume_st fixed binary (18), 448 3 first_jump_target pointer unaligned; 449 450 dcl section (10) character (25) varying internal static options (constant) 451 initial ("assign_symbol_coordinates", "build_flow_units", "flow_analysis", "optimize_loop", "reduce_strength", 452 "replace_tests", "remove_dead_assignments", "consolidate_subprogram", "recompute_usage", "index_value_analysis") 453 ; 454 455 dcl 1 timing_info aligned, 456 2 last_vcpu fixed binary (71), 457 2 last_pf fixed binary (18), 458 2 last_section fixed binary (18), 459 2 entry (10) aligned, 460 3 vcpu fixed binary (18), 461 3 pf fixed binary (18); 462 463 dcl total_pf fixed binary (18); 464 dcl total_vcpu float binary; 465 dcl tx float binary; 466 dcl (max_n_sym, max_n_loops, max_n_flow_units) fixed binary (18); 467 468 dcl ioa_ entry options (variable); 469 470 dcl (abs, addr, bit, char, dim, divide, fixed, float, hbound, length, ltrim, max, min, mod, null, rel, round, size, 471 string, substr, sum, unspec) builtin; 472 1 1 /* BEGIN fort_opt_nodes.incl.pl1 */ 1 2 1 3 /* Created: 22 November 1977 by Richard A. Barnes for the optimizing Fortran compiler */ 1 4 1 5 /* Modified: 09 October 1978 by Paul E. Smee for larger common and arrays. 1 6* Modified: 2 June 1979 by RAB to speed up intersection of optimizer 1 7* machine states by adding operator.coordinate and 1 8* flow_unit.is_active_operator 1 9* Modified: 28 June 1979 by RAB to speed up compute_busy_on_exit by 1 10* adding flow_unit.dim_or_alias_or_not_set. 1 11* Modified: 02 July 1979 by RAB to fix 218 by moving loop_end_chain stuff 1 12* to flow_unit node from loop node. 1 13* Modified: 14 August 1979 by RAB to change flow_unit.dim_or_alias_or_not_set 1 14* to flow_unit.always_completely_set. 1 15* Modified: 17 September 1979 by RAB in preparation for register optimizer. 1 16* Modified: 20 September 1979 by RAB for index_value_analysis of register optimizer. 1 17* Modified: 03 November 1979 by RAB for flow_unit.refreshed for register optimizer. 1 18* Modified: 30 November 1979 by RAB to add more info to the loop node 1 19* for the register optimizer. 1 20* Modified: 18 December 1979 by RAB to make remainder of register 1 21* optimizer changes. 1 22* Modified: 17 December 1980 by CRD to add opt_statement.removable. 1 23**/ 1 24 1 25 /* CHAIN (2 words) */ 1 26 1 27 dcl 1 chain based aligned, 1 28 2 next pointer unaligned, 1 29 2 value pointer unaligned; 1 30 1 31 /* EDGE (6 words) */ 1 32 1 33 dcl 1 edge based aligned, 1 34 2 from structure, 1 35 3 value ptr unal, 1 36 3 next ptr unal, 1 37 3 back ptr unal, 1 38 2 to structure, 1 39 3 value ptr unal, 1 40 3 next ptr unal, 1 41 3 back ptr unal; 1 42 1 43 1 44 /* FLOW_UNIT (22 words) */ 1 45 1 46 dcl 1 flow_unit based aligned, 1 47 2 next ptr unal, 1 48 2 back ptr unal, 1 49 2 successors ptr unal, 1 50 2 predecessors ptr unal, 1 51 2 dominator ptr unal, 1 52 2 loop ptr unal, 1 53 2 next_in_loop ptr unal, 1 54 2 loop_end_chain ptr unal, 1 55 2 position fixed bin(17) aligned, 1 56 2 number fixed bin(17) unal, 1 57 2 n_in_loop_end fixed bin(17) unal, 1 58 2 level_number fixed bin(17) aligned, 1 59 2 first_statement fixed bin (18) unsigned unal, 1 60 2 last_statement fixed bin (18) unsigned unal, 1 61 2 insert_statement fixed bin (18) unsigned unal, 1 62 2 insert_operator fixed bin (18) unsigned unal, 1 63 2 info structure unal, 1 64 3 processed bit(1), 1 65 3 loop_entry bit(1), 1 66 3 falls_through bit(1), 1 67 3 has_label bit(1), 1 68 3 entry_pt bit(1), 1 69 3 in_queue bit(1), 1 70 3 is_back_target bit(1), 1 71 3 has_side_effects bit(1), 1 72 3 removed bit(1), 1 73 3 refreshed bit(1), 1 74 3 pad bit(26), 1 75 2 used ptr unal, 1 76 2 set ptr unal, 1 77 2 busy_on_entry ptr unal, 1 78 2 set_multiple ptr unal, 1 79 2 busy_on_exit ptr unal, 1 80 2 dominated_by ptr unal, 1 81 2 is_active_operator ptr unal, 1 82 2 always_completely_set ptr unal; 1 83 1 84 1 85 /* INPUT_TO (3 words) */ 1 86 1 87 dcl 1 input_to based aligned, 1 88 2 next pointer unaligned, 1 89 2 operator pointer unaligned, 1 90 2 which fixed bin aligned; 1 91 1 92 /* LCHAIN (2 words) */ 1 93 1 94 dcl 1 lchain based aligned, 1 95 2 next pointer unaligned, 1 96 2 value fixed bin(18) aligned; 1 97 1 98 /* LOOP (33 words) */ 1 99 1 100 dcl 1 loop based aligned, 1 101 2 number fixed bin(18), 1 102 2 depth fixed bin(18), 1 103 2 father pointer unaligned, 1 104 2 brother pointer unaligned, 1 105 2 prev_brother pointer unaligned, 1 106 2 son pointer unaligned, 1 107 2 last_son pointer unaligned, 1 108 2 entry_unit pointer unaligned, 1 109 2 members pointer unaligned, 1 110 2 back_target pointer unaligned, 1 111 2 exits pointer unaligned, 1 112 2 first_unit pointer unaligned, 1 113 2 last_unit pointer unaligned, 1 114 2 is_member pointer unaligned, 1 115 2 is_exit pointer unaligned, 1 116 2 articulation_blocks pointer unaligned, 1 117 2 used pointer unaligned, 1 118 2 set pointer unaligned, 1 119 2 busy_on_exit pointer unaligned, 1 120 2 set_multiple pointer unaligned, 1 121 2 ancestors_and_me pointer unaligned, 1 122 2 bits structure unaligned, 1 123 3 has_side_effects bit(1), 1 124 3 erases structure unaligned, 1 125 4 xr(0:7) bit(1), 1 126 4 pr(6) bit(1), 1 127 3 avoid_pr(6) bit(1), 1 128 3 all_xrs_globally_assigned bit(1), 1 129 3 pad bit(14), 1 130 2 induction_var pointer unaligned, 1 131 2 may_keep_in_xr pointer unaligned, 1 132 2 computed pointer unaligned, 1 133 2 xregs_used fixed bin(4), 1 134 2 pregs_used fixed bin(4), 1 135 2 global_xr_items pointer unaligned, 1 136 2 global_pr_items pointer unaligned, 1 137 2 range_list pointer unaligned, 1 138 2 msp pointer unaligned, 1 139 2 eligible_ind_var_op_var pointer unaligned, 1 140 2 left_shift_chain pointer unaligned; 1 141 1 142 /* OPERATOR */ 1 143 1 144 dcl 1 operator based aligned, 1 145 1 146 /* WORD 1 */ 1 147 1 148 2 op_code fixed bin(8) unal, 1 149 2 assigns_constant_to_symbol bit(1) unal, 1 150 2 freed bit(1) unal, 1 151 2 number fixed bin(7) unsigned unal, 1 152 2 coordinate fixed bin(18) unsigned unal, 1 153 1 154 /* WORD 2 */ 1 155 1 156 2 next fixed bin(18) unsigned unal, 1 157 2 back fixed bin(18) unsigned unal, 1 158 1 159 /* WORD 3 */ 1 160 1 161 2 primary pointer unal, 1 162 1 163 /* WORD 4 */ 1 164 1 165 2 output fixed bin(18) aligned, 1 166 1 167 /* WORDS 5 - n */ 1 168 1 169 2 operand(n_operands refer (operator.number)) fixed bin (18) aligned; 1 170 1 171 dcl n_operands fixed bin; 1 172 1 173 1 174 /* OPT_STATEMENT */ 1 175 1 176 dcl 1 opt_statement based aligned structure, 1 177 1 178 /* WORD 1 */ 1 179 1 180 2 op_code fixed bin(8) unal, /* must be stat_op */ 1 181 2 number fixed bin(8) unal, /* must be 0 */ 1 182 2 label fixed bin (18) unsigned unal, 1 183 1 184 /* WORD 2 */ 1 185 1 186 2 first_operator fixed bin (18) unsigned unal, 1 187 2 prev_operator fixed bin (18) unsigned unal, 1 188 1 189 /* WORD 3 */ 1 190 1 191 2 next bit(18) unal, /* "0"b = no next statement */ 1 192 2 back bit(18) unal, /* "0"b = no prev statement */ 1 193 1 194 /* WORD 4 */ 1 195 1 196 2 source_id structure unaligned, 1 197 3 file fixed bin (8) unsigned, /* 0 = first file */ 1 198 3 line bit(14), 1 199 3 statement bit(5), /* 1 = first statement */ 1 200 1 201 2 length bit(9) unaligned, 1 202 1 203 /* WORD 5 */ 1 204 1 205 2 bits structure unaligned, 1 206 3 put_in_map bit(1), 1 207 3 put_in_profile bit(1), 1 208 3 processed_by_converter bit(1), 1 209 3 referenced_backwards bit(1), 1 210 3 referenced_by_assign bit(1), 1 211 3 has_operator_list bit(1), 1 212 3 moved bit(1), 1 213 3 removable bit(1), 1 214 3 pad bit(1), 1 215 1 216 2 start fixed bin(26) unaligned, 1 217 1 218 /* WORD 6 */ 1 219 1 220 2 location bit(18) unaligned, /* (18)"1"b = no code */ 1 221 2 machine_state fixed bin (18) unsigned unaligned, 1 222 1 223 /* WORD 7 */ 1 224 1 225 2 flow_unit pointer unaligned, 1 226 1 227 /* WORD 8 */ 1 228 1 229 2 operator_list pointer unaligned; 1 230 1 231 1 232 /* PRIMARY (4 words) */ 1 233 1 234 dcl 1 primary based aligned, 1 235 2 next pointer unaligned, 1 236 2 last pointer unaligned, 1 237 2 data structure aligned, 1 238 3 expression pointer unaligned, 1 239 3 flow_unit pointer unaligned; 1 240 1 241 /* RANGE (3 words) */ 1 242 1 243 dcl 1 range based aligned, 1 244 2 next pointer unaligned, 1 245 2 variable pointer unaligned, 1 246 2 bits structure unaligned, 1 247 3 range_bits structure unaligned, 1 248 4 fb17 bit(1), 1 249 4 fb18_uns bit(1), 1 250 3 mbz bit(34); 1 251 1 252 1 253 /* END fort_opt_nodes.incl.pl1 */ 473 2 1 /* BEGIN fort_nodes.incl.pl1 */ 2 2 2 3 2 4 2 5 /****^ HISTORY COMMENTS: 2 6* 1) change(86-07-14,BWong), approve(86-07-14,MCR7382), audit(86-07-17,Ginter), 2 7* install(86-07-28,MR12.0-1105): 2 8* Fix fortran bug 473. 2 9* 2) change(88-04-28,RWaters), approve(88-04-28,MCR7875), audit(88-07-13,Huen), 2 10* install(88-11-10,MR12.2-1209): 2 11* Implement SCP 6339: Allow character variable to be up to 128K-1 (131071) 2 12* character long. 2 13* END HISTORY COMMENTS */ 2 14 2 15 2 16 /* Written: June 1976 by David Levin and Richard Barnes 2 17* 2 18*Modified: 2 19* Feb 24 1977 by G. Chang for the optimizer 2 20* Sept 12, 1977 by R. Barnes for the loop optimizer 2 21* Nov 16, 1977 by D. Levin to add machine state node for loop optimizer 2 22* Oct 09 1978 by P Smee for larger common and arrays. 2 23* Dec 05 1978 by P Smee for %options statement. 2 24* Jan 17 1979 by R Barnes for machine_state.value_in_xr 2 25* May 23 1979 by P Smee to add source.line_number 2 26* July 19 1979 by R Barnes for char mode changes 2 27* Sept 17 1979 by R Barnes for register optimizer changes 2 28* Oct 3 1979 by C R Davis for new EAQ management scheme. 2 29* 29 Oct 1979 by C R Davis for machine_state.eaq.reserved. 2 30* 3 Nov 1979 by R. Barnes for pointer node and to change 2 31* machine_state.next from a fixed bin to a pointer. 2 32* 18 Dec 1979 by R. Barnes for loop_ref_count to finalize 2 33* changes for the register optimizer. 2 34* 17 Dec 1979 by C R Davis for symbol.descriptor 2 35* 22 Dec 1979 by R. Barnes to remove in_list. 2 36* 22 Jan 1980 by P E Smee to try for long char arrays. 2 37* 23 Jan 1980 by C R Davis to fix bugs with yesterday's changes. 2 38* 4 Mar 1980 by C R Davis to rename node.multi_position to 2 39* node.stack_indirect, and to add machine_state.stack_extended 2 40* and machine_state.last_dynamic_temp. 2 41* 5 Jun 1980 by M E Presser to alter arg_desc node for use 2 42* in stack-extensions and arg-descriptor generation. 2 43* 16 July 1980 by C R Davis for symbol.variable_arglist. 2 44* 8 Jan 81 by M E Presser for label.not_referencable 2 45* 17 Feb 1981 by C R Davis for new dimension node layout. 2 46* 11 March 1981 by MEP for dimension.assumed_size 2 47* 3 May 1982 by TO to add star_extent_function to subprogram node. 2 48* Mod 1 25 August 1982 by TO to add VLA_chain and LA_chain to subprogram node. 2 49* Mod 1 2 September 1982 by TO to add 5 more entries to storage_info in 2 50* the subprogram node (13-17), and to add VLA and LA bits to the 2 51* symbol node. 2 52* Mod 1 2 September 1982 by TO move fields around in nodes to get correct 2 53* 24 (really 35) bit fields and still maintain mapping between 2 54* node, temporary, and array_ref (others limit to word 6 like node.) 2 55* 19 Jun 83, HH - 145: Add 'branched_to', 'ends_do_loop' & 'loop_end' 2 56* to 'label' node. 2 57* 19 Feb 86, BW & AG - 473.a: Add 'VLA' to 'arg_desc' node. 2 58*END Modifications */ 2 59 2 60 2 61 /* GENERAL NODE TEMPLATE */ 2 62 2 63 dcl 1 node aligned based structure, 2 64 2 65 /* WORD 1 */ 2 66 2 67 2 node_type fixed bin (4) unaligned, 2 68 2 data_type fixed bin (4) unaligned unsigned, 2 69 2 operand_type fixed bin (4) unaligned, 2 70 2 71 2 addressing_bits unaligned structure, 2 72 3 is_addressable bit (1), 2 73 3 value_in, 2 74 4 eaq bit (1), 2 75 4 x bit (1), 2 76 3 allocated bit (1), 2 77 3 needs_pointer bit (1), 2 78 3 stack_indirect bit (1), 2 79 3 large_address bit (1), 2 80 3 address_in_base bit (1), 2 81 3 dont_update bit (1), /* for optimizer */ 2 82 3 not_in_storage bit (1), /* for optimizer */ 2 83 3 globally_assigned bit (1), /* for optimizer */ 2 84 2 85 2 bits unaligned structure, 2 86 3 standard_bits, 2 87 4 allocate bit (1), 2 88 4 set bit (1), 2 89 4 referenced bit (1), 2 90 4 passed_as_arg bit (1), 2 91 2 92 3 fill bit (7), /* These bits may be used by individual nodes. */ 2 93 2 94 /* WORD 2 */ 2 95 2 96 2 address aligned structure, 2 97 3 base bit (3) unaligned, /* For labels and constants, base and offset are */ 2 98 3 offset fixed bin (14) unaligned, /* combined to: fixed bin (18) unsigned unaligned. */ 2 99 3 char_num fixed bin (2) unaligned unsigned, 2 100 3 bit_num fixed bin (4) unaligned unsigned, 2 101 3 fill bit (4) unaligned, 2 102 3 inhibit bit (1) unaligned, 2 103 3 ext_base bit (1) unaligned, 2 104 3 tag bit (6) unaligned, 2 105 2 106 /* WORD 3 */ 2 107 2 108 2 units fixed bin (3) unaligned unsigned, 2 109 2 fill bit (3) unaligned, /* already used in symbol node */ 2 110 2 reloc_hold bit (6) unaligned, 2 111 2 reloc bit (6) unaligned, 2 112 2 addr_hold bit (18) unaligned, 2 113 2 114 /* WORD 4. Must not change for constant, char_constant, header, label, or symbol nodes. */ 2 115 2 116 2 next fixed bin (18) unsigned unaligned, 2 117 2 hash_chain fixed bin (18) unsigned unaligned, /* No hash chain for header nodes. */ 2 118 2 119 /* WORD 5 */ 2 120 2 121 2 pad fixed bin (18) unsigned unaligned, 2 122 2 loop_ref_count fixed bin (17) unaligned, /* Only for symbols and temporaries. */ 2 123 2 124 /* WORD 6 */ 2 125 2 126 2 location fixed bin (24) aligned; /* Only for array refs, symbols, temporaries, and headers. */ 2 127 2 128 /* ARG DESCRIPTOR NODE */ 2 129 2 130 dcl 1 arg_desc based aligned, 2 131 2 132 /* WORD 1 */ 2 133 2 134 2 node_type fixed bin (4) unaligned, 2 135 2 n_args fixed bin (12) unaligned, 2 136 2 pad bit (18) unaligned, 2 137 2 138 /* WORDS 2 - N_ARGS + 1 */ 2 139 2 140 2 arg(num_args refer(n_args)) aligned, 2 141 3 data_type fixed bin (4) unaligned unsigned, 2 142 3 must_be unaligned, 2 143 4 array bit (1) unaligned, 2 144 4 scalar bit (1) unaligned, 2 145 4 VLA bit (1) unaligned, 2 146 3 star_extents bit (1) unaligned, 2 147 3 pad bit (9) unaligned, 2 148 3 symbol fixed bin (18) unaligned; 2 149 2 150 dcl num_args fixed bin; 2 151 2 152 2 153 /* ARRAY REF NODE -- Must be same size as TEMPORARY NODE. */ 2 154 2 155 dcl 1 array_ref aligned based structure, 2 156 2 157 /* WORD 1 */ 2 158 2 159 2 node_type fixed bin (4) unaligned, 2 160 2 data_type fixed bin (4) unaligned unsigned, 2 161 2 operand_type fixed bin (4) unaligned, 2 162 2 163 2 addressing_bits unaligned structure, 2 164 3 is_addressable bit (1), 2 165 3 value_in, 2 166 4 eaq bit (1), 2 167 4 x bit (1), 2 168 3 allocated bit (1), 2 169 3 needs_pointer bit (1), 2 170 3 stack_indirect bit (1), 2 171 3 large_address bit (1), 2 172 3 address_in_base bit (1), 2 173 3 dont_update bit (1), /* for optimizer */ 2 174 3 not_in_storage bit (1), /* for optimizer */ 2 175 3 globally_assigned bit (1), /* for optimizer */ 2 176 2 177 2 bits unaligned structure, 2 178 3 standard_bits, 2 179 4 allocate bit (1), 2 180 4 set bit (1), 2 181 4 referenced bit (1), 2 182 4 passed_as_arg bit (1), 2 183 2 184 3 variable_length bit (1), 2 185 2 186 3 variable_offset bit (1), 2 187 2 188 3 invariant bit (1), /* must line up with temporary node */ 2 189 3 irreducible bit (1), /* .. */ 2 190 3 used_across_loops bit (1), /* .. */ 2 191 2 192 3 large_offset bit (1), 2 193 2 194 3 has_address bit (1), 2 195 2 196 /* WORD 2 */ 2 197 2 198 2 address aligned structure, 2 199 3 base bit (3) unaligned, 2 200 3 offset fixed bin (14) unaligned, 2 201 3 char_num fixed bin (2) unaligned unsigned, 2 202 3 bit_num fixed bin (4) unaligned unsigned, 2 203 3 fill bit (4) unaligned, 2 204 3 inhibit bit (1) unaligned, 2 205 3 ext_base bit (1) unaligned, 2 206 3 tag bit (6) unaligned, 2 207 2 208 /* WORD 3 */ 2 209 2 210 2 units fixed bin (3) unaligned unsigned, 2 211 2 fill bit (3) unaligned, 2 212 2 reloc_hold bit (6) unaligned, 2 213 2 reloc bit (6) unaligned, 2 214 2 addr_hold bit (18) unaligned, 2 215 2 216 /* WORD 4 */ 2 217 2 218 2 next fixed bin (18) unsigned unaligned, 2 219 2 loop_end_fu_pos fixed bin (17) unaligned, /* must overlay temporary.loop_end_fu_pos */ 2 220 2 221 /* WORD 5 */ 2 222 2 223 2 pad fixed bin (18) unsigned unaligned, 2 224 2 v_offset fixed bin (18) unsigned unaligned, 2 225 2 226 /* WORD 6 */ 2 227 2 228 2 location fixed bin (24) aligned, 2 229 2 230 /* WORD 7 */ 2 231 2 232 2 ref_count fixed bin (17) unaligned, /* must overlay temporary.ref_count */ 2 233 2 output_by fixed bin (18) unsigned unal, /* must overlay temporary.output_by */ 2 234 2 235 /* WORD 8 */ 2 236 2 237 2 length fixed bin (24) aligned, 2 238 2 239 /* WORD 9 */ 2 240 2 241 2 start_input_to fixed bin (18) unsigned unal, /* must overlay temporary.start_input_to */ 2 242 2 end_input_to fixed bin (18) unsigned unal, /* must overlay temporary.end_input_to */ 2 243 2 244 /* WORD 10 */ 2 245 2 246 2 ref_count_copy fixed bin (17) unaligned, /* must overlay temporary.ref_count_copy */ 2 247 2 parent fixed bin (18) unsigned unaligned, 2 248 2 249 /* WORD 11 */ 2 250 2 251 2 unused fixed bin (24) aligned; /* Pad to size of 'temporary'. */ 2 252 2 253 2 254 /* CONSTANT NODE */ 2 255 2 256 dcl 1 constant aligned based structure, 2 257 2 258 /* WORD 1 */ 2 259 2 260 2 node_type fixed bin (4) unaligned, 2 261 2 data_type fixed bin (4) unaligned unsigned, 2 262 2 operand_type fixed bin (4) unaligned, 2 263 2 264 2 addressing_bits unaligned structure, 2 265 3 is_addressable bit (1), 2 266 3 value_in, 2 267 4 eaq bit (1), 2 268 4 x bit (1), 2 269 3 allocated bit (1), 2 270 3 needs_pointer bit (1), 2 271 3 stack_indirect bit (1), 2 272 3 large_address bit (1), 2 273 3 address_in_base bit (1), 2 274 3 dont_update bit (1), /* for optimizer */ 2 275 3 not_in_storage bit (1), /* for optimizer */ 2 276 3 globally_assigned bit (1), /* for optimizer */ 2 277 2 278 2 bits unaligned structure, 2 279 3 standard_bits, 2 280 4 allocate bit (1), 2 281 4 set bit (1), 2 282 4 referenced bit (1), 2 283 4 passed_as_arg bit (1), 2 284 2 285 3 fill bit (7), 2 286 2 287 /* WORD 2 */ 2 288 2 289 2 address aligned structure, 2 290 3 location fixed bin (18) unsigned unaligned, 2 291 3 op bit (10) unaligned, 2 292 3 inhibit bit (1) unaligned, 2 293 3 ext_base bit (1) unaligned, 2 294 3 tag bit (6) unaligned, 2 295 2 296 /* WORD 3 */ 2 297 2 298 2 units fixed bin (3) unaligned unsigned, 2 299 2 fill bit (3) unaligned, 2 300 2 reloc_hold bit (6) unaligned, 2 301 2 reloc bit (6) unaligned, 2 302 2 addr_hold bit (18) unaligned, 2 303 2 304 /* WORD 4 */ 2 305 2 306 2 next_constant fixed bin (18) unsigned unaligned, 2 307 2 hash_chain fixed bin (18) unsigned unaligned, 2 308 2 309 /* WORDS 5 & 6 */ 2 310 2 311 2 value bit (72) aligned; 2 312 2 313 2 314 /* CHARACTER CONSTANT NODE */ 2 315 2 316 dcl 1 char_constant aligned based structure, 2 317 2 318 /* WORD 1 */ 2 319 2 320 2 node_type fixed bin (4) unaligned, 2 321 2 data_type fixed bin (4) unaligned unsigned, 2 322 2 operand_type fixed bin (4) unaligned, 2 323 2 324 2 addressing_bits unaligned structure, 2 325 3 is_addressable bit (1), 2 326 3 value_in, 2 327 4 eaq bit (1), 2 328 4 x bit (1), 2 329 3 allocated bit (1), 2 330 3 needs_pointer bit (1), 2 331 3 stack_indirect bit (1), 2 332 3 large_address bit (1), 2 333 3 address_in_base bit (1), 2 334 3 dont_update bit (1), /* for optimizer */ 2 335 3 not_in_storage bit (1), /* for optimizer */ 2 336 3 globally_assigned bit (1), /* for optimizer */ 2 337 2 338 2 bits unaligned structure, 2 339 3 standard_bits, 2 340 4 allocate bit (1), 2 341 4 set bit (1), 2 342 4 referenced bit (1), 2 343 4 passed_as_arg bit (1), 2 344 2 345 3 no_value_stored bit (1), 2 346 2 347 3 fill bit (6), 2 348 2 349 /* WORD 2 */ 2 350 2 351 2 address aligned structure, 2 352 3 location fixed bin (18) unsigned unaligned, 2 353 3 char_num fixed bin (2) unaligned unsigned, 2 354 3 bit_num fixed bin (4) unaligned unsigned, 2 355 3 fill bit (4) unaligned, 2 356 3 inhibit bit (1) unaligned, 2 357 3 ext_base bit (1) unaligned, 2 358 3 tag bit (6) unaligned, 2 359 2 360 /* WORD 3 */ 2 361 2 362 2 units fixed bin (3) unaligned unsigned, 2 363 2 fill bit (3) unaligned, 2 364 2 reloc_hold bit (6) unaligned, 2 365 2 reloc bit (6) unaligned, 2 366 2 addr_hold bit (18) unaligned, 2 367 2 368 /* WORD 4 */ 2 369 2 370 2 next_constant fixed bin (18) unsigned unaligned, 2 371 2 hash_chain fixed bin (18) unsigned unaligned, 2 372 2 373 /* WORDS 5 thru n */ 2 374 2 375 2 length fixed bin (18) unsigned unaligned, 2 376 2 value char(char_constant_length refer(char_constant.length)) unaligned; 2 377 2 378 dcl char_constant_length fixed bin (18) unsigned; 2 379 2 380 2 381 /* DIMENSION NODE */ 2 382 2 383 dcl 1 dimension aligned based structure, 2 384 2 385 /* WORD 1 */ 2 386 2 387 2 node_type fixed bin (4) unaligned, /* The only field in common with other nodes */ 2 388 2 389 2 number_of_dims fixed bin (3) unaligned, /* Number of dimensions */ 2 390 2 391 2 v_bound (7) unaligned, /* Variable bound info - up to 7 dims. */ 2 392 3 lower bit (1) unaligned, /* On if lower bound is variable */ 2 393 3 upper bit (1) unaligned, /* On if upper bound is variable */ 2 394 2 395 2 has_virtual_origin bit (1) unaligned, /* On if virtual_origin is valid */ 2 396 2 has_array_size bit (1) unaligned, /* On if array_size is valid */ 2 397 2 has_dim_sizes bit (1) unaligned, /* On if dim.size (*) is valid */ 2 398 2 399 2 variable_virtual_origin bit (1) unaligned, /* On if virtual_origin is variable */ 2 400 2 variable_array_size bit (1) unaligned, /* On if array_size is variable */ 2 401 2 assumed_size bit (1) unaligned, /* On if array has assumed size */ 2 402 2 403 2 fill bit (7) unaligned, 2 404 2 405 /* WORD 2 */ 2 406 2 407 2 virtual_origin fixed bin (24) aligned, 2 408 2 409 /* WORD 3 */ 2 410 2 411 2 element_count fixed bin (24) aligned, 2 412 2 413 /* WORD 4 */ 2 414 2 415 2 array_size fixed bin (24) aligned, /* Expressed in symbol.units */ 2 416 2 417 /* WORD 5 */ 2 418 2 419 2 VLA_base_addressor fixed bin (18) aligned, 2 420 2 421 /* WORDS 6 - n (max = 26) */ 2 422 2 423 2 dim (num_dims refer (dimension.number_of_dims)) aligned, 2 424 2 425 3 lower_bound fixed bin (24) aligned, /* Lower bound of this dimension */ 2 426 2 427 3 upper_bound fixed bin (24) aligned, /* Upper bound of this dimension */ 2 428 2 429 3 size fixed bin (24) aligned; /* No. of elements in this dimension */ 2 430 2 431 dcl num_dims fixed bin (3); 2 432 2 433 2 434 /* HEADER NODE */ 2 435 2 436 dcl 1 header aligned based structure, 2 437 2 438 /* WORD 1 */ 2 439 2 440 2 node_type fixed bin (4) unaligned, 2 441 2 data_type fixed bin (4) unaligned unsigned, 2 442 2 operand_type fixed bin (4) unaligned, 2 443 2 444 2 addressing_bits unaligned structure, 2 445 3 is_addressable bit (1), 2 446 3 value_in, 2 447 4 eaq bit (1), 2 448 4 x bit (1), 2 449 3 allocated bit (1), 2 450 3 needs_pointer bit (1), 2 451 3 stack_indirect bit (1), 2 452 3 large_address bit (1), 2 453 3 address_in_base bit (1), 2 454 3 dont_update bit (1), /* for optimizer */ 2 455 3 not_in_storage bit (1), /* for optimizer */ 2 456 3 globally_assigned bit (1), /* for optimizer */ 2 457 2 458 2 bits unaligned structure, 2 459 3 storage_info, 2 460 4 standard_bits, 2 461 5 allocate bit (1), 2 462 5 set bit (1), 2 463 5 referenced bit (1), 2 464 5 passed_as_arg bit (1), 2 465 4 initialed bit (1), /* On if any member has initial attribute. */ 2 466 2 467 3 alignment structure unaligned, 2 468 4 even bit (1), 2 469 4 odd bit (1), 2 470 4 character bit (1), 2 471 2 472 3 storage_class structure unaligned, 2 473 4 automatic bit (1), 2 474 4 static bit (1), 2 475 4 in_common bit (1), 2 476 2 477 /* WORD 2 */ 2 478 2 479 2 address aligned structure, 2 480 3 base bit (3) unaligned, 2 481 3 offset fixed bin (14) unaligned, 2 482 3 char_num fixed bin (2) unaligned unsigned, 2 483 3 bit_num fixed bin (4) unaligned unsigned, 2 484 3 fill bit (4) unaligned, 2 485 3 inhibit bit (1) unaligned, 2 486 3 ext_base bit (1) unaligned, 2 487 3 tag bit (6) unaligned, 2 488 2 489 /* WORD 3 */ 2 490 2 491 2 units fixed bin (3) unaligned unsigned, 2 492 2 VLA bit (1) unaligned, /* chain for VLA's */ 2 493 2 LA bit (1) unaligned, /* chain for LA's */ 2 494 2 fill bit (1) unaligned, 2 495 2 reloc_hold bit (6) unaligned, 2 496 2 reloc bit (6) unaligned, 2 497 2 addr_hold bit (18) unaligned, 2 498 2 499 /* WORD 4 */ 2 500 2 501 2 next_header fixed bin (18) unsigned unaligned, 2 502 2 first_element fixed bin (18) unsigned unaligned, 2 503 2 504 /* WORD 5 */ 2 505 2 506 2 last_element fixed bin (18) unsigned unaligned, 2 507 2 name_length fixed bin (17) unaligned, 2 508 2 509 /* WORD 6 */ 2 510 2 511 2 location fixed bin (24) aligned, 2 512 2 513 /* WORD 7 */ 2 514 2 515 2 length fixed bin (24) aligned, 2 516 2 517 /* WORD 8 */ 2 518 2 519 2 VLA_base_addressor fixed bin (18) aligned, 2 520 2 521 /* WORDS 9 - n. This field is variable in length. Its length is zero for equivalence groups. */ 2 522 2 523 2 block_name char(allocate_symbol_name refer (header.name_length)) aligned; 2 524 2 525 dcl allocate_symbol_name fixed bin; 2 526 2 527 2 528 /* LABEL NODE */ 2 529 2 530 dcl 1 label aligned based structure, 2 531 2 532 /* WORD 1 */ 2 533 2 534 2 node_type fixed bin (4) unaligned, 2 535 2 data_type fixed bin (4) unaligned unsigned, 2 536 2 operand_type fixed bin (4) unaligned, 2 537 2 538 2 addressing_bits unaligned structure, 2 539 3 is_addressable bit (1), 2 540 3 value_in, 2 541 4 eaq bit (1), 2 542 4 x bit (1), 2 543 3 allocated bit (1), 2 544 3 needs_pointer bit (1), 2 545 3 stack_indirect bit (1), 2 546 3 large_address bit (1), 2 547 3 address_in_base bit (1), 2 548 3 dont_update bit (1), /* for optimizer */ 2 549 3 not_in_storage bit (1), /* for optimizer */ 2 550 3 globally_assigned bit (1), /* for optimizer */ 2 551 2 552 2 bits unaligned structure, 2 553 3 storage_info, 2 554 4 standard_bits, 2 555 5 allocate bit (1), 2 556 5 set bit (1), 2 557 5 referenced bit (1), 2 558 5 passed_as_arg bit (1), 2 559 4 referenced_executable bit (1), 2 560 2 561 3 usage, /* Label is on a non-executable stmnt if both bits are ON. */ 2 562 4 format bit (1), 2 563 4 executable bit (1), 2 564 2 565 3 restore_prs bit (1), 2 566 3 not_referencable bit (1), 2 567 3 branched_to bit (1), 2 568 3 ends_do_loop bit (1), 2 569 2 570 /* WORD 2 */ 2 571 2 572 2 address aligned structure, 2 573 3 location fixed bin (18) unsigned unaligned, 2 574 3 op bit (10) unaligned, 2 575 3 inhibit bit (1) unaligned, 2 576 3 ext_base bit (1) unaligned, 2 577 3 tag bit (6) unaligned, 2 578 2 579 /* WORD 3 */ 2 580 2 581 2 units fixed bin (3) unaligned unsigned, 2 582 2 fill bit (3) unaligned, 2 583 2 reloc_hold bit (6) unaligned, 2 584 2 reloc bit (6) unaligned, 2 585 2 addr_hold bit (18) unaligned, 2 586 2 587 /* WORD 4 */ 2 588 2 589 2 next_label fixed bin (18) unsigned unaligned, 2 590 2 hash_chain fixed bin (18) unsigned unaligned, 2 591 2 592 /* WORD 5 */ 2 593 2 594 2 format_var fixed bin (18) unsigned unaligned, 2 595 2 name fixed bin (17) unaligned, 2 596 2 597 /* WORD 6 */ 2 598 2 599 2 statement fixed bin (18) unsigned unaligned, 2 600 2 loop_end fixed bin (18) unsigned unaligned; 2 601 2 602 2 603 /* LIBRARY NODE */ 2 604 2 605 dcl 1 library aligned based structure, 2 606 2 607 /* WORD 1 */ 2 608 2 609 2 node_type fixed bin (4) unaligned, /* The only field in common with the other nodes. */ 2 610 2 fill bit (13) unaligned, 2 611 2 next_library_node fixed bin (18) unsigned unaligned, 2 612 2 613 /* WORD 2 */ 2 614 2 615 2 character_operand fixed bin (18) unsigned aligned; 2 616 2 617 2 618 /* MACHINE_STATE NODE */ 2 619 2 620 dcl 1 machine_state aligned based structure, 2 621 2 622 /* WORD 1 */ 2 623 2 624 2 node_type fixed bin (4) unal, 2 625 2 pad bit (31) unal, 2 626 2 627 /* WORD 2 */ 2 628 2 629 2 next pointer unaligned, 2 630 2 631 /* WORDS 3-104 */ 2 632 2 633 2 ms aligned, 2 634 2 635 3 eaq (4), /* One for each of the A, Q, EAQ, and IND */ 2 636 4 name fixed bin, 2 637 4 number fixed bin, 2 638 4 variable(4) fixed bin (18), 2 639 4 reserved bit (1) aligned, 2 640 3 rounded bit (1) aligned, 2 641 3 indicators_valid fixed bin (18), 2 642 2 643 3 value_in_xr bit (1) aligned, 2 644 2 645 3 index_regs(0:7), 2 646 4 bits structure unaligned, 2 647 5 global bit (1), 2 648 5 reserved bit (1), 2 649 5 mbz bit (34), 2 650 4 type fixed bin (18), 2 651 4 variable fixed bin (18), 2 652 4 used fixed bin (18), 2 653 4 mbz fixed bin (18), 2 654 2 655 3 address_in_base bit (1) aligned, 2 656 2 657 3 base_regs(0:7), 2 658 4 bits structure unaligned, 2 659 5 global bit (1), 2 660 5 reserved bit (1), 2 661 5 mbz bit (34), 2 662 4 type fixed bin (18), 2 663 4 variable fixed bin (18), 2 664 4 used fixed bin (18), 2 665 4 offset fixed bin (18), 2 666 2 667 3 stack_extended bit (1) aligned, 2 668 3 last_dynamic_temp fixed bin (18); 2 669 2 670 /* POINTER NODE */ 2 671 2 672 dcl 1 pointer aligned based structure, 2 673 2 674 /* WORD 1 */ 2 675 2 676 2 node_type fixed bin (4) unaligned, 2 677 2 pad bit (4) unaligned, 2 678 2 code fixed bin (9) unaligned unsigned, 2 679 2 variable fixed bin (18) unaligned unsigned, 2 680 2 681 /* WORD 2 */ 2 682 2 683 2 offset fixed bin (18) unaligned unsigned, 2 684 2 count fixed bin (18) unaligned unsigned, 2 685 2 686 /* WORD 3 */ 2 687 2 688 2 hash_chain fixed bin (18) aligned; 2 689 2 690 2 691 /* SOURCE NODE */ 2 692 2 693 dcl 1 source aligned based structure, 2 694 2 695 /* WORD 1 */ 2 696 2 697 2 node_type fixed bin (4) unal, 2 698 2 pad bit (13) unal, 2 699 2 line_number fixed bin (17) unaligned, 2 700 2 701 /* WORD 2 */ 2 702 2 703 2 uid bit (36) aligned, 2 704 2 705 /* WORDS 3 & 4 */ 2 706 2 707 2 dtm fixed bin (71) unaligned, 2 708 2 709 /* WORD 5 */ 2 710 2 711 2 next fixed bin (18) unsigned unaligned, 2 712 2 initial_subprogram fixed bin (18) unsigned unaligned, 2 713 2 714 /* WORDS 6 - ? (depends on length of pathname) */ 2 715 2 716 2 pathname char(256) varying; 2 717 2 718 2 719 /* STATEMENT NODE - This node only appears in the polish. */ 2 720 2 721 dcl 1 statement aligned based structure, 2 722 2 723 /* WORD 1 */ 2 724 2 725 2 op_code fixed bin aligned, /* Always equal to "stat_op". */ 2 726 2 727 /* WORD 2 */ 2 728 2 729 2 next bit (18) unaligned, /* "0"b = no next stmnt */ 2 730 2 location bit (18) unaligned, /* (18)"1"b = no text */ 2 731 2 732 /* WORD 3 */ 2 733 2 734 2 source_id structure unaligned, 2 735 3 file fixed bin (8) unsigned, /* 0 = first file */ 2 736 3 line bit (14), 2 737 3 statement bit (5), /* 1 = first statement */ 2 738 2 739 2 length bit (9) unaligned, 2 740 2 741 /* WORD 4 */ 2 742 2 743 2 bits structure unaligned, 2 744 3 put_in_map bit (1) unaligned, 2 745 3 put_in_profile bit (1) unaligned, 2 746 3 pad bit (7) unaligned, 2 747 2 748 2 start fixed bin (26) unaligned; 2 749 2 750 2 751 /* SUBPROGRAM NODE */ 2 752 2 753 dcl 1 subprogram aligned based structure, 2 754 2 755 /* WORD 1 */ 2 756 2 757 2 node_type fixed bin (4) unaligned, /* The only field in common with the other nodes. */ 2 758 2 subprogram_type fixed bin (3) unaligned, 2 759 2 default_is unaligned, 2 760 3 auto bit (1), 2 761 3 static bit (1), 2 762 2 need_PS bit (1) unaligned, 2 763 2 need_prologue bit (1) unaligned, 2 764 2 multiple_entry bit (1) unaligned, 2 765 2 namelist_used bit (1) unaligned, 2 766 2 has_parameters bit (1) unaligned, 2 767 2 star_extent_function bit (1) unaligned, 2 768 2 fill bit (1) unaligned, 2 769 2 770 2 symbol fixed bin (18) unsigned unaligned, /* symbol node for subprogram name */ 2 771 2 772 /* WORD 2 */ 2 773 2 774 2 previous_subprogram fixed bin (18) unsigned unaligned, 2 775 2 next_subprogram fixed bin (18) unsigned unaligned, 2 776 2 777 /* WORD 3 */ 2 778 2 779 2 common_chain fixed bin (18) unsigned unaligned, 2 780 2 equiv_chain fixed bin (18) unsigned unaligned, 2 781 2 782 /* WORD 4 */ 2 783 2 784 2 first_symbol fixed bin (18) unsigned unaligned, 2 785 2 last_symbol fixed bin (18) unsigned unaligned, 2 786 2 787 /* WORD 5 */ 2 788 2 789 2 first_label fixed bin (18) unsigned unaligned, 2 790 2 last_label fixed bin (18) unsigned unaligned, 2 791 2 792 /* WORD 6 */ 2 793 2 794 2 first_polish fixed bin (18) unsigned unaligned, 2 795 2 last_polish fixed bin (18) unsigned unaligned, 2 796 2 797 /* WORD 7 */ 2 798 2 799 2 map unaligned, 2 800 3 first fixed bin (18) unsigned unaligned, 2 801 3 last fixed bin (18) unsigned unaligned, 2 802 2 803 /* WORD 8 */ 2 804 2 805 2 entry_info fixed bin (18) unsigned unaligned, 2 806 2 runtime fixed bin (18) unsigned unaligned, 2 807 2 808 /* WORD 9 */ 2 809 2 810 2 first_quad fixed bin (18) unsigned unaligned, 2 811 2 last_quad fixed bin (18) unsigned unaligned, 2 812 2 813 /* WORD 10 */ 2 814 2 815 2 options aligned like fortran_options, 2 816 2 817 /* WORDS 11 - 44 */ 2 818 2 819 2 storage_info(17) aligned, 2 820 3 first fixed bin (18) unsigned unaligned, 2 821 3 last fixed bin (18) unsigned unaligned, 2 822 3 next_loc fixed bin (18) aligned, 2 823 2 824 /* WORD 45 */ 2 825 2 826 2 loop_vector_p pointer unaligned, 2 827 2 828 /* WORD 46 */ 2 829 2 830 2 n_loops fixed bin (18) unsigned unaligned, 2 831 2 max_operators fixed bin (18) unsigned unaligned, 2 832 2 833 /* WORD 47 */ 2 834 2 835 2 VLA_chain fixed bin (18) unsigned unaligned, /* Mod 1 */ 2 836 2 LA_chain fixed bin (18) unsigned unaligned, /* Mod 1 */ 2 837 /* WORD 48 */ 2 838 2 839 2 max_sym fixed bin (18) aligned; 2 840 2 841 2 842 /* SYMBOL NODE */ 2 843 2 844 dcl 1 symbol aligned based structure, 2 845 2 846 /* WORD 1 */ 2 847 2 848 2 node_type fixed bin (4) unaligned, 2 849 2 data_type fixed bin (4) unaligned unsigned, 2 850 2 operand_type fixed bin (4) unaligned, 2 851 2 852 2 addressing_bits unaligned structure, 2 853 3 is_addressable bit (1), 2 854 3 value_in, 2 855 4 eaq bit (1), 2 856 4 x bit (1), 2 857 3 allocated bit (1), 2 858 3 needs_pointer bit (1), 2 859 3 stack_indirect bit (1), 2 860 3 large_address bit (1), 2 861 3 address_in_base bit (1), 2 862 3 dont_update bit (1), /* for optimizer */ 2 863 3 not_in_storage bit (1), /* for optimizer */ 2 864 3 globally_assigned bit (1), /* for optimizer */ 2 865 2 866 2 bits unaligned structure, 2 867 3 storage_info, 2 868 4 standard_bits, 2 869 5 allocate bit (1), 2 870 5 set bit (1), 2 871 5 referenced bit (1), 2 872 5 passed_as_arg bit (1), 2 873 4 initialed bit (1), /* Allows variable to become a constant. */ 2 874 2 875 3 variable_arglist bit (1), 2 876 3 dummy_arg bit (1), 2 877 3 variable_extents bit (1), 2 878 3 needs_descriptors bit (1), 2 879 3 put_in_symtab bit (1), 2 880 3 by_compiler bit (1), 2 881 2 882 /* WORD 2 */ 2 883 2 884 2 address aligned structure, 2 885 3 base bit (3) unaligned, 2 886 3 offset fixed bin (14) unaligned, 2 887 3 char_num fixed bin (2) unaligned unsigned, 2 888 3 bit_num fixed bin (4) unaligned unsigned, 2 889 3 fill bit (4) unaligned, 2 890 3 inhibit bit (1) unaligned, 2 891 3 ext_base bit (1) unaligned, 2 892 3 tag bit (6) unaligned, 2 893 2 894 /* WORD 3 */ 2 895 2 896 2 units fixed bin (3) unaligned unsigned, 2 897 2 aliasable bit (1) unaligned, 2 898 2 has_constant_value bit (1) unaligned, 2 899 2 new_induction_var bit (1) unaligned, 2 900 2 reloc_hold bit (6) unaligned, 2 901 2 reloc bit (6) unaligned, 2 902 2 addr_hold bit (18) unaligned, 2 903 2 904 /* WORD 4 */ 2 905 2 906 2 next_symbol fixed bin (18) unsigned unaligned, 2 907 2 hash_chain fixed bin (18) unsigned unaligned, 2 908 2 909 /* WORD 5 */ 2 910 2 911 2 ext_attributes unaligned structure, 2 912 3 VLA bit (1), /* symbol is Very large Element */ 2 913 3 LA bit (1), /* symbol is Large Element */ 2 914 3 pad bit (18-2), 2 915 2 916 2 loop_ref_count fixed bin (17) unaligned, 2 917 2 918 /* WORD 6 */ 2 919 2 920 2 location fixed bin (24) aligned, 2 921 2 922 /* WORD 7 */ 2 923 2 924 2 v_length fixed bin (18) unsigned unaligned, 2 925 2 general fixed bin (18) unsigned unaligned, 2 926 2 927 /* WORD 8 */ 2 928 2 929 2 parent fixed bin (18) unsigned unaligned, 2 930 2 next_member fixed bin (18) unsigned unaligned, 2 931 2 932 /* WORD 9 */ 2 933 2 934 2 attributes aligned structure, 2 935 3 mode_bits unaligned structure, 2 936 4 char_size fixed bin (20) unsigned, 2 937 4 mode, 2 938 5 integer bit (1), 2 939 5 real bit (1), 2 940 5 double_precision bit (1), 2 941 5 complex bit (1), 2 942 5 logical bit (1), 2 943 5 character bit (1), 2 944 5 label_value bit (1), 2 945 5 entry_value bit (1), 2 946 2 947 3 misc_attributes unaligned structure, 2 948 4 function bit (1), 2 949 4 subroutine bit (1), 2 950 4 entry_point bit (1), 2 951 4 external bit (1), 2 952 4 builtin bit (1), 2 953 4 stmnt_func bit (1), 2 954 4 namelist bit (1), 2 955 4 dimensioned bit (1), 2 956 2 957 /* WORD 10 */ 2 958 2 959 3 storage_class unaligned structure, 2 960 4 automatic bit (1), 2 961 4 static bit (1), 2 962 4 in_common bit (1), 2 963 4 equivalenced bit (1), 2 964 4 parameter bit (1), 2 965 4 constant bit (1), /* If external or entry_point. */ 2 966 4 named_constant bit (1), 2 967 2 968 3 variable bit (1) unaligned, 2 969 3 in_equiv_stmnt bit (1) unaligned, 2 970 3 star_extents bit (1) unaligned, 2 971 3 descriptor bit (1) unaligned, 2 972 2 pad bit (25) unaligned, 2 973 2 974 /* WORD 11 */ 2 975 2 976 2 dimension fixed bin (18) unsigned unaligned, /* Bounds may be added after symbol is declared. */ 2 977 2 initial fixed bin (18) unsigned unaligned, 2 978 2 979 /* WORD 12 */ 2 980 2 981 2 runtime bit (18) unaligned, 2 982 2 name_length fixed bin (17) unaligned, 2 983 2 984 /* WORD 13 */ 2 985 2 986 2 coordinate fixed bin (17) unaligned, /* used by loop optimizer */ 2 987 2 element_size fixed bin (17) unaligned, 2 988 2 989 /* WORD 14 */ 2 990 2 991 2 secondary pointer unaligned, /* used by loop optimizer */ 2 992 2 993 /* WORD 15 */ 2 994 2 995 2 offset fixed bin (24) aligned, 2 996 2 997 /* WORDS 16 - n. This field is variable in length. */ 2 998 2 999 2 name char(allocate_symbol_name refer (symbol.name_length)) aligned; 2 1000 2 1001 2 1002 2 1003 /* TEMPORARY NODE -- Must be same size as ARRAY REF NODE. */ 2 1004 2 1005 dcl 1 temporary aligned based structure, 2 1006 2 1007 /* WORD 1 */ 2 1008 2 1009 2 node_type fixed bin (4) unaligned, 2 1010 2 data_type fixed bin (4) unaligned unsigned, 2 1011 2 operand_type fixed bin (4) unaligned, 2 1012 2 1013 2 addressing_bits unaligned structure, 2 1014 3 is_addressable bit (1), 2 1015 3 value_in, 2 1016 4 eaq bit (1), 2 1017 4 x bit (1), 2 1018 3 allocated bit (1), 2 1019 3 needs_pointer bit (1), 2 1020 3 stack_indirect bit (1), 2 1021 3 large_address bit (1), 2 1022 3 address_in_base bit (1), 2 1023 3 dont_update bit (1), /* for optimizer */ 2 1024 3 not_in_storage bit (1), /* for optimizer */ 2 1025 3 globally_assigned bit (1), /* for optimizer */ 2 1026 2 1027 2 bits unaligned structure, 2 1028 3 standard_bits, 2 1029 4 allocate bit (1), 2 1030 4 set bit (1), 2 1031 4 referenced bit (1), 2 1032 4 passed_as_arg bit (1), 2 1033 2 1034 3 variable_length bit (1), 2 1035 2 1036 3 fill bit (1), /* can be used */ 2 1037 2 1038 3 invariant bit (1), /* must line up with array_ref node */ 2 1039 3 irreducible bit (1), /* .. */ 2 1040 3 used_across_loops bit (1), /* .. */ 2 1041 3 frozen_for_do bit (1), 2 1042 3 used_as_subscript bit (1), 2 1043 2 1044 /* WORD 2 */ 2 1045 2 1046 2 address aligned structure, 2 1047 3 base bit (3) unaligned, 2 1048 3 offset fixed bin (14) unaligned, 2 1049 3 char_num fixed bin (2) unaligned unsigned, 2 1050 3 bit_num fixed bin (4) unaligned unsigned, 2 1051 3 fill bit (4) unaligned, 2 1052 3 inhibit bit (1) unaligned, 2 1053 3 ext_base bit (1) unaligned, 2 1054 3 tag bit (6) unaligned, 2 1055 2 1056 /* WORD 3 */ 2 1057 2 1058 2 units fixed bin (3) unaligned unsigned, 2 1059 2 fill bit (3) unaligned, 2 1060 2 reloc_hold bit (6) unaligned, 2 1061 2 reloc bit (6) unaligned, 2 1062 2 addr_hold bit (18) unaligned, 2 1063 2 1064 /* WORD 4 */ 2 1065 2 1066 2 next fixed bin (18) unsigned unaligned, 2 1067 2 loop_end_fu_pos fixed bin (17) unaligned, /* must overlay array_ref.loop_end_fu_pos */ 2 1068 2 1069 /* WORD 5 */ 2 1070 2 1071 2 pad fixed bin (18) unsigned unaligned, 2 1072 2 loop_ref_count fixed bin (17) unaligned, 2 1073 2 1074 /* WORD 6 */ 2 1075 2 1076 2 location fixed bin (24) aligned, 2 1077 2 1078 /* WORD 7*/ 2 1079 2 1080 2 ref_count fixed bin (17) unaligned, /* must overlay array_ref.ref_count */ 2 1081 2 output_by fixed bin (18) unsigned unal, /* must overlay array_ref.output_by */ 2 1082 2 1083 /* WORD 8 */ 2 1084 2 1085 2 size fixed bin (24) aligned, /* size in words */ 2 1086 2 1087 /* WORD 9 */ 2 1088 2 1089 2 start_input_to fixed bin (18) unsigned unal, /* must overlay array_ref.start_input_to */ 2 1090 2 end_input_to fixed bin (18) unsigned unal, /* must overlay array_ref.end_input_to */ 2 1091 2 1092 /* WORD 10 */ 2 1093 2 1094 2 ref_count_copy fixed bin (17) unaligned, /* must overlay array_ref.ref_count_copy */ 2 1095 2 ms_ref_count fixed bin (17) unaligned, /* counts occurances in saved machine states */ 2 1096 2 1097 /* WORD 11 */ 2 1098 2 1099 2 length fixed bin (24) aligned; /* length in characters */ 2 1100 2 1101 /* END fort_nodes.incl.pl1 */ 474 3 1 /* BEGIN fort_system_constants.incl.pl1 */ 3 2 3 3 3 4 3 5 /****^ HISTORY COMMENTS: 3 6* 1) change(86-07-14,BWong), approve(86-07-14,MCR7382), audit(86-07-17,Ginter), 3 7* install(86-07-28,MR12.0-1105): 3 8* Fix fortran bug 428. 3 9* END HISTORY COMMENTS */ 3 10 3 11 3 12 /* Created: June 1976, David Levin */ 3 13 3 14 /* Modified: 3 15* 15 Dec 85, RW - 428: Changed max_char_length from 256 to 512. 3 16* 22 Jun 84, MM - Install typeless functions support. 3 17* 17 Jun 83, HH - 383: Added 'process_param_list_op'. 3 18* 12 Jan 83, HH - Added 'form_VLA_packed_ptr_op'. 3 19* 05 Oct 82, HH - Added 'units_per_word'. 3 20* 27 Sep 82, HH - Added 'max_fixed_bin_18', 'max_fixed_bin_24' and 'sys_info$max_seg_size'. 3 21* Removed 'max_stored_value' and 'min_stored_value'. 3 22* 24 October 1981, ME Presser - added inquire_op. 3 23* 20 October 1981, C R Davis - add (read write)_internal_file_op. 3 24* 11 May 1981, Marshall Presser - added op-codes for .EQV. and .NEQV. 3 25* 28 April 1981, Marshall Presser - added default_main_entry_point_name 3 26* 11 March 1981, Marshall Presser - add min_stored_value 3 27* 8 December 1980, C R Davis - add block_if_op, else_if_op, else_op. 3 28* 15 January 1980, C R Davis - add bits_per_char. 3 29* 21 December 1979, Richard A. Barnes - add unrecoverable_errror and 3 30* max_error_level. 3 31* 3 November 1979, Richard Barnes - add pointer_node. 3 32* 17 September 1979, Richard Barnes - add load_preg_op & load_xreg_op 3 33* 13 September 1979, Paul Smee - add colon and concat token types, 3 34* change value of EOS_token, remove default_char_size. 3 35* 31 August 1979, Charlie Davis - change offset units to 3 36* be consistent with those in runtime symbols. 3 37* 13 August 1979, Richard Barnes - add cat_op & substr_op 3 38* 19 July 1979, Richard Barnes - char mode 3 39* 10 October 1978, Paul Smee - double max_stored_value and bias. 3 40* 15 June 1978, Paul Smee - add max_num_of_rands 3 41* 16 November 1977, David Levin - add machine_state_node 3 42* 12 September 1977, Richard Barnes - new ops for loop optimizer 3 43* 30 August 1977, David Levin - change bias from 65536 to 131072. 3 44* 5 July 1977, David Levin - add open_op, close_op, and iostat_op. 3 45* 28 April 1977, David Levin - add xmit_vector_op in operator list 3 46* 22 April 1977, David Levin - add max_prec_single, last_assigned_mode 3 47* 24 February 1977, Gabriel Chang for the optimizer. 3 48* 23 February 1977, David Levin to change name of count operand. 3 49* 28 October 1976, David Levin and Gabriel Chang to add 2 new ops and 3 50* 1 new node type. 3 51* 2 September 1976, David Levin - add 8 new ops and change name of 3 52* data_op. 3 53**/ 3 54 /* SYSTEM CONSTANTS */ 3 55 3 56 dcl bias init(262144) fixed bin(19) int static options(constant); 3 57 dcl gap_value init(0) fixed bin int static options(constant); 3 58 dcl max_fixed_bin_18 init(111111111111111111b) fixed bin (18) static options (constant); 3 59 dcl max_fixed_bin_24 init(111111111111111111111111b) fixed bin (24) static options (constant); 3 60 dcl max_num_of_rands init(127) fixed bin int static options(constant); 3 61 dcl sys_info$max_seg_size 3 62 fixed bin (18) ext; 3 63 3 64 dcl ( unrecoverable_error init(3), 3 65 max_error_level init(4)) 3 66 fixed bin int static options(constant); 3 67 3 68 dcl (main_program init(0), 3 69 block_data init(1), 3 70 subroutine init(2), 3 71 function init(3), 3 72 chars_per_word init(4), 3 73 chars_per_dw init(8), 3 74 bits_per_char init(9), 3 75 first_auto_loc init(64), 3 76 max_prec_single init(8)) fixed bin(9) int static options(constant); 3 77 dcl max_char_length init(512) fixed bin(10) int static options(constant); 3 78 3 79 dcl blank_common_name init("blnk*com") char(8) aligned int static options(constant); 3 80 declare default_main_entry_point_name 3 81 char (5) int static options (constant) initial ("main_"); 3 82 declare unnamed_block_data_subprg_name 3 83 char (29) int static options (constant) initial ("unnamed block data subprogram"); 3 84 3 85 /* NODE TYPES */ 3 86 3 87 dcl (fill_node init(0), 3 88 source_node init(1), 3 89 symbol_node init(2), 3 90 dimension_node init(3), 3 91 temporary_node init(4), 3 92 constant_node init(5), 3 93 label_node init(6), 3 94 header_node init(7), 3 95 char_constant_node init(8), 3 96 array_ref_node init(9), 3 97 proc_frame_node init(10), 3 98 library_node init(11), 3 99 subprogram_node init(12), 3 100 arg_desc_node init(13), 3 101 pointer_node init(14), 3 102 machine_state_node init(15)) fixed bin(4) aligned internal static options(constant); 3 103 3 104 /* DATA TYPES */ 3 105 3 106 dcl (int_mode init(1), 3 107 real_mode init(2), 3 108 dp_mode init(3), 3 109 cmpx_mode init(4), 3 110 logical_mode init(5), 3 111 char_mode init(6), 3 112 typeless_mode init(7), 3 113 last_assigned_mode init(7)) fixed bin(4) aligned internal static options(constant); 3 114 3 115 dcl data_type_size(7) init(1,1,2,2,1,0,1) fixed bin int static options(constant); 3 116 3 117 3 118 /* OPERAND TYPES */ 3 119 3 120 dcl (variable_type init(1), 3 121 constant_type init(2), 3 122 array_ref_type init(3), 3 123 temp_type init(4), 3 124 count_type init(5), 3 125 rel_constant init(6), 3 126 bif init(7), 3 127 statement_function init(8), 3 128 external init(9), 3 129 entry_type init(10), 3 130 dummy init(11), 3 131 error init(12)) fixed bin(4) aligned internal static options(constant); 3 132 3 133 3 134 /* OFFSET UNITS */ 3 135 3 136 dcl 3 137 (word_units init (0), 3 138 bit_units init (1), 3 139 char_units init (2), 3 140 halfword_units init (3)) fixed bin (3) aligned internal static options(constant); 3 141 3 142 dcl units_per_word (0:3) init (1, 36, 4, 2) fixed bin (6) static options (constant); 3 143 3 144 3 145 /* TOKEN MASKS */ 3 146 3 147 dcl 3 148 (is_operand initial("101000000"b), 3 149 is_operator initial("010000000"b), 3 150 is_constant initial("001000000"b), 3 151 is_arith_constant initial("000100000"b)) bit(9) aligned internal static options(constant); 3 152 3 153 3 154 /* TOKEN TYPES */ 3 155 3 156 dcl (no_token initial("000000000"b), 3 157 ident initial("100000000"b), 3 158 plus initial("010000001"b), 3 159 minus initial("010000010"b), 3 160 asterisk initial("010000011"b), 3 161 slash initial("010000100"b), 3 162 expon initial("010000101"b), 3 163 not initial("010000110"b), 3 164 and initial("010000111"b), 3 165 or initial("010001000"b), 3 166 eq initial("010001001"b), 3 167 ne initial("010001010"b), 3 168 lt initial("010001011"b), 3 169 gt initial("010001100"b), 3 170 le initial("010001101"b), 3 171 ge initial("010001110"b), 3 172 assign initial("010001111"b), 3 173 comma initial("010010000"b), 3 174 left_parn initial("010010001"b), 3 175 right_parn initial("010010010"b), 3 176 apostrophe initial("010010011"b), 3 177 colon initial("010010100"b), 3 178 concat initial("010010101"b), 3 179 substr_left_parn initial("010010110"b), 3 180 eqv initial("010010111"b), 3 181 neqv initial("010011000"b), 3 182 EOS_token initial("010011111"b), 3 183 char_string initial("001000001"b), 3 184 logical_const initial("001000010"b), 3 185 false initial("001000010"b), /* Must be identical to true except low order bit off. */ 3 186 true initial("001000011"b), /* Must be identical to false except low order bit on. */ 3 187 label_const initial("001000100"b), 3 188 octal_const initial("001000101"b), 3 189 dec_int initial("001100110"b), 3 190 real_const initial("001100111"b), 3 191 double_const initial("001101000"b), 3 192 complex_const initial("001101001"b)) bit(9) aligned internal static options(constant); 3 193 3 194 3 195 /* OPERATOR NAMES */ 3 196 3 197 declare 3 198 (assign_op initial(1), 3 199 add_op initial(2), 3 200 sub_op initial(3), 3 201 mult_op initial(4), 3 202 div_op initial(5), 3 203 exponentiation_op initial(6), 3 204 negate_op initial(7), 3 205 less_op initial(8), 3 206 less_or_equal_op initial(9), 3 207 equal_op initial(10), 3 208 not_equal_op initial(11), 3 209 greater_or_equal_op initial(12), 3 210 greater_op initial(13), 3 211 or_op initial(14), 3 212 and_op initial(15), 3 213 not_op initial(16), 3 214 jump_op initial(17), 3 215 jump_logical_op initial(18), 3 216 jump_arithmetic_op initial(19), 3 217 jump_computed_op initial(20), 3 218 jump_assigned_op initial(21), 3 219 assign_label_op initial(22), 3 220 read_op initial(23), 3 221 write_op initial(24), 3 222 format_op initial(25), 3 223 end_label_op initial(26), 3 224 error_label_op initial(27), 3 225 xmit_scalar_op initial(28), 3 226 xmit_array_op initial(29), 3 227 xmit_vector_op initial(30), 3 228 endfile_op initial(31), 3 229 rewind_op initial(32), 3 230 backspace_op initial(33), 3 231 margin_op initial(34), 3 232 openfile_op initial(35), 3 233 closefile_op initial(36), 3 234 record_number_op initial(37), 3 235 string_op initial(38), 3 236 string_length_op initial(39), 3 237 terminate_op initial(40), 3 238 return_op initial(41), 3 239 pause_op initial(42), 3 240 stop_op initial(43), 3 241 item_op initial(44), 3 242 exit_op initial(45), 3 243 eol_op initial(46), 3 244 do_op initial(47), 3 245 builtin_op initial(48), 3 246 sf_op initial(49), 3 247 sf_def_op initial(50), 3 248 subscript_op initial(51), 3 249 func_ref_op initial(52), 3 250 block_data_op initial(53), 3 251 increment_polish_op initial(54), 3 252 main_op initial(55), 3 253 func_op initial(56), 3 254 subr_op initial(57), 3 255 stat_op initial(58), 3 256 label_op initial(59), 3 257 call_op initial(60), 3 258 chain_op initial(61), 3 259 endunit_op initial(62), 3 260 non_executable initial(63), 3 261 no_op initial(64), 3 262 form_VLA_packed_ptr_op initial(65), 3 263 opt_subscript_op initial(66), 3 264 left_shift_op initial(67), 3 265 right_shift_op initial(68), 3 266 store_zero_op initial(69), 3 267 storage_add_op initial(70), 3 268 storage_sub_op initial(71), 3 269 neg_storage_add_op initial(72), 3 270 storage_add_one_op initial(73), 3 271 namelist_op initial(74), 3 272 open_op initial(75), 3 273 close_op initial(76), 3 274 iostat_op initial(77), 3 275 convert_to_int_op initial(78), 3 276 convert_to_real_op initial(79), 3 277 convert_to_dp_op initial(80), 3 278 convert_to_cmpx_op initial(81), 3 279 read_scalar_op initial(82), 3 280 read_array_op initial(83), 3 281 read_vector_op initial(84), 3 282 write_scalar_op initial(85), 3 283 write_array_op initial(86), 3 284 write_vector_op initial(87), 3 285 jump_true_op initial(88), 3 286 jump_false_op initial(89), 3 287 sub_index_op initial(90), 3 288 loop_end_op initial(91), 3 289 read_namelist_op initial(92), 3 290 write_namelist_op initial(93), 3 291 decode_string_op initial(94), 3 292 encode_string_op initial(95), 3 293 cat_op initial(96), 3 294 substr_op initial(97), 3 295 load_xreg_op initial(98), 3 296 load_preg_op initial(99), 3 297 block_if_op initial(100), 3 298 else_if_op initial(101), 3 299 else_op initial(102), 3 300 equiv_op initial (103), 3 301 not_equiv_op initial (104), 3 302 read_internal_file_op initial (105), 3 303 write_internal_file_op initial (106), 3 304 inquire_op initial (107), 3 305 process_param_list_op initial (108), 3 306 lhs_fld_op initial (109), 3 307 last_assigned_op initial (109)) fixed bin(18) internal static options(constant); 3 308 3 309 /* END fort_system_constants.incl.pl1 */ 475 476 477 dcl 1 shared_globals structure aligned based (shared_struc_ptr), 4 1 4 2 /* BEGIN fort_shared_vars.incl.pl1 */ 4 3 4 4 4 5 4 6 /****^ HISTORY COMMENTS: 4 7* 1) change(86-07-14,BWong), approve(86-07-14,MCR7286), audit(86-07-17,Ginter), 4 8* install(86-07-28,MR12.0-1105): 4 9* Fix fortran bug 463. 4 10* END HISTORY COMMENTS */ 4 11 4 12 4 13 /* Created: June 1976, David Levin 4 14* 4 15* Modified: 30 Aug 76, David Levin - to add global variables for listing segment. 4 16* Modified: 22 Nov 76, Richard Barnes - to add profile_size 4 17* Modified: 24 Feb 77, Gabriel Chang - for the optimizer 4 18* Modified: 06 Oct 77, Richard Barnes - for the loop optimizer 4 19* Modified: 16 Nov 77, David Levin - add next_free_(temp array_ref). 4 20* Modified: 09 Oct 78, Paul Smee - for larger common and arrays. 4 21* Modified: 03 Apr 79, Paul Smee - add list of include file data. 4 22* Modified: 17 May 79, Paul Smee - add cur_statement_list. 4 23* Modified: 28 Jun 79, Paul Smee - add compile-time math entry arrays. 4 24* Modified: 13 Sep 79, Paul Smee - add default_char_size. 4 25* Modified: 18 Dec 79, Richard Barnes - add free and freei 4 26* Modified: 03 Mar 80, C R Davis - add must_save_stack_extent. 4 27* Modified: 15 Mar 82, T G Oke - add source (line_number, file_number). 4 28* Modified: 20 Sept 82, T G Oke - add VLA_is_256K flag 4 29* Modified: 22 Sept 82, T G Oke - add area creation info to pass to 4 30* listing generator. 4 31* Modified: 17 May 83, M Mabey - add declared_options. 4 32* Modified: 02 Aug 85, B Wong - 463: changed 'must_save_stack_extent' 4 33* to 'pad' since the variable is no longer used. 4 34**/ 4 35 4 36 2 polish_base ptr, 4 37 2 operand_base ptr, 4 38 2 object_base ptr, 4 39 2 quadruple_base ptr, 4 40 2 opt_base ptr, 4 41 2 relocation_base ptr, 4 42 4 43 2 cref_base ptr, /* base of cross reference segment */ 4 44 2 source_line_base ptr, /* base of source line offset segment */ 4 45 2 listing_base ptr, /* base of listing info segment */ 4 46 2 cur_listing ptr, /* points to listing info for the active subprogram */ 4 47 4 48 2 free(2:4) ptr, /* free chains for optimizer */ 4 49 2 freei ptr, /* .. */ 4 50 4 51 2 polish_max_len fixed bin (19), 4 52 2 operand_max_len fixed bin (19), 4 53 2 object_max_len fixed bin (19), 4 54 2 quad_max_len fixed bin (19), 4 55 2 opt_max_len fixed bin (19), 4 56 4 57 2 next_free_polish fixed bin (18), 4 58 2 next_free_operand fixed bin (18), 4 59 2 next_free_object fixed bin (18), 4 60 2 next_free_listing fixed bin (18), 4 61 2 next_free_quad fixed bin (18), 4 62 2 next_free_array_ref fixed bin (18), /* Chain for freed array_ref nodes. */ 4 63 2 next_free_temp fixed bin (18), /* Chain for freed temporary nodes. */ 4 64 2 next_free_opt fixed bin (18), 4 65 4 66 2 first_segment fixed bin, 4 67 2 number_of_source_segments fixed bin (8), 4 68 2 number_of_lines fixed bin, 4 69 2 number_of_crefs fixed bin, 4 70 2 profile_size fixed bin, 4 71 4 72 2 main_entry_point_name char (32) varying, 4 73 4 74 2 cur_statement fixed bin (18), 4 75 2 cur_statement_list fixed bin (17), 4 76 2 cur_subprogram fixed bin (18), 4 77 2 first_subprogram fixed bin (18), 4 78 2 last_subprogram fixed bin (18), 4 79 2 unnamed_block_data_subprogram 4 80 fixed bin (18), 4 81 2 first_entry_name fixed bin (18), 4 82 2 last_entry_name fixed bin (18), 4 83 4 84 2 constant_info (4) aligned structure, 4 85 3 constant_count fixed bin (17), 4 86 3 first_constant fixed bin (18), 4 87 3 last_constant fixed bin (18), 4 88 4 89 2 options aligned, 4 90 3 user_options aligned like fortran_options, 4 91 3 system_options aligned, 4 92 4 is_fast bit (1) unaligned, 4 93 4 namelist_used bit (1) unaligned, 4 94 4 compile_only bit (1) unaligned, 4 95 4 VLA_is_256K bit (1) unaligned, /* FLAG 255/256K code */ 4 96 4 pad bit (32) unaligned, 4 97 4 98 2 incl_data aligned, 4 99 3 incl_count fixed bin, 4 100 3 file_list (0:255), 4 101 4 source_node_offset fixed bin (18), 4 102 4 incl_len fixed bin (21), 4 103 4 incl_ptr unaligned ptr, 4 104 4 105 2 create_constant entry (fixed bin (4), bit (72) aligned) returns (fixed bin (18)) 4 106 variable, 4 107 2 create_char_constant entry (char (*)) returns (fixed bin (18)) 4 108 variable, 4 109 2 print_message entry options (variable) 4 110 variable, 4 111 2 get_next_temp_segment entry (ptr, fixed bin (18)) returns (ptr) 4 112 variable, 4 113 2 negate_round (6) entry (fixed bin (35), bit (72), bit (72), fixed bin (35)) 4 114 returns (bit (72)) variable, 4 115 2 negate_trunc (6) entry (fixed bin (35), bit (72), bit (72), fixed bin (35)) 4 116 returns (bit (72)) variable, 4 117 2 binop_round (6,6) entry (fixed bin (35), bit (72), bit (72), fixed bin (35)) 4 118 returns (bit (72)) variable, 4 119 2 binop_trunc (6,6) entry (fixed bin (35), bit (72), bit (72), fixed bin (35)) 4 120 returns (bit (72)) variable, 4 121 2 comp_parm (6,6) entry (fixed bin (35), bit (72), bit (72), fixed bin (35)) 4 122 returns (bit (72)) variable, 4 123 2 conv_round (6,6) entry (bit (72), fixed bin (35)) 4 124 returns (bit (72)) variable, 4 125 2 conv_trunc (6,6) entry (bit (72), fixed bin (35)) 4 126 returns (bit (72)) variable, 4 127 2 pad bit (1) aligned, 4 128 4 129 /* The following are used by "print_message - decode_source_id" if use_source_info set. */ 4 130 4 131 2 use_source_info bit (1) aligned, 4 132 2 source_file_number fixed bin (35), 4 133 2 source_line_number fixed bin (35), 4 134 2 Area_create_first fixed bin (18), /* start of text to do creation */ 4 135 2 Area_create_last fixed bin (18), /* Last item */ 4 136 2 Area_init_first fixed bin (18), /* start of text to init areas */ 4 137 2 Area_init_last fixed bin (18), /* Last item */ 4 138 2 declared_options aligned like fortran_declared; 4 139 4 140 dcl num_of_word_constants fixed bin (17) defined (constant_info (1).constant_count); 4 141 dcl first_word_constant fixed bin (18) defined (constant_info (1).first_constant); 4 142 dcl last_word_constant fixed bin (18) defined (constant_info (1).last_constant); 4 143 4 144 dcl num_of_dw_constants fixed bin (17) defined (constant_info (2).constant_count); 4 145 dcl first_dw_constant fixed bin (18) defined (constant_info (2).first_constant); 4 146 dcl last_dw_constant fixed bin (18) defined (constant_info (2).last_constant); 4 147 4 148 dcl num_of_char_constants fixed bin (17) defined (constant_info (3).constant_count); 4 149 dcl first_char_constant fixed bin (18) defined (constant_info (3).first_constant); 4 150 dcl last_char_constant fixed bin (18) defined (constant_info (3).last_constant); 4 151 4 152 dcl num_of_block_constants fixed bin (17) defined (constant_info (4).constant_count); 4 153 dcl first_block_constant fixed bin (18) defined (constant_info (4).first_constant); 4 154 dcl last_block_constant fixed bin (18) defined (constant_info (4).last_constant); 4 155 4 156 /* END fort_shared_vars.incl.pl1 */ 478 5 1 /* BEGIN INCLUDE FILE fort_options.incl.pl1 */ 5 2 5 3 /****^ *********************************************************** 5 4* * * 5 5* * Copyright, (C) Honeywell Information Systems Inc., 1987 * 5 6* * * 5 7* *********************************************************** */ 5 8 5 9 /****^ HISTORY COMMENTS: 5 10* 1) change(86-07-14,BWong), approve(86-07-14,MCR7382), audit(86-07-17,Ginter), 5 11* install(86-07-28,MR12.0-1105): 5 12* Fix fortran bug 473. 5 13* 2) change(87-06-23,RWaters), approve(87-06-23,MCR7703), audit(87-07-10,Huen), 5 14* install(87-08-06,MR12.1-1069): 5 15* Implemented SCP 6315: fortran error-handling argument. 5 16* END HISTORY COMMENTS */ 5 17 5 18 5 19 /* 5 20* Modified: 12 May 87 by RWaters added debug_io 5 21* Modified: 19 February 1986 by B. Wong & A. Ginter - 473.a: Correct 5 22* comments and size of pad field in fort_declared 5 23* and pad out dfast and fast bit masks to two words. 5 24* Modified: 09 October 1985 by B. Wong - 473: add VLA_auto, VLA_static, 5 25* VLA_parm, VLC, LA_auto, and LA_static. Remove VLA and LA. 5 26* Modified: 28 March 1984 by M. Mabey - Install HFP support. 5 27* Modified: 21 September 1983 by M. Mabey - correct size of pad field in fortran_declared. 5 28* Modified: 16 May 1983 by M. Mabey - add fortran_declared 5 29* Modified: 18 December 1982 by T. Oke - Add 'long_profile'. 5 30* Modified: 22 September 1982 by T. Oke - add VLA and LA 5 31* Modified: 3 May 1982 by T. Oke - add check_multiply 5 32* Modified: 06/24/81 by S. Herbst - add do_rounding & auto_zero to fast_mask and dfast_mask 5 33* Modified: 26 February 1980 by C R Davis - add fast_mask, fix dfast_mask. 5 34* Modified: 31 January 1980 by C R Davis - add stringrange. 5 35* Modified: 13 September 1979 by Paul E. Smee--add ansi_77. 5 36* Modified: 05 December 1978 by Paul E. Smee--add do_rounding, auto_zero. 5 37* Modified: 25 January 1978 by Richard A. Barnes for the loop optimizer 5 38**/ 5 39 5 40 declare 5 41 5 42 1 fortran_options aligned based, 5 43 2 use_library bit (1) unaligned, /* (1) ON if library statements will be parsed */ 5 44 2 optimize bit (1) unaligned, /* (2) ON if optimized code is to be produced */ 5 45 2 time bit (1) unaligned, /* (3) ON for compile timing */ 5 46 2 source_format unaligned, 5 47 3 has_line_numbers bit (1) unaligned, /* (4) ON if each line begins with a line number */ 5 48 3 fold bit (1) unaligned, /* (5) ON if variable names are to be folded to lowercase */ 5 49 3 card bit (1) unaligned, /* (6) ON for card format */ 5 50 3 convert bit (1) unaligned, /* (7) ON for card format to be converted */ 5 51 2 listing unaligned, 5 52 3 source bit (1) unaligned, /* (8) ON for listing of numbered source */ 5 53 3 symbol bit (1) unaligned, /* (9) ON for listing with symbol map */ 5 54 3 map bit (1) unaligned, /* (10) ON for listing with statement map */ 5 55 3 list bit (1) unaligned, /* (11) ON for listing with assembler instructions */ 5 56 2 error_messages unaligned, 5 57 3 brief bit (1) unaligned, /* (12) ON for brief error messages */ 5 58 3 severity fixed bin (3), /* (13-16) suppresses messages below this severity */ 5 59 2 debugging unaligned, 5 60 3 subscriptrange bit (1) unaligned, /* (17) ON for subscript range checking */ 5 61 3 stringrange bit (1) unaligned, /* (18) ON for string range checking */ 5 62 3 brief_table bit (1) unaligned, /* (19) ON for statement table */ 5 63 3 table bit (1) unaligned, /* (20) ON for statement and symbol table */ 5 64 3 profile bit (1) unaligned, /* (21) ON to generate code to meter statements */ 5 65 3 check bit (1) unaligned, /* (22) ON for syntactic and semantic checking only */ 5 66 2 system_debugging unaligned, 5 67 3 stop_after_cg bit (1) unaligned, /* (23) ON if debug stop after code generator */ 5 68 3 stop_after_parse bit (1) unaligned, /* (24) ON if debug stop after parse */ 5 69 2 relocatable bit (1) unaligned, /* (25) ON if relocatable object segment generated */ 5 70 2 optimizing unaligned, 5 71 3 time_optimizer bit (1) unaligned, /* (26) ON if timings for optimizer requested */ 5 72 /* (27) ON if optimizer can loosen safety constraints */ 5 73 3 ignore_articulation_blocks bit (1) unaligned, 5 74 3 consolidate bit(1) unaligned, /* (28) ON if optimizer should run consolidation phase */ 5 75 2 do_rounding bit(1) unaligned, /* (29) ON if floating point round should be used */ 5 76 2 auto_zero bit(1) unaligned, /* (30) ON if auto storage should be zeroed when allocated */ 5 77 2 ansi_77 bit (1) unaligned, /* (31) ON if ansi77 rules are to be followed */ 5 78 2 check_multiply bit (1) unaligned, /* (32) ON if check integer multiply extent */ 5 79 2 VLA_auto bit (1) unaligned, /* (33) ON if auto VLA's being done */ 5 80 2 VLA_parm bit (1) unaligned, /* (34) ON if parm VLA's being done */ 5 81 2 VLA_static bit (1) unaligned, /* (35) ON if static VLA's being done */ 5 82 2 VLC bit (1) unaligned, /* (36) ON if VLC's being done */ 5 83 2 LA_auto bit (1) unaligned, /* (1) ON if auto LA's being done */ 5 84 2 LA_static bit (1) unaligned, /* (2) ON if static LA's being done */ 5 85 2 long_profile bit (1) unaligned, /* (3) ON to generate long_profile */ 5 86 2 static_storage bit (1) unaligned, /* (4) ON if static storage */ 5 87 2 hfp bit (1) unaligned, /* (5) ON if using hex floating point math */ 5 88 2 debug_io bit (1) unaligned, /* (6) */ 5 89 2 pad bit(30) unaligned; /* (7-36) Pad bits */ 5 90 5 91 declare 5 92 5 93 1 fortran_declared aligned based, 5 94 2 ansi66 bit(1) unaligned, /* (1) First word */ 5 95 2 ansi77 bit(1) unaligned, /* (2) */ 5 96 2 auto bit(1) unaligned, /* (3) */ 5 97 2 auto_zero bit(1) unaligned, /* (4) */ 5 98 2 brief bit(1) unaligned, /* (5) */ 5 99 2 binary_floating_point bit(1) unaligned, /* (6) */ 5 100 2 brief_table bit(1) unaligned, /* (7) */ 5 101 2 card bit(1) unaligned, /* (8) */ 5 102 2 check bit(1) unaligned, /* (9) */ 5 103 2 check_multiply bit(1) unaligned, /* (10) */ 5 104 2 consolidate bit(1) unaligned, /* (11) */ 5 105 2 debug bit(1) unaligned, /* (12) */ 5 106 2 debug_cg bit(1) unaligned, /* (13) */ 5 107 2 debug_io bit(1) unaligned, /* (14) */ 5 108 2 default_full bit(1) unaligned, /* (15) */ 5 109 2 default_safe bit(1) unaligned, /* (16) */ 5 110 2 fold bit(1) unaligned, /* (17) */ 5 111 2 free bit(1) unaligned, /* (18) */ 5 112 2 full_optimize bit(1) unaligned, /* (19) */ 5 113 2 hexadecimal_floating_point bit(1) unaligned, 5 114 /* (20) */ 5 115 2 la_auto bit(1) unaligned, /* (21) */ 5 116 2 la_static bit(1) unaligned, /* (22) */ 5 117 2 large_array bit(1) unaligned, /* (23) */ 5 118 2 line_numbers bit(1) unaligned, /* (24) */ 5 119 2 list bit(1) unaligned, /* (25) */ 5 120 2 long bit(1) unaligned, /* (26) */ 5 121 2 long_profile bit(1) unaligned, /* (27) */ 5 122 2 map bit(1) unaligned, /* (28) */ 5 123 2 no_auto_zero bit(1) unaligned, /* (29) */ 5 124 2 no_check bit(1) unaligned, /* (30) */ 5 125 2 no_fold bit(1) unaligned, /* (31) */ 5 126 2 no_large_array bit(1) unaligned, /* (32) */ 5 127 2 no_line_numbers bit(1) unaligned, /* (33) */ 5 128 2 no_map bit(1) unaligned, /* (34) */ 5 129 2 no_optimize bit(1) unaligned, /* (35) */ 5 130 2 no_check_multiply bit(1) unaligned, /* (36) */ 5 131 2 no_debug_io bit(1) unal, /* (1) Second Word */ 5 132 2 no_stringrange bit(1) unaligned, /* (2) */ 5 133 2 no_subscriptrange bit(1) unaligned, /* (3) */ 5 134 2 no_table bit(1) unaligned, /* (4) */ 5 135 2 no_very_large_array bit(1) unaligned, /* (5) */ 5 136 2 no_vla_parm bit(1) unaligned, /* (6) */ 5 137 2 no_version bit(1) unaligned, /* (7) */ 5 138 2 non_relocatable bit(1) unaligned, /* (8) */ 5 139 2 optimize bit(1) unaligned, /* (9) */ 5 140 2 profile bit(1) unaligned, /* (10) */ 5 141 2 relocatable bit(1) unaligned, /* (11) */ 5 142 2 round bit(1) unaligned, /* (12) */ 5 143 2 safe_optimize bit(1) unaligned, /* (13) */ 5 144 2 severity fixed bin(3) unaligned, /* (14-16) */ 5 145 2 static bit(1) unaligned, /* (17) */ 5 146 2 stringrange bit(1) unaligned, /* (18) */ 5 147 2 subscriptrange bit(1) unaligned, /* (19) */ 5 148 2 table bit(1) unaligned, /* (20) */ 5 149 2 time bit(1) unaligned, /* (21) */ 5 150 2 time_ot bit(1) unaligned, /* (22) */ 5 151 2 top_down bit(1) unaligned, /* (23) */ 5 152 2 truncate bit(1) unaligned, /* (24) */ 5 153 2 version bit(1) unaligned, /* (25) */ 5 154 2 very_large_array bit(1) unaligned, /* (26) */ 5 155 2 very_large_common bit(1) unaligned, /* (27) */ 5 156 2 vla_auto bit(1) unaligned, /* (28) */ 5 157 2 vla_parm bit(1) unaligned, /* (29) */ 5 158 2 vla_static bit(1) unaligned, /* (30) */ 5 159 2 pad bit(6) unaligned; /* (31-36) */ 5 160 5 161 5 162 declare /* Options used by DFAST */ 5 163 5 164 dfast_mask bit (72) internal static options (constant) initial ("100110000000000010100000000011"b); 5 165 /* use_library, has_line_numbers, fold, subscriptrange, brief_table */ 5 166 5 167 5 168 declare /* Options used by FAST */ 5 169 5 170 fast_mask bit (72) internal static options (constant) initial ("000100000000000010100000000011"b); 5 171 /* has_line_numbers, subscriptrange, brief_table */ 5 172 5 173 /* END INCLUDE FILE fort_options.incl.pl1 */ 479 480 481 if hbound (op_class, 1) ^= last_assigned_op | hbound (xop_class, 1) ^= last_assigned_op 482 then do; 483 call print_message (382, "The size of the op_class array", "last_assigned_op"); 484 return; 485 end; 486 487 shared_struc_ptr = pt1; 488 489 operand_max_len = shared_globals.operand_max_len; 490 quad_max_len = shared_globals.quad_max_len; 491 opt_max_len = shared_globals.opt_max_len; 492 polish_max_len = shared_globals.polish_max_len; 493 494 operand_base = shared_globals.operand_base; 495 quadruple_base = shared_globals.quadruple_base; 496 opt_base = shared_globals.opt_base; 497 polish_base = shared_globals.polish_base; 498 499 max_operands = 10b ** length (unspec (null -> operator.number)) - 1; 500 501 meter_hash_buckets = "0"b; 502 503 consolidating = "0"b; 504 505 p_list (*) = null; 506 bt_list (*) = null; 507 508 hash_mask = "0"b; 509 510 free (*) = null; 511 512 s_list, freei, freep, freep_tail, freesrv, init_frame, loop_entry_list, entry_unit, exit_unit, adam_loop, 513 freefu, init_lp_frame = null; 514 515 n_loops = 0; 516 517 timing_info.last_section = 0; 518 max_n_sym, max_n_loops, max_n_flow_units = 0; 519 520 allocate_symbol_name = 0; 521 522 zero = 0; 523 zero = create_constant (int_mode, unspec (zero)); 524 525 one = 1; 526 one = create_constant (int_mode, unspec (one)); 527 onep = addr (rands (one)); 528 529 full_strength_reduction = "1"b; 530 531 /* MAIN OPTIMIZATION LOOP */ 532 533 do cur_subprogram = first_subprogram repeat cs -> subprogram.next_subprogram while (cur_subprogram > 0); 534 cs = addr (rands (cur_subprogram)); 535 536 need_consolidation_pass = cs -> subprogram.options.consolidate; 537 538 if cs -> subprogram.options.ignore_articulation_blocks 539 then always_safe_to_move_class = unlikely_to_fault_class; 540 else always_safe_to_move_class = cannot_fault_class; 541 542 do_timings = cs -> subprogram.options.time_optimizer; 543 544 call timer (1); 545 546 call assign_symbol_coordinates; 547 548 call timer (2); 549 550 call build_flow_units; 551 552 call timer (3); 553 554 call flow_analysis; 555 556 call timer (4); 557 558 call optimize_subprogram; 559 560 call timer (10); 561 562 call index_value_analysis; 563 564 max_n_sym = max (max_n_sym, n_sym); 565 max_n_loops = max (max_n_loops, n_loops); 566 max_n_flow_units = max (max_n_flow_units, n_flow_units); 567 568 end; 569 570 call timer (0); 571 572 if do_timings 573 then do; 574 total_vcpu = float (sum (timing_info.vcpu (*))); 575 total_pf = sum (timing_info.pf (*)); 576 577 call ioa_ ("Section CPU % Pages"); 578 579 do i = 1 to hbound (section, 1); 580 tx = float (timing_info.vcpu (i)); 581 call ioa_ ("^27a^9.3f^6.1f^6d", section (i), tx / 1.0e6, 100e0 * tx / total_vcpu, timing_info.pf (i)); 582 end; 583 584 call ioa_ ("TOTAL ^9.3f ^6d", total_vcpu / 1.0e6, total_pf); 585 call ioa_ ("^/max(symbols):^-^d^/max(loops):^-^d^/max(flow_units):^-^d", max_n_sym, max_n_loops, 586 max_n_flow_units); 587 588 end; 589 590 shared_globals.free (*) = free (*); 591 shared_globals.freei = freei; 592 593 return; 594 595 timer: 596 procedure (i); 597 598 /* timing routine */ 599 600 dcl i fixed binary (18); 601 602 dcl vcpu fixed binary (71); 603 dcl (pf, last, dummy) fixed binary (18); 604 dcl cpu_time_and_paging_ entry (fixed bin (18), fixed bin (71), fixed bin (18)); 605 606 if ^do_timings 607 then return; 608 609 if timing_info.last_section = 0 610 then do; 611 call cpu_time_and_paging_ (timing_info.last_pf, timing_info.last_vcpu, dummy); 612 timing_info.vcpu (*) = 0; 613 timing_info.pf (*) = 0; 614 end; 615 616 else do; 617 call cpu_time_and_paging_ (pf, vcpu, dummy); 618 last = timing_info.last_section; 619 timing_info.vcpu (last) = timing_info.vcpu (last) + (vcpu - timing_info.last_vcpu); 620 timing_info.pf (last) = timing_info.pf (last) + (pf - timing_info.last_pf); 621 timing_info.last_vcpu = vcpu; 622 timing_info.last_pf = pf; 623 end; 624 625 timing_info.last_section = i; 626 627 end timer; 628 629 assign_symbol_coordinates: 630 procedure (); 631 632 /* assigns coordinates to the symbols for use with the bit masks */ 633 634 dcl (s, h, ea, equiv_array_chain, equiv_array_tail) pointer; 635 dcl (i, hdr, sym) fixed binary (18); 636 dcl has_parameters bit (1) aligned; 637 638 dcl 1 initial aligned based, 639 2 next fixed binary (18), 640 2 limit fixed binary (18), 641 2 value fixed binary (18); 642 643 has_parameters = cs -> subprogram.has_parameters; 644 equiv_array_chain, equiv_array_tail = null; 645 646 /* symbols in common whose space is not overlapped by that of other symbols 647* get unique coordinates */ 648 649 /* loop to turn on in_equiv_stmnt for all symbols in common that might be overlapped 650* by equivalenced arrays */ 651 652 do hdr = cs -> subprogram.common_chain repeat h -> header.next_header while (hdr > 0); 653 h = addr (rands (hdr)); 654 655 do sym = h -> header.first_element repeat s -> symbol.next_member while (sym > 0); 656 s = addr (rands (sym)); 657 658 if s -> symbol.in_equiv_stmnt & s -> symbol.dimensioned 659 then do; 660 ea = create_input_to (); 661 662 ea -> equiv_array.next = equiv_array_chain; 663 equiv_array_chain = ea; 664 if equiv_array_tail = null 665 then equiv_array_tail = ea; 666 667 ea -> equiv_array.lowest = s -> symbol.offset; 668 ea -> equiv_array.highest = 669 s -> symbol.offset + addr (rands (s -> symbol.dimension)) -> dimension.array_size - 1; 670 end; 671 end; 672 673 if equiv_array_chain ^= null 674 then do; 675 do sym = h -> header.first_element repeat s -> symbol.next_member while (sym > 0); 676 s = addr (rands (sym)); 677 678 do ea = equiv_array_chain repeat ea -> equiv_array.next 679 while (^s -> symbol.in_equiv_stmnt & ea ^= null); 680 681 if s -> symbol.offset >= ea -> equiv_array.lowest 682 & s -> symbol.offset <= ea -> equiv_array.highest 683 then s -> symbol.in_equiv_stmnt = "1"b; 684 end; 685 end; 686 687 equiv_array_tail -> equiv_array.next = freei; 688 freei = equiv_array_chain; 689 equiv_array_chain, equiv_array_tail = null; 690 end; 691 end; 692 693 /* assign coordinates to all non constant referenced symbols. Parameters 694* and equivalenced symbols get coordinates depending on their data_type. */ 695 696 if last_assigned_mode ^= length (alias_mask) | last_assigned_mode ^= hbound (aliasable_mask, 1) 697 then do; 698 call print_message (382, "last_assigned_mode", "length(alias_mask)"); 699 return; 700 end; 701 702 n_sym = last_assigned_mode; 703 do sym = cs -> subprogram.first_symbol repeat s -> symbol.next_symbol while (sym > 0); 704 s = addr (rands (sym)); 705 706 s -> symbol.secondary = null; 707 708 if s -> symbol.allocate & ^s -> symbol.constant & ^s -> symbol.named_constant & ^s -> symbol.builtin 709 & ^s -> symbol.stmnt_func & ^s -> symbol.namelist 710 then do; 711 if s -> symbol.in_equiv_stmnt | s -> symbol.parameter | (s -> symbol.in_common & has_parameters) 712 then s -> symbol.aliasable = "1"b; 713 714 if (s -> symbol.static | s -> symbol.automatic) & s -> symbol.initial ^= 0 & ^s -> symbol.set 715 & ^s -> symbol.passed_as_arg & ^s -> symbol.aliasable & ^s -> symbol.dimensioned 716 then do; 717 718 /* convert the symbol into a named constant */ 719 720 s -> symbol.automatic, s -> symbol.static = "0"b; 721 s -> symbol.named_constant = "1"b; 722 s -> symbol.initial = addr (polish (s -> symbol.initial)) -> initial.value; 723 end; 724 725 else if ^s -> symbol.parameter & ^s -> symbol.in_equiv_stmnt 726 then do; 727 n_sym = n_sym + 1; 728 s -> symbol.coordinate = n_sym; 729 end; 730 else s -> symbol.coordinate = s -> symbol.data_type; 731 end; 732 end; 733 734 /* allow room for creation of more symbols (use a min of 288 until we have a way to 735* recycle str_red-created vars) */ 736 737 max_sym, cs -> subprogram.max_sym = max (36 * divide (n_sym + 89, 36, 17, 0), 288); 738 739 /* Set up aliasable_mask's, non_auto_mask, and integer_scalar_mask. */ 740 741 non_auto_mask_p = get_opt_space (size (non_auto_mask)); 742 non_auto_mask = alias_mask; 743 744 integer_scalar_mask_p = get_opt_space (size (integer_scalar_mask)); 745 746 aliasable_mask_p = get_opt_space (size (aliasable_mask)); 747 aliasable_mask (0) = alias_mask; 748 749 do i = 1 to length (alias_mask); 750 substr (aliasable_mask (i), i, 1) = "1"b; 751 end; 752 753 do sym = cs -> subprogram.first_symbol repeat s -> symbol.next_symbol while (sym > 0); 754 s = addr (rands (sym)); 755 756 if s -> symbol.coordinate > length (alias_mask) 757 then do; 758 i = s -> symbol.coordinate; 759 760 if ^s -> symbol.automatic 761 then substr (non_auto_mask, i, 1) = "1"b; 762 763 if s -> symbol.data_type = int_mode & ^s -> symbol.dimensioned 764 then substr (integer_scalar_mask, i, 1) = "1"b; 765 766 if s -> symbol.in_common 767 then do; 768 substr (aliasable_mask (s -> symbol.data_type), i, 1) = "1"b; 769 substr (aliasable_mask (0), i, 1) = "1"b; 770 end; 771 end; 772 773 end; 774 775 end assign_symbol_coordinates; 776 777 build_flow_units: 778 procedure (); 779 780 /* builds flow_units and collects variable usage information */ 781 782 dcl need_new_unit bit (1) aligned; 783 dcl (lp, o, p, st, cur_unit) pointer; 784 dcl (op, next_statement, op_code, ipol) fixed binary (17); 785 dcl i fixed binary (18); 786 dcl chaining_input bit (1) aligned; 787 788 dcl (jump_assigned_list, jump_assigned_target_list) pointer; 789 790 /* initialize */ 791 792 chaining_input = "1"b; 793 max_flow_units, n_operators, n_loops = 0; 794 795 jump_assigned_list, jump_assigned_target_list = null; 796 797 state_discarded = "1"b; 798 need_new_unit = "1"b; /* need a new unit to represent top of the program */ 799 adam_loop = create_loop (null); 800 cur_unit, entry_unit = create_flow_unit (); 801 entry_unit -> flow_unit.processed = "1"b; 802 entry_unit -> flow_unit.position, entry_unit -> flow_unit.number = 1; 803 exit_unit = create_flow_unit (); 804 805 /* loop through the statement chain to get flow information */ 806 807 do cur_statement = cs -> subprogram.first_quad repeat next_statement while (cur_statement > 0); 808 st = addr (quad (cur_statement)); 809 next_statement = fixed (st -> opt_statement.next, 18); 810 811 if st -> opt_statement.label ^= 0 812 then if addr (rands (st -> opt_statement.label)) -> label.executable 813 then if addr (rands (st -> opt_statement.label)) -> label.referenced_executable 814 /* must be a jump target */ 815 then need_new_unit = "1"b; 816 817 if need_new_unit & st -> opt_statement.put_in_map 818 /* put_in_map means executable */ 819 then call change_cur_unit; 820 821 /* process this statement's operators getting usage and flow information */ 822 823 do op = st -> opt_statement.first_operator repeat o -> operator.next while (op ^= next_statement); 824 o = addr (quad (op)); 825 op_code = o -> operator.op_code; 826 go to action (op_class (op_code)); 827 828 action (1): /* reducible */ 829 action (2): /* .. */ 830 action (3): /* .. */ 831 action (4): /* assignment */ 832 action (5): /* .. */ 833 n_operators = n_operators + 1; 834 o -> operator.coordinate = n_operators; 835 836 call use_inputs; 837 call set ((o -> operator.output), 0, "1"b); 838 go to step; 839 840 action (6): /* call & func_ref */ 841 call process_call; 842 go to step; 843 844 action (7): /* entry points */ 845 /*** We won't create a flow_unit here because one has already been 846* created before the statement loop because we are either at the top 847* of the program, or are after an unconditional jump or return. 848* ***/ 849 call link (entry_unit, cur_unit); 850 cur_unit -> flow_unit.entry_pt = "1"b; 851 go to step; 852 853 action (8): /* jump */ 854 call link_to_target (o -> operand (1)); 855 state_discarded = "1"b; 856 need_new_unit = "1"b; 857 858 if addr (rands (o -> operand (1))) -> label.statement = next_statement 859 then do; 860 861 /* special case: go to next_statement */ 862 863 o -> operator.op_code = no_op; 864 o -> operator.number = 0; 865 end; 866 867 go to step; 868 869 action (9): /* jump_arithmetic */ 870 call use_inputs; 871 do i = 2 to 4; 872 call link_to_target (o -> operand (i)); 873 end; 874 state_discarded = "1"b; 875 need_new_unit = "1"b; 876 go to step; 877 878 action (10): /* jump_computed */ 879 call use_inputs; 880 do i = 1 to o -> operator.operand (1) + bias; 881 call link_to_target (o -> operator.operand (i + 1)); 882 end; 883 need_new_unit = "1"b; 884 go to step; 885 886 action (11): /* jump_assigned */ 887 call use_inputs; 888 call add_to_jump_assigned_list; 889 state_discarded = "1"b; 890 need_new_unit = "1"b; 891 go to step; 892 893 action (12): /* jump_true, jump_false */ 894 call use_inputs; 895 call link_to_target (o -> operand (2)); 896 need_new_unit = "1"b; 897 go to step; 898 899 action (13): /* return, stop */ 900 call use_inputs; /* in case of stop n */ 901 call link (cur_unit, exit_unit); 902 state_discarded = "1"b; 903 need_new_unit = "1"b; 904 go to step; 905 906 action (14): /* error_label, end_label */ 907 call link_to_target (o -> operand (1)); 908 call link_entry_to_target; 909 addr (rands (o -> operand (1))) -> label.restore_prs = "1"b; 910 need_new_unit = "1"b; 911 go to step; 912 913 action (15): /* irreducible */ 914 cur_unit -> flow_unit.has_side_effects = "1"b; 915 916 call use_inputs; 917 call set ((o -> operator.output), 0, "1"b); 918 go to step; 919 920 action (16): /* assign_label */ 921 call set ((o -> operator.output), 0, "1"b); 922 if addr (rands (o -> operator.operand (1))) -> node.node_type = label_node 923 then do; 924 call link_entry_to_target (); 925 call add_to_jump_assigned_target_list (); 926 end; 927 go to step; 928 929 action (17): /* end_unit */ 930 st -> opt_statement.flow_unit = exit_unit; 931 call change_cur_unit; 932 go to step; 933 934 action (18): /* read_namelist */ 935 cur_unit -> flow_unit.has_side_effects = "1"b; 936 937 ipol = addr (rands (o -> operand (1))) -> symbol.initial; 938 do i = 1 to polish (ipol); 939 call set ((polish (ipol + i)), 0, "0"b); 940 end; 941 go to step; 942 943 action (19): /* write_name_list */ 944 cur_unit -> flow_unit.has_side_effects = "1"b; 945 946 ipol = addr (rands (o -> operand (1))) -> symbol.initial; 947 do i = 1 to polish (ipol); 948 call use_symbol (addr (rands (polish (ipol + i)))); 949 end; 950 go to step; 951 952 action (20): /* non_executable, no_op */ 953 go to step; 954 955 action (21): /* irreducible, partially sets */ 956 cur_unit -> flow_unit.has_side_effects = "1"b; 957 958 call use_inputs; 959 call set ((o -> operator.output), 0, "0"b); 960 961 go to step; 962 963 action (22): /* inquire */ 964 cur_unit -> flow_unit.has_side_effects = "1"b; 965 966 do i = 1 to 3; 967 call use_one_input (i); 968 end; 969 970 do i = 4 to o -> operator.number by 2; 971 if o -> operator.operand (i + 1) + bias = 4 972 /* filename */ 973 | o -> operator.operand (i + 1) + bias = 14 974 /* unit */ 975 then call use_one_input (i); 976 else call set ((o -> operator.operand (i)), i, "0"b); 977 end; 978 979 go to step; 980 981 action (0): /* unexpected operators */ 982 call print_message (383, op_code - bias); 983 984 step: 985 end; 986 987 st -> opt_statement.flow_unit = cur_unit; 988 cur_unit -> flow_unit.last_statement = cur_statement; 989 end; 990 991 /* connect all flow_units ending in jump_assigned operators with 992* all possible targets */ 993 994 995 /* connect_jump_assigneds if EITHER we had an assign or a jump_assigned_list */ 996 997 if jump_assigned_list ^= null | jump_assigned_target_list ^= null 998 then call connect_jump_assigneds; 999 1000 /* set n_flow_units */ 1001 1002 n_flow_units = exit_unit -> flow_unit.number; 1003 1004 /* allocate dominated_by bit vectors */ 1005 1006 max_flow_units = 36 * divide (n_flow_units + 55, 36, 17, 0); 1007 1008 do p = entry_unit repeat p -> flow_unit.next while (p ^= null); 1009 p -> flow_unit.dominated_by = get_opt_space (size (dbits)); 1010 end; 1011 1012 /* seg max_operators */ 1013 1014 max_operators, cs -> subprogram.max_operators = 36 * divide (n_operators + n_operators + 35, 36, 17); 1015 1016 /* allocate bit vectors in loop node */ 1017 1018 adam_loop -> loop.is_member = get_opt_space (size (dbits)); 1019 adam_loop -> loop.is_exit = get_opt_space (size (dbits)); 1020 adam_loop -> loop.articulation_blocks = get_opt_space (size (dbits)); 1021 1022 return; 1023 1024 recompute_usage: 1025 entry; 1026 1027 /* recompute_usage completely recomputes all flow_unit & loop usage bits after 1028* most optimizations have been performed. */ 1029 1030 chaining_input = "0"b; 1031 1032 /* zero out loop usage bits */ 1033 1034 do i = 1 to n_loops; 1035 lp = loop_vector (i); 1036 lp -> loop.used -> bits, lp -> loop.set -> bits, lp -> loop.busy_on_exit -> bits, 1037 lp -> loop.set_multiple -> bits = "0"b; 1038 end; 1039 1040 /* zero out all flow_unit usage bits */ 1041 1042 do cur_unit = exit_unit repeat cur_unit -> flow_unit.back while (cur_unit ^= null); 1043 cur_unit -> flow_unit.used -> bits, cur_unit -> flow_unit.set -> bits, 1044 cur_unit -> flow_unit.busy_on_entry -> bits, cur_unit -> flow_unit.set_multiple -> bits, 1045 cur_unit -> flow_unit.busy_on_exit -> bits, cur_unit -> flow_unit.always_completely_set -> bits = 1046 "0"b; 1047 end; 1048 1049 /* scan through the quads picking up new usage info */ 1050 1051 do cur_statement = cs -> subprogram.first_quad repeat next_statement while (cur_statement > 0); 1052 st = addr (quad (cur_statement)); 1053 next_statement = fixed (st -> opt_statement.next, 18); 1054 cur_unit = st -> opt_statement.flow_unit; 1055 1056 /* process the statement's operators */ 1057 1058 do op = st -> opt_statement.first_operator repeat o -> operator.next while (op ^= next_statement); 1059 o = addr (quad (op)); 1060 op_code = o -> operator.op_code; 1061 go to reaction (op_class (op_code)); 1062 1063 reaction (1): /* reducible */ 1064 reaction (2): /* .. */ 1065 reaction (3): /* .. */ 1066 reaction (4): /* assignment */ 1067 reaction (15): /* irreducible */ 1068 call use_inputs; 1069 call set ((o -> operator.output), 0, "1"b); 1070 go to restep; 1071 1072 reaction (5): /* increment */ 1073 call use_inputs; 1074 1075 p = addr (rands (o -> operator.output)); 1076 if p -> node.node_type = array_ref_node 1077 then p = addr (rands (p -> array_ref.parent)); 1078 1079 call use_symbol (p); 1080 call set ((o -> operator.output), 0, "1"b); 1081 go to restep; 1082 1083 reaction (6): /* call & func_ref */ 1084 call process_call; 1085 go to restep; 1086 1087 reaction (9): /* jump_arithmetic */ 1088 reaction (10): /* jump_computed */ 1089 reaction (11): /* jump_assigned */ 1090 reaction (12): /* jump_true, jump_false */ 1091 reaction (13): /* return, stop */ 1092 call use_inputs; 1093 go to restep; 1094 1095 reaction (16): /* assign_label */ 1096 call set ((o -> operator.output), 0, "1"b); 1097 go to restep; 1098 1099 reaction (18): /* read_namelist */ 1100 ipol = addr (rands (o -> operand (1))) -> symbol.initial; 1101 do i = 1 to polish (ipol); 1102 call set ((polish (ipol + i)), 0, "0"b); 1103 end; 1104 go to restep; 1105 1106 reaction (19): /* write_namelist */ 1107 ipol = addr (rands (o -> operand (1))) -> symbol.initial; 1108 do i = 1 to polish (ipol); 1109 call use_symbol (addr (rands (polish (ipol + i)))); 1110 end; 1111 go to restep; 1112 1113 reaction (21): /* irreducible, partially sets */ 1114 call use_inputs; 1115 call set ((o -> operator.output), 0, "0"b); 1116 1117 go to restep; 1118 1119 reaction (22): /* inquire */ 1120 do i = 1 to 3; 1121 call use_one_input (i); 1122 end; 1123 1124 do i = 4 to o -> operator.number by 2; 1125 if o -> operator.operand (i + 1) + bias = 4 1126 /* filename */ 1127 | o -> operator.operand (i + 1) + bias = 14 1128 /* unit */ 1129 then call use_one_input (i); 1130 else call set ((o -> operator.operand (i)), i, "0"b); 1131 end; 1132 1133 go to restep; 1134 1135 reaction (0): /* unexpected operators */ 1136 call print_message (383, op_code - bias); 1137 1138 reaction (7): /* entry points */ 1139 reaction (8): /* jump */ 1140 reaction (14): /* error_label, end_label */ 1141 reaction (17): /* end_unit */ 1142 reaction (20): /* non_executable, no_op */ 1143 restep: 1144 end; 1145 end; 1146 1147 /* complete data flow analysis */ 1148 1149 call analyze_data_flow; 1150 1151 return; 1152 1153 use_inputs: 1154 procedure (); 1155 1156 /* marks all input operands as used */ 1157 /* also chains temps & array_refs to their uses */ 1158 1159 dcl i fixed binary (18); 1160 1161 do i = 1 to o -> operator.number; 1162 call use_one_input (i); 1163 end; 1164 1165 end use_inputs; 1166 1167 use_one_input: 1168 procedure (iop); 1169 1170 /* Marks the specified operand as used. */ 1171 1172 dcl (iop, i, opnd) fixed binary (18); 1173 dcl p pointer; /* pointer to the node to "use" */ 1174 dcl s pointer; /* pointer to array_ref symbol nodes */ 1175 dcl q pointer; /* pointer to opt_subscript quad */ 1176 1177 i = iop; 1178 opnd = o -> operator.operand (i); 1179 1180 if opnd > 0 1181 then do; 1182 p = addr (rands (opnd)); 1183 1184 if p -> node.node_type = symbol_node 1185 then do; 1186 if p -> symbol.named_constant 1187 then do; 1188 1189 /* turn named constant into a constant */ 1190 1191 if op_code = opt_subscript_op & i = 1 1192 then addr (rands (p -> symbol.initial)) -> node.allocate = "1"b; 1193 else o -> operator.operand (i) = p -> symbol.initial; 1194 1195 /* if constant is input to opt_subscript_op, 1196* combine variable & constant offset */ 1197 1198 if op_code = opt_subscript_op & i = 3 1199 then call make_constant_opt_subscript (o); 1200 end; 1201 1202 else if i ^= 1 | op_code ^= opt_subscript_op 1203 then call use_symbol (p); 1204 end; 1205 1206 else if p -> node.node_type = temporary_node & chaining_input 1207 then call chain_input (p, o, i); 1208 1209 else if p -> node.node_type = array_ref_node 1210 then do; 1211 if chaining_input 1212 then call chain_input (p, o, i); 1213 1214 /* get address of quad which produced the array_ref node */ 1215 q = addr (quad (p -> array_ref.output_by)); 1216 1217 /* get address of variable offset if it exists */ 1218 if q -> operator.operand (3) ^= 0 1219 then do; 1220 s = addr (rands (q -> operator.operand (3))); 1221 1222 /* use temporary offset if it is a symbol */ 1223 if s -> node.node_type = symbol_node 1224 then call use_symbol (s); 1225 end; 1226 1227 /* use array which is the parent of the array ref */ 1228 s = addr (rands (p -> array_ref.parent)); 1229 call use_symbol (s); 1230 end; 1231 end; 1232 1233 end use_one_input; 1234 1235 use_symbol: 1236 procedure (s); 1237 1238 dcl s pointer; /* symbol */ 1239 dcl (c, dt, other_dt) fixed binary (18); 1240 1241 if s -> symbol.coordinate > 0 1242 then do; 1243 c = s -> symbol.coordinate; 1244 1245 substr (cur_unit -> flow_unit.used -> bits, c, 1) = "1"b; 1246 if ^substr (cur_unit -> flow_unit.always_completely_set -> bits, c, 1) 1247 then substr (cur_unit -> flow_unit.busy_on_entry -> bits, c, 1) = "1"b; 1248 1249 if s -> symbol.aliasable 1250 then do; 1251 dt = s -> symbol.data_type; 1252 1253 if s -> symbol.parameter 1254 then do; 1255 cur_unit -> flow_unit.used -> bits = cur_unit -> flow_unit.used -> bits | aliasable_mask (dt); 1256 cur_unit -> flow_unit.busy_on_entry -> bits = 1257 cur_unit -> flow_unit.busy_on_entry -> bits 1258 | (aliasable_mask (dt) & ^cur_unit -> flow_unit.always_completely_set -> bits); 1259 end; 1260 1261 else if c > length (alias_mask) 1262 then do; 1263 1264 /* the variable is in common */ 1265 1266 substr (cur_unit -> flow_unit.used -> bits, dt, 1) = "1"b; 1267 substr (cur_unit -> flow_unit.busy_on_entry -> bits, dt, 1) = "1"b; 1268 end; 1269 1270 else do; 1271 1272 /* the symbol is equivalenced. Deal with the fact that 1273* a real variable may be equivalenced with a complex 1274* variable, and both may be simultaneously defined. */ 1275 1276 if dt = real_mode 1277 then other_dt = cmpx_mode; 1278 1279 else if dt = cmpx_mode 1280 then other_dt = real_mode; 1281 1282 else other_dt = 0; 1283 1284 if other_dt > 0 1285 then do; 1286 substr (cur_unit -> flow_unit.used -> bits, other_dt, 1) = "1"b; 1287 substr (cur_unit -> flow_unit.busy_on_entry -> bits, other_dt, 1) = "1"b; 1288 end; 1289 end; 1290 end; 1291 end; 1292 1293 end use_symbol; 1294 1295 set: 1296 procedure (opnd, iop, always_sets); 1297 1298 /* turns on set & set_multiple bits for opnd */ 1299 1300 dcl opnd fixed binary (18), /* operand being set */ 1301 iop fixed binary (18), /* which operand of the operator (0 is output) */ 1302 always_sets bit (1) aligned; /* guarantees variable is set, and, if the 1303* operand if a symbol node, that the whole 1304* variable is set. */ 1305 1306 dcl (i, dt, other_dt) fixed binary (18); 1307 dcl always_completely_sets bit (1) aligned; /* guarantees entire generation of variable is set */ 1308 dcl p pointer; 1309 1310 if opnd > 0 1311 then do; 1312 always_completely_sets = always_sets; 1313 1314 p = addr (rands (opnd)); 1315 1316 if p -> node.node_type = array_ref_node 1317 then do; 1318 if op_code ^= opt_subscript_op 1319 then do; 1320 always_completely_sets = "0"b; /* sets only one array element or a substring */ 1321 if iop = 0 & chaining_input 1322 then call chain_input (p, o, 0); 1323 p = addr (rands (p -> array_ref.parent)); 1324 end; 1325 end; 1326 1327 if p -> node.node_type = symbol_node 1328 then do; 1329 i = p -> symbol.coordinate; 1330 if i > 0 1331 then do; 1332 if substr (cur_unit -> flow_unit.set -> bits, i, 1) 1333 then substr (cur_unit -> flow_unit.set_multiple -> bits, i, 1) = "1"b; 1334 else substr (cur_unit -> flow_unit.set -> bits, i, 1) = "1"b; 1335 1336 if p -> symbol.aliasable 1337 then do; 1338 dt = p -> symbol.data_type; 1339 1340 if p -> symbol.parameter 1341 then do; 1342 cur_unit -> flow_unit.set_multiple -> bits = 1343 cur_unit -> flow_unit.set_multiple -> bits 1344 | (cur_unit -> flow_unit.set -> bits & aliasable_mask (dt)); 1345 cur_unit -> flow_unit.set -> bits = 1346 cur_unit -> flow_unit.set -> bits | aliasable_mask (dt); 1347 always_completely_sets = "0"b; 1348 /* several variables share this coordinate */ 1349 end; 1350 1351 else if i > length (alias_mask) 1352 then if substr (cur_unit -> flow_unit.set -> bits, dt, 1) 1353 then substr (cur_unit -> flow_unit.set_multiple -> bits, dt, 1) = "1"b; 1354 else substr (cur_unit -> flow_unit.set -> bits, dt, 1) = "1"b; 1355 1356 else do; 1357 1358 /* equivalenced variables */ 1359 1360 always_completely_sets = "0"b; 1361 /* several variables share this coordinate */ 1362 1363 /* real and complex vars may be equivalenced 1364* and simultaneously defined */ 1365 1366 if dt = real_mode 1367 then other_dt = cmpx_mode; 1368 1369 else if dt = cmpx_mode 1370 then other_dt = real_mode; 1371 1372 else other_dt = 0; 1373 1374 if other_dt > 0 1375 then if substr (cur_unit -> flow_unit.set -> bits, other_dt, 1) 1376 then substr (cur_unit -> flow_unit.set_multiple -> bits, other_dt, 1) = "1"b; 1377 else substr (cur_unit -> flow_unit.set -> bits, other_dt, 1) = "1"b; 1378 end; 1379 end; 1380 1381 if always_completely_sets 1382 then substr (cur_unit -> flow_unit.always_completely_set -> bits, i, 1) = "1"b; 1383 end; 1384 end; 1385 end; 1386 1387 end set; 1388 1389 process_call: 1390 procedure (); 1391 1392 dcl i fixed binary (18); 1393 1394 call use_inputs; 1395 1396 /* set the arguments */ 1397 1398 do i = 3 to o -> operator.number; 1399 call set ((o -> operator.operand (i)), i, "0"b); 1400 end; 1401 1402 /* use & set all aliasables */ 1403 1404 cur_unit -> flow_unit.used -> bits = cur_unit -> flow_unit.used -> bits | aliasable_mask (0); 1405 cur_unit -> flow_unit.busy_on_entry -> bits = 1406 cur_unit -> flow_unit.busy_on_entry -> bits 1407 | (aliasable_mask (0) & ^cur_unit -> flow_unit.always_completely_set -> bits); 1408 cur_unit -> flow_unit.set_multiple -> bits = 1409 cur_unit -> flow_unit.set_multiple -> bits | (cur_unit -> flow_unit.set -> bits & aliasable_mask (0)); 1410 cur_unit -> flow_unit.set -> bits = cur_unit -> flow_unit.set -> bits | aliasable_mask (0); 1411 1412 /* set the output */ 1413 1414 call set ((o -> operator.output), 0, "1"b); 1415 1416 cur_unit -> flow_unit.has_side_effects = "1"b; 1417 1418 end process_call; 1419 1420 change_cur_unit: 1421 procedure (); 1422 1423 /* makes a new flow_unit the current unit and chains it in */ 1424 1425 dcl next_unit pointer; 1426 1427 need_new_unit = "0"b; 1428 1429 if st -> opt_statement.flow_unit ^= null 1430 then next_unit = st -> opt_statement.flow_unit; 1431 else next_unit = create_flow_unit (); 1432 1433 next_unit -> flow_unit.position, next_unit -> flow_unit.number = cur_unit -> flow_unit.number + 1; 1434 next_unit -> flow_unit.first_statement = cur_statement; 1435 1436 cur_unit -> flow_unit.next = next_unit; 1437 next_unit -> flow_unit.back = cur_unit; 1438 1439 if ^state_discarded 1440 then do; 1441 cur_unit -> flow_unit.falls_through = "1"b; 1442 call link (cur_unit, next_unit); 1443 end; 1444 else state_discarded = "0"b; 1445 1446 cur_unit = next_unit; 1447 st -> opt_statement.flow_unit = cur_unit; 1448 1449 end change_cur_unit; 1450 1451 link_to_target: 1452 procedure (lab); 1453 1454 /* links cur_unit to the flow_unit designated by the label lab */ 1455 1456 dcl lab fixed binary (18); /* label of target (input/output) */ 1457 1458 dcl target_statement fixed binary (18); 1459 dcl (target, target_unit) pointer; 1460 1461 call get_final_target (lab, target_statement, target); 1462 1463 if target -> opt_statement.flow_unit = null 1464 then do; 1465 target_unit = create_flow_unit (); 1466 target -> opt_statement.flow_unit = target_unit; 1467 end; 1468 else target_unit = target -> opt_statement.flow_unit; 1469 1470 target_unit -> flow_unit.has_label = "1"b; 1471 1472 call link (cur_unit, target_unit); 1473 1474 if next_statement = target_statement 1475 then cur_unit -> flow_unit.falls_through = "1"b; 1476 1477 end link_to_target; 1478 1479 get_final_target: 1480 procedure (lab, target_statement, target); 1481 1482 /* gets final target of jump. This optimizes a goto a goto statement */ 1483 1484 dcl lab fixed binary (18), /* label referenced in the jump (input/output) */ 1485 target_statement fixed binary (18), /* statement labelled by lab(output) */ 1486 target pointer; /* .. (output) */ 1487 1488 dcl try_to_optimize bit (1) aligned; 1489 dcl i fixed binary; 1490 dcl o pointer; 1491 1492 i = 1; 1493 try_to_optimize = "1"b; 1494 1495 do while (try_to_optimize); 1496 target_statement = addr (rands (lab)) -> label.statement; 1497 target = addr (quad (target_statement)); 1498 1499 do o = addr (quad (target -> opt_statement.first_operator)) repeat addr (quad (o -> operator.next)) 1500 while (o -> operator.op_code = no_op | o -> operator.op_code = non_executable); 1501 end; 1502 1503 if o -> operator.op_code = jump_op & i < 10 1504 then do; 1505 lab = o -> operand (1); 1506 1507 /* Set removable to prevent warning 384 */ 1508 1509 target -> opt_statement.removable = "1"b; 1510 end; 1511 else try_to_optimize = "0"b; 1512 1513 i = i + 1; 1514 end; 1515 1516 end get_final_target; 1517 1518 link_entry_to_target: 1519 procedure (); 1520 1521 /* links entry unit to target unit which is operator.operand(1) */ 1522 1523 dcl (target, target_st) pointer; 1524 1525 target_st = addr (quad (addr (rands (o -> operand (1))) -> label.statement)); 1526 1527 if target_st -> opt_statement.flow_unit ^= null 1528 then target = target_st -> opt_statement.flow_unit; 1529 else do; 1530 target = create_flow_unit (); 1531 target_st -> opt_statement.flow_unit = target; 1532 end; 1533 1534 target -> flow_unit.has_label = "1"b; 1535 target_st -> opt_statement.referenced_by_assign = "1"b; 1536 1537 call link (entry_unit, target); 1538 1539 end link_entry_to_target; 1540 1541 add_to_jump_assigned_list: 1542 procedure (); 1543 1544 dcl c pointer; 1545 1546 c = create_chain (); 1547 1548 c -> chain.value = cur_unit; 1549 c -> chain.next = jump_assigned_list; 1550 jump_assigned_list = c; 1551 1552 end add_to_jump_assigned_list; 1553 1554 add_to_jump_assigned_target_list: 1555 procedure (); 1556 1557 dcl (target, target_st, c, sym) pointer; 1558 1559 target_st = addr (quad (addr (rands (o -> operand (1))) -> label.statement)); 1560 target = target_st -> opt_statement.flow_unit; 1561 1562 sym = addr (rands (o -> operator.output)); 1563 1564 if sym -> symbol.secondary = null 1565 then do; 1566 c = create_chain (); 1567 1568 c -> chain.value = sym; 1569 c -> chain.next = jump_assigned_target_list; 1570 jump_assigned_target_list = c; 1571 end; 1572 1573 c = create_chain (); 1574 1575 c -> chain.value = target; 1576 c -> chain.next = sym -> symbol.secondary; 1577 sym -> symbol.secondary = c; 1578 1579 end add_to_jump_assigned_target_list; 1580 1581 connect_jump_assigneds: 1582 procedure (); 1583 1584 dcl (c_source, c_target, source, st, o, sym, last, last_c) pointer; 1585 1586 last = null; 1587 1588 do c_source = jump_assigned_list repeat c_source -> chain.next while (c_source ^= null); 1589 1590 source = c_source -> chain.value; 1591 1592 st = addr (quad (source -> flow_unit.last_statement)); 1593 st = addr (quad (fixed (st -> opt_statement.next, 18))); 1594 o = addr (quad (st -> opt_statement.prev_operator)); 1595 sym = addr (rands (o -> operand (1))); 1596 1597 do c_target = sym -> symbol.secondary repeat c_target -> chain.next while (c_target ^= null); 1598 call link (source, (c_target -> chain.value)); 1599 end; 1600 1601 last = c_source; 1602 end; 1603 1604 if last ^= null 1605 then do; 1606 last -> chain.next = free (size (chain)); 1607 free (size (chain)) = jump_assigned_list; 1608 jump_assigned_list = null; 1609 end; 1610 1611 last_c = null; 1612 1613 do c_target = jump_assigned_target_list repeat c_target -> chain.next while (c_target ^= null); 1614 1615 last_c = c_target; 1616 sym = c_target -> chain.value; 1617 1618 do last = sym -> symbol.secondary repeat last -> chain.next while (last -> chain.next ^= null); 1619 end; 1620 1621 last -> chain.next = free (size (chain)); 1622 free (size (chain)) = sym -> symbol.secondary; 1623 sym -> symbol.secondary = null; 1624 end; 1625 1626 if last_c ^= null 1627 then do; 1628 last_c -> chain.next = free (size (chain)); 1629 free (size (chain)) = jump_assigned_target_list; 1630 jump_assigned_target_list = null; 1631 end; 1632 1633 end connect_jump_assigneds; 1634 1635 end build_flow_units; 1636 1637 link: 1638 procedure (from_unit, to_unit); 1639 1640 /* builds an edge between from_unit and to_unit */ 1641 1642 dcl (from_unit, to_unit) pointer; 1643 1644 dcl (e, q) pointer; 1645 1646 e = get_opt_space (size (edge)); 1647 1648 e -> edge.from.back = null; 1649 e -> edge.to.back = null; 1650 1651 e -> edge.from.value = from_unit; 1652 e -> edge.to.value = to_unit; 1653 1654 e -> edge.from.next, q = to_unit -> flow_unit.predecessors; 1655 to_unit -> flow_unit.predecessors = e; 1656 if q ^= null 1657 then q -> edge.from.back = e; 1658 1659 e -> edge.to.next, q = from_unit -> flow_unit.successors; 1660 from_unit -> flow_unit.successors = e; 1661 if q ^= null 1662 then q -> edge.to.back = e; 1663 1664 end link; 1665 1666 make_constant_opt_subscript: 1667 procedure (p_o); 1668 1669 dcl (o, p_o) pointer; /* points at operator */ 1670 dcl (c2, c3) fixed binary (18); 1671 1672 o = p_o; 1673 unspec (c2) = addr (rands (o -> operator.operand (2))) -> constant.value; 1674 unspec (c3) = addr (rands (o -> operator.operand (3))) -> constant.value; 1675 o -> operator.operand (2) = create_integer_constant (c2 + c3); 1676 o -> operator.operand (3) = 0; 1677 1678 end make_constant_opt_subscript; 1679 1680 flow_analysis: 1681 procedure (); 1682 1683 dcl (c, e, exit, lastc, lp, p, q) pointer; 1684 dcl (i, lvec, pnum, qnum) fixed binary (18); 1685 dcl found bit (1) aligned; 1686 1687 /* BACK DOMINATOR ALGORITHM */ 1688 1689 /* Assign level numbers. The level number represents the minimum 1690* distance from the entry_unit. */ 1691 1692 flow_unit_vector_p = get_opt_space (size (flow_unit_vector_st)); 1693 flow_unit_vector (1) = entry_unit; 1694 entry_unit -> flow_unit.level_number = 0; 1695 lvec = 1; 1696 1697 do i = 1 by 1 while (i <= lvec); 1698 p = flow_unit_vector (i); 1699 qnum = p -> flow_unit.level_number + 1; 1700 1701 do e = p -> flow_unit.successors repeat e -> edge.to.next while (e ^= null); 1702 q = e -> edge.to.value; 1703 if q -> flow_unit.level_number = 0 1704 then do; 1705 q -> flow_unit.level_number = qnum; 1706 lvec = lvec + 1; 1707 flow_unit_vector (lvec) = q; 1708 if q -> flow_unit.predecessors -> edge.from.next = null 1709 /* check for only one predecessor */ 1710 then q -> flow_unit.dominator = p; 1711 end; 1712 end; 1713 end; 1714 1715 if lvec ^= n_flow_units 1716 then do; 1717 call detach_flow_units; 1718 n_flow_units = lvec; 1719 end; 1720 1721 /* Determine back dominators. a is the back dominator of b if a is the closest unit to 1722* b that must be executed before b is executed. */ 1723 1724 begin; 1725 1726 dcl scan_vector (n_flow_units) pointer unaligned; 1727 dcl scan_bits bit (n_flow_units) aligned; 1728 1729 dcl (i, j, lvec, lowest_level, our_level) fixed binary (18); 1730 dcl (e, p, q, bd, lowest_fu) pointer; 1731 1732 do i = 2 to n_flow_units; 1733 p = flow_unit_vector (i); 1734 1735 if p -> flow_unit.dominator ^= null 1736 then bd = p -> flow_unit.dominator; 1737 1738 else do; 1739 1740 /* we want to initialize scan_bits with dominated_by bits from and the bit for 1741* the predecessor with lowest level number */ 1742 1743 our_level = p -> flow_unit.level_number; 1744 lowest_level = n_flow_units; 1745 lowest_fu = null; 1746 1747 do e = p -> flow_unit.predecessors repeat e -> edge.from.next while (e ^= null); 1748 q = e -> edge.from.value; 1749 if q -> flow_unit.level_number < lowest_level 1750 then do; 1751 lowest_level = q -> flow_unit.level_number; 1752 lowest_fu = q; 1753 end; 1754 end; 1755 1756 scan_bits = lowest_fu -> flow_unit.dominated_by -> dbits; 1757 substr (scan_bits, lowest_fu -> flow_unit.number, 1) = "1"b; 1758 1759 /* scan all backward paths to find intersection furthest back from p, 1760* that is, with the lowest level number */ 1761 1762 lowest_level = n_flow_units; 1763 lowest_fu = null; 1764 scan_vector (1) = p; 1765 lvec = 1; 1766 1767 do j = 1 by 1 while (j <= lvec); 1768 q = scan_vector (j); 1769 1770 if q -> flow_unit.level_number < our_level 1771 then call process ((q -> flow_unit.dominator)); 1772 1773 else do e = q -> flow_unit.predecessors repeat e -> edge.from.next while (e ^= null); 1774 call process ((e -> edge.from.value)); 1775 end; 1776 end; 1777 1778 p -> flow_unit.dominator, bd = lowest_fu; 1779 end; 1780 1781 p -> flow_unit.dominated_by -> dbits = bd -> flow_unit.dominated_by -> dbits; 1782 substr (p -> flow_unit.dominated_by -> dbits, bd -> flow_unit.number, 1) = "1"b; 1783 end; 1784 1785 process: 1786 procedure (fu); 1787 1788 dcl fu pointer; /* flow_unit being scanned */ 1789 1790 if substr (scan_bits, fu -> flow_unit.number, 1) 1791 then do; 1792 if fu -> flow_unit.level_number < lowest_level 1793 then do; 1794 lowest_level = fu -> flow_unit.level_number; 1795 lowest_fu = fu; 1796 end; 1797 end; 1798 else do; 1799 substr (scan_bits, fu -> flow_unit.number, 1) = "1"b; 1800 lvec = lvec + 1; 1801 scan_vector (lvec) = fu; 1802 end; 1803 1804 end process; 1805 1806 end /* back dominator begin block */; 1807 1808 /* FIND LOOP ENTRY UNITS */ 1809 1810 loop_entry_list = null; 1811 1812 /* order of processing of flow_units is important */ 1813 1814 do i = n_flow_units by -1 to 3; 1815 p = flow_unit_vector (i); 1816 pnum = p -> flow_unit.number; 1817 found = "0"b; 1818 1819 /* a loop entry unit either dominates one of its predecessors or is its own predecessor */ 1820 1821 do e = p -> flow_unit.predecessors repeat e -> edge.from.next while (^found & e ^= null); 1822 q = e -> edge.from.value; 1823 if p = q | substr (q -> flow_unit.dominated_by -> dbits, pnum, 1) 1824 then found = "1"b; 1825 end; 1826 1827 if found 1828 then do; 1829 1830 if ^addr (quad (p -> flow_unit.first_statement)) -> opt_statement.referenced_by_assign 1831 then do; 1832 1833 /* we have a legitimate loop entry unit */ 1834 1835 c = create_chain (); 1836 c -> chain.next = loop_entry_list; 1837 loop_entry_list = c; 1838 c -> chain.value = p; 1839 p -> flow_unit.loop_entry = "1"b; 1840 end; 1841 end; 1842 end; 1843 1844 /* ASSIGN ALL FLOW UNITS TO LOOPS */ 1845 1846 scan_vector_p = get_opt_space (size (scan_vector_st)); 1847 scan_bits_p = get_opt_space (size (scan_bits)); 1848 lastc = null; 1849 1850 do c = loop_entry_list repeat c -> chain.next while (c ^= null); 1851 p = c -> chain.value; 1852 pnum = p -> flow_unit.number; 1853 1854 /* Create a loop node. Assign a provisional back_target. */ 1855 1856 lp = create_loop ((p -> flow_unit.loop)); 1857 p -> flow_unit.loop = lp; 1858 lp -> loop.entry_unit = p; 1859 lp -> loop.back_target = p -> flow_unit.dominator; 1860 1861 /* Scan back from the loop entry unit on all paths that don't reach the back target 1862* (without retouching the entry unit) and contain flow_units dominated by the loop 1863* entry unit to get loop members. */ 1864 1865 scan_bits = "0"b; 1866 lvec = 1; 1867 substr (scan_bits, pnum, 1) = "1"b; 1868 scan_vector (1) = p; 1869 1870 do i = 1 by 1 while (i <= lvec); 1871 do e = scan_vector (i) -> flow_unit.predecessors repeat e -> edge.from.next while (e ^= null); 1872 q = e -> edge.from.value; 1873 1874 if (i ^= 1 1875 | q ^= lp -> loop.back_target & substr (q -> flow_unit.dominated_by -> dbits, pnum, 1)) 1876 & ^substr (scan_bits, q -> flow_unit.number, 1) 1877 then do; 1878 lvec = lvec + 1; 1879 scan_vector (lvec) = q; 1880 substr (scan_bits, q -> flow_unit.number, 1) = "1"b; 1881 q -> flow_unit.loop = lp; 1882 end; 1883 end; 1884 end; 1885 1886 lastc = c; 1887 end; 1888 1889 if loop_entry_list ^= null 1890 then do; 1891 1892 /* free loop_entry_list */ 1893 1894 lastc -> chain.next = free (size (chain)); 1895 free (size (chain)) = loop_entry_list; 1896 loop_entry_list = null; 1897 end; 1898 1899 /* MAKE A VECTOR OF LOOPS IN DESCENDING ORDER OF NESTING DEPTH AND FROM FRONT TO BACK */ 1900 1901 cs -> subprogram.n_loops = n_loops; 1902 cs -> subprogram.loop_vector_p, loop_vector_p = get_opt_space (size (loop_vector_st)); 1903 lvec = n_loops; 1904 1905 loop_vector (lvec) = adam_loop; 1906 1907 adam_loop -> loop.number = lvec; 1908 adam_loop -> loop.ancestors_and_me = get_opt_space (size (lbits)); 1909 substr (adam_loop -> loop.ancestors_and_me -> lbits, lvec, 1) = "1"b; 1910 1911 do i = n_loops to 1 by -1; 1912 lp = loop_vector (i); 1913 1914 do p = lp -> loop.last_son repeat p -> loop.prev_brother while (p ^= null); 1915 lvec = lvec - 1; 1916 1917 loop_vector (lvec) = p; 1918 1919 p -> loop.number = lvec; 1920 p -> loop.ancestors_and_me = get_opt_space (size (lbits)); 1921 p -> loop.ancestors_and_me -> lbits = lp -> loop.ancestors_and_me -> lbits; 1922 substr (p -> loop.ancestors_and_me -> lbits, lvec, 1) = "1"b; 1923 end; 1924 1925 end; 1926 1927 /* ASSIGN REAL BACK TARGETS (fixes bug 187) */ 1928 1929 /* find earliest flow_unit for each loop */ 1930 1931 do p = exit_unit -> flow_unit.back repeat p -> flow_unit.back while (p ^= null); 1932 p -> flow_unit.loop -> loop.first_unit = p; 1933 end; 1934 1935 /* find last flow_unit for each loop */ 1936 1937 do p = entry_unit -> flow_unit.next repeat p -> flow_unit.next while (p ^= null); 1938 p -> flow_unit.loop -> loop.last_unit = p; 1939 end; 1940 1941 /* refine first_unit and last_unit to account for contained loops */ 1942 1943 do i = 1 to n_loops - 1; 1944 lp = loop_vector (i); 1945 1946 do p = lp -> loop.son repeat p -> loop.brother while (p ^= null); 1947 if lp -> loop.first_unit -> flow_unit.position > p -> loop.first_unit -> flow_unit.position 1948 then lp -> loop.first_unit = p -> loop.first_unit; 1949 1950 if lp -> loop.last_unit -> flow_unit.position < p -> loop.last_unit -> flow_unit.position 1951 then lp -> loop.last_unit = p -> loop.last_unit; 1952 end; 1953 1954 end; 1955 1956 /* Now make sure each loop has a suitable back_target. 1957* A suitable back_target has one successor and 1958* physically appears before any flow_unit in the loop. 1959* The latter is necessary because the code generator 1960* makes one linear pass over the program. We scan from 1961* outside-in so that inner back targets are closest to 1962* their loops */ 1963 1964 do i = n_loops - 1 to 1 by -1; 1965 lp = loop_vector (i); 1966 p = lp -> loop.entry_unit; 1967 q = p -> flow_unit.dominator; 1968 1969 if q -> flow_unit.successors -> edge.to.next ^= null 1970 | q -> flow_unit.position > lp -> loop.first_unit -> flow_unit.position 1971 then q = create_new_back_target (p, (lp -> loop.first_unit)); 1972 1973 lp -> loop.back_target = q; 1974 q -> flow_unit.is_back_target = "1"b; 1975 end; 1976 1977 /* CHAIN FLOW_UNITS BELONGING TO EACH LOOP. 1978* Note that all flow_units must now have been created so that we can properly determine the exit paths. */ 1979 1980 do p = exit_unit repeat p -> flow_unit.back while (p ^= null); 1981 pnum = p -> flow_unit.number; 1982 lp = p -> flow_unit.loop; 1983 substr (lp -> loop.is_member -> dbits, p -> flow_unit.number, 1) = "1"b; 1984 p -> flow_unit.next_in_loop = lp -> loop.members; 1985 lp -> loop.members = p; 1986 1987 /* check if this is an exit unit (used to determine articulation blocks) */ 1988 1989 if lp -> loop.depth > 0 1990 then do e = p -> flow_unit.successors repeat e -> edge.to.next while (e ^= null); 1991 q = e -> edge.to.value -> flow_unit.loop; 1992 1993 /* if we have an exit unit, mark it in this loop and in intervening loops */ 1994 1995 if lp -> loop.depth > q -> loop.depth 1996 then do exit = lp repeat exit -> loop.father while (exit ^= q); 1997 c = create_chain (); 1998 c -> chain.value = e; 1999 c -> chain.next = exit -> loop.exits; 2000 exit -> loop.exits = c; 2001 substr (exit -> loop.is_exit -> dbits, pnum, 1) = "1"b; 2002 end; 2003 end; 2004 end; 2005 2006 /* DETERMINE ARTICULATION BLOCKS */ 2007 2008 do i = 1 to n_loops - 1; 2009 lp = loop_vector (i); 2010 lp -> loop.articulation_blocks -> dbits = lp -> loop.is_member -> dbits; 2011 2012 do c = lp -> loop.exits repeat c -> chain.next while (c ^= null); 2013 p = c -> chain.value -> edge.from.value; 2014 scan_bits = p -> flow_unit.dominated_by -> dbits; 2015 substr (scan_bits, p -> flow_unit.number, 1) = "1"b; 2016 lp -> loop.articulation_blocks -> dbits = lp -> loop.articulation_blocks -> dbits & scan_bits; 2017 end; 2018 end; 2019 2020 /* allocate temp_bits */ 2021 2022 temp_bits_p = get_opt_space (size (temp_bits)); 2023 2024 /* COMPLETE DATA_FLOW ANALYSIS */ 2025 2026 call analyze_data_flow; 2027 2028 return; 2029 2030 create_new_back_target: 2031 procedure (pt, p_ins) returns (pointer); 2032 2033 dcl (p, pt) pointer; /* ptr to loop entry unit */ 2034 dcl (ins, p_ins) pointer; /* ptr to earliest flow_unit in loop */ 2035 2036 dcl (e, q, fu, next_edge, pr, qst, o) pointer; 2037 dcl (j, qlabel, pnum, old_label, qpos) fixed binary (18); 2038 2039 2040 /* this routine creates a new flow_unit (with statement & label) to be a 2041* back target for the loop entry unit p and splices it in */ 2042 2043 p = pt; 2044 ins = p_ins; 2045 pnum = p -> flow_unit.number; 2046 2047 q = insert_flow_unit_before (ins, qlabel, qst); 2048 2049 q -> flow_unit.level_number = p -> flow_unit.level_number; 2050 q -> flow_unit.dominator = p -> flow_unit.dominator; 2051 q -> flow_unit.dominated_by -> dbits = p -> flow_unit.dominated_by -> dbits; 2052 p -> flow_unit.dominator = q; 2053 q -> flow_unit.loop = p -> flow_unit.loop -> loop.father; 2054 2055 do j = n_flow_units by -1 to 1 while (flow_unit_vector (j) ^= p); 2056 flow_unit_vector (j), fu = flow_unit_vector (j - 1); 2057 if substr (fu -> flow_unit.dominated_by -> dbits, pnum, 1) 2058 then substr (fu -> flow_unit.dominated_by -> dbits, n_flow_units, 1) = "1"b; 2059 end; 2060 2061 flow_unit_vector (j) = q; 2062 2063 qpos = q -> flow_unit.position; 2064 2065 old_label = addr (quad (p -> flow_unit.first_statement)) -> opt_statement.label; 2066 2067 q -> flow_unit.falls_through = p = ins; 2068 2069 if ^q -> flow_unit.falls_through 2070 then call make_jump_to (old_label, q); 2071 2072 /* redirect edges from outside the loop to the new back target */ 2073 2074 do e = p -> flow_unit.predecessors repeat next_edge while (e ^= null); 2075 next_edge = e -> edge.from.next; 2076 pr = e -> edge.from.value; 2077 2078 if pr ^= p & ^substr (pr -> flow_unit.dominated_by -> dbits, pnum, 1) 2079 then do; 2080 2081 /* pr is a flow_unit outside of the loop headed by p */ 2082 2083 /* set the reference_backwards bit , if necessary */ 2084 2085 if pr -> flow_unit.position > qpos 2086 then qst -> opt_statement.referenced_backwards = "1"b; 2087 2088 /* change this edge to point to the new flow unit */ 2089 2090 call redirect_edge (e, q); 2091 2092 /* now change the jump_x operator, if any, to jump to the right place */ 2093 2094 if old_label > 0 2095 then do; 2096 o = addr (quad (pr -> flow_unit.last_statement)); 2097 o = addr (quad (fixed (o -> opt_statement.next, 18))); 2098 o = addr (quad (o -> opt_statement.prev_operator)); 2099 2100 if o -> operator.op_code = jump_op 2101 then o -> operand (1) = qlabel; 2102 2103 else if o -> operator.op_code = jump_true_op | o -> operator.op_code = jump_false_op 2104 then do; 2105 if o -> operand (2) = old_label 2106 then o -> operand (2) = qlabel; 2107 2108 if pr -> flow_unit.next = p 2109 then call splice_in_another_fu (pr, q, qlabel); 2110 end; 2111 2112 else if o -> operator.op_code = jump_arithmetic_op 2113 then do j = 2 to 4; 2114 if o -> operand (j) = old_label 2115 then o -> operand (j) = qlabel; 2116 end; 2117 2118 else if o -> operator.op_code = jump_computed_op 2119 then do; 2120 do j = 1 to o -> operand (1) + bias; 2121 if o -> operand (j + 1) = old_label 2122 then o -> operand (j + 1) = qlabel; 2123 end; 2124 2125 if pr -> flow_unit.next = p 2126 then call splice_in_another_fu (pr, q, qlabel); 2127 end; 2128 2129 else /* it was a fall through */ 2130 if pr -> flow_unit.next ^= q 2131 then do; 2132 pr -> flow_unit.falls_through = "0"b; 2133 pr -> flow_unit.last_statement = insert_statement_after ((pr -> flow_unit.last_statement)); 2134 call make_jump_to (qlabel, pr); 2135 end; 2136 end; 2137 end; 2138 end; 2139 2140 /* link the new back target to the loop entry unit */ 2141 2142 call link (q, p); 2143 2144 return (q); 2145 2146 insert_flow_unit_before: 2147 procedure (p_ins, new_label, new_stm) returns (pointer); 2148 2149 dcl (p_ins, ins) pointer; /* -> flow_unit before which we insert the new flow_unit */ 2150 dcl new_label fixed binary (18); /* label for new flow_unit (output) */ 2151 dcl new_stm pointer; /* -> stm for new flow_unit (output) */ 2152 2153 dcl (fu, q, qst) pointer; 2154 dcl (q_statement, qlabel) fixed binary (18); 2155 2156 ins = p_ins; 2157 2158 q = create_flow_unit (); 2159 2160 if n_flow_units >= max_flow_units 2161 then do; 2162 cur_statement = ins -> flow_unit.back -> flow_unit.last_statement; 2163 call print_message (388); 2164 stop; 2165 end; 2166 2167 n_flow_units = n_flow_units + 1; 2168 q -> flow_unit.number = n_flow_units; 2169 q -> flow_unit.position = ins -> flow_unit.position; 2170 q -> flow_unit.back = ins -> flow_unit.back; 2171 q -> flow_unit.next = ins; 2172 ins -> flow_unit.back = q; 2173 q -> flow_unit.back -> flow_unit.next = q; 2174 2175 do fu = ins repeat fu -> flow_unit.next while (fu ^= null); 2176 fu -> flow_unit.position = fu -> flow_unit.position + 1; 2177 end; 2178 2179 q_statement = insert_statement_after ((q -> flow_unit.back -> flow_unit.last_statement)); 2180 q -> flow_unit.first_statement = q_statement; 2181 q -> flow_unit.last_statement = q_statement; 2182 2183 qst = addr (quad (q_statement)); 2184 qst -> opt_statement.flow_unit = q; 2185 2186 qlabel = create_label (q_statement); 2187 q -> flow_unit.has_label = "1"b; 2188 2189 new_label = qlabel; 2190 new_stm = qst; 2191 return (q); 2192 2193 end insert_flow_unit_before; 2194 2195 redirect_edge: 2196 procedure (e, new_target); 2197 2198 dcl e pointer, /* -> edge whose target is changed */ 2199 new_target pointer; /* -> new target unit */ 2200 2201 dcl (e1, next_edge, old_target) pointer; 2202 2203 next_edge = e -> edge.from.next; 2204 old_target = e -> edge.to.value; 2205 2206 if e -> edge.from.back = null 2207 then old_target -> flow_unit.predecessors = next_edge; 2208 else e -> edge.from.back -> edge.from.next = next_edge; 2209 if next_edge ^= null 2210 then next_edge -> edge.from.back = e -> edge.from.back; 2211 2212 e -> edge.to.value = new_target; 2213 e -> edge.from.next, e1 = new_target -> flow_unit.predecessors; 2214 e -> edge.from.back = null; 2215 new_target -> flow_unit.predecessors = e; 2216 if e1 ^= null 2217 then e1 -> edge.from.back = e; 2218 2219 end redirect_edge; 2220 2221 make_jump_to: 2222 procedure (tlabel, fu); 2223 2224 dcl tlabel fixed binary (18), /* target label of jump */ 2225 fu pointer; /* -> flow_unit in which jump is inserted */ 2226 2227 dcl (j_operator, j_statement) fixed binary (18); 2228 2229 j_statement, fu -> flow_unit.last_statement = insert_statement_after ((fu -> flow_unit.last_statement)); 2230 j_operator = insert_operator_after (jump_op, 1, j_statement); 2231 addr (quad (j_operator)) -> operand (1) = tlabel; 2232 2233 end make_jump_to; 2234 2235 splice_in_another_fu: 2236 procedure (pr, bt, btlabel); 2237 2238 dcl pr pointer, /* -> flow_unit that falls thru */ 2239 bt pointer, /* -> flow_unit we will build jump to (new back target) */ 2240 btlabel fixed binary (18); /* label on bt */ 2241 2242 dcl q pointer; 2243 dcl (j, useless) fixed binary (18); 2244 dcl useless_ptr pointer; 2245 2246 q = insert_flow_unit_before ((pr -> flow_unit.next), useless, useless_ptr); 2247 2248 q -> flow_unit.level_number = bt -> flow_unit.level_number; 2249 q -> flow_unit.dominator = pr; 2250 q -> flow_unit.dominated_by -> dbits = pr -> flow_unit.dominated_by -> dbits; 2251 substr (q -> flow_unit.dominated_by -> dbits, pr -> flow_unit.number, 1) = "1"b; 2252 q -> flow_unit.loop = bt -> flow_unit.loop; 2253 2254 do j = n_flow_units by -1 to 1 while (flow_unit_vector (j) ^= bt); 2255 flow_unit_vector (j) = flow_unit_vector (j - 1); 2256 end; 2257 2258 flow_unit_vector (j) = q; 2259 2260 call make_jump_to ((btlabel), q); 2261 2262 /* redirect edges */ 2263 2264 call redirect_edge (e, q); 2265 2266 call link (q, bt); 2267 2268 end splice_in_another_fu; 2269 2270 end create_new_back_target; 2271 2272 detach_flow_units: 2273 procedure (); 2274 2275 /* detaches unreachable flow_units */ 2276 2277 dcl (lst, nst, p, qst, st, last_o, next_fu) pointer; 2278 dcl (q_statement, last_statement, next_statement, last_operator) fixed binary (18); 2279 2280 do p = entry_unit -> flow_unit.next repeat next_fu while (p ^= exit_unit); 2281 next_fu = p -> flow_unit.next; 2282 2283 if p -> flow_unit.level_number = 0 2284 then do; 2285 cur_statement = p -> flow_unit.first_statement; 2286 st = addr (quad (cur_statement)); 2287 2288 /* unthread the statement/operator chain */ 2289 2290 q_statement = p -> flow_unit.last_statement; 2291 qst = addr (quad (q_statement)); 2292 next_statement = fixed (qst -> opt_statement.next, 18); 2293 nst = addr (quad (next_statement)); 2294 last_statement = fixed (st -> opt_statement.back, 18); 2295 lst = addr (quad (last_statement)); 2296 last_operator = st -> opt_statement.prev_operator; 2297 last_o = addr (quad (last_operator)); 2298 2299 /* Print warning if this is a real statement */ 2300 2301 if ^st -> opt_statement.removable 2302 then call print_message (384, fixed (st -> opt_statement.source_id.line, 14, 0) - bias, 2303 fixed (qst -> opt_statement.source_id.line, 14, 0) - bias); 2304 2305 lst -> opt_statement.next = qst -> opt_statement.next; 2306 last_o -> operator.next = next_statement; 2307 nst -> opt_statement.back = st -> opt_statement.back; 2308 nst -> opt_statement.prev_operator = last_operator; 2309 2310 /* detach and unthread the flow_unit */ 2311 2312 call detach_flow_unit (p); 2313 end; 2314 end; 2315 2316 end detach_flow_units; 2317 2318 end flow_analysis; 2319 2320 detach_flow_unit: 2321 procedure (pt); 2322 2323 /* detaches a flow_unit from its edges and unthreads a flow_unit from the 2324* flow_unit chain */ 2325 2326 dcl (p, pt) pointer; 2327 2328 p = pt; 2329 2330 /* detach all edges connected to this flow_unit */ 2331 2332 do while (p -> flow_unit.predecessors ^= null); 2333 call unlink ((p -> flow_unit.predecessors)); 2334 end; 2335 2336 do while (p -> flow_unit.successors ^= null); 2337 call unlink ((p -> flow_unit.successors)); 2338 end; 2339 2340 /* unthread the flow_unit */ 2341 2342 call unthread_flow_unit (p); 2343 2344 end detach_flow_unit; 2345 2346 unlink: 2347 procedure (e); 2348 2349 /* unlinks an edge between 2 flow_units */ 2350 2351 dcl e pointer; /* -> edge to be unlinked */ 2352 2353 dcl (from_unit, to_unit) pointer; 2354 2355 from_unit = e -> edge.from.value; 2356 to_unit = e -> edge.to.value; 2357 2358 if e -> edge.from.back ^= null 2359 then e -> edge.from.back -> edge.from.next = e -> edge.from.next; 2360 else to_unit -> flow_unit.predecessors = e -> edge.from.next; 2361 if e -> edge.from.next ^= null 2362 then e -> edge.from.next -> edge.from.back = e -> edge.from.back; 2363 2364 if e -> edge.to.back ^= null 2365 then e -> edge.to.back -> edge.to.next = e -> edge.to.next; 2366 else from_unit -> flow_unit.successors = e -> edge.to.next; 2367 if e -> edge.to.next ^= null 2368 then e -> edge.to.next -> edge.to.back = e -> edge.to.back; 2369 2370 end unlink; 2371 2372 analyze_data_flow: 2373 procedure (); 2374 2375 /* Calls subroutines to do data flow analysis . */ 2376 2377 call summarize_loop_usage; 2378 2379 call compute_busy_on_exit; 2380 2381 call summarize_loop_busy_on_exit; 2382 2383 end analyze_data_flow; 2384 2385 compute_busy_on_exit: 2386 procedure (); 2387 2388 /* computes busy_on_exit information */ 2389 2390 dcl (i, j, lvec) fixed binary; 2391 dcl (bd, e, fu, p, q) pointer; 2392 2393 /* initialize exit_unit to show that all aliasable vars are busy_on_entry */ 2394 2395 exit_unit -> flow_unit.busy_on_entry -> bits = aliasable_mask (0); 2396 2397 /* process each flow_unit in descending order by level number, 2398* propagating information backwards to its dominator */ 2399 2400 retry: 2401 do i = n_flow_units to 2 by -1; 2402 p = flow_unit_vector (i); 2403 bd = p -> flow_unit.dominator; 2404 2405 scan_vector (1) = p; 2406 j = 0; 2407 lvec = 1; 2408 2409 do while (j ^= lvec); 2410 j = j + 1; 2411 if j > n_flow_units 2412 then j = 1; 2413 2414 fu = scan_vector (j); 2415 fu -> flow_unit.in_queue = "0"b; 2416 2417 do e = fu -> flow_unit.predecessors repeat e -> edge.from.next while (e ^= null); 2418 q = e -> edge.from.value; 2419 q -> flow_unit.busy_on_exit -> bits = 2420 q -> flow_unit.busy_on_exit -> bits | fu -> flow_unit.busy_on_entry -> bits; 2421 2422 temp_bits = 2423 q -> flow_unit.busy_on_entry -> bits 2424 | (q -> flow_unit.busy_on_exit -> bits & ^q -> flow_unit.always_completely_set -> bits); 2425 2426 if temp_bits ^= q -> flow_unit.busy_on_entry -> bits 2427 then do; 2428 q -> flow_unit.busy_on_entry -> bits = temp_bits; 2429 if q ^= bd & ^q -> flow_unit.in_queue 2430 then do; 2431 lvec = lvec + 1; 2432 if lvec > n_flow_units 2433 then lvec = 1; 2434 scan_vector (lvec) = q; 2435 q -> flow_unit.in_queue = "1"b; 2436 end; 2437 end; 2438 end; 2439 end; 2440 end; 2441 2442 2443 /* decide whether we have to make another pass because some static 2444* variables are busy on entry to the program but were not considered 2445* busy_on_exit from the program */ 2446 2447 temp_bits = 2448 exit_unit -> flow_unit.busy_on_entry -> bits 2449 | (entry_unit -> flow_unit.busy_on_entry -> bits & non_auto_mask); 2450 2451 if temp_bits ^= exit_unit -> flow_unit.busy_on_entry -> bits 2452 then do; 2453 exit_unit -> flow_unit.busy_on_entry -> bits = temp_bits; 2454 go to retry; 2455 end; 2456 2457 2458 end compute_busy_on_exit; 2459 2460 summarize_loop_usage: 2461 procedure (); 2462 2463 /* build up loop usage information by collecting from member flow_units and 2464* propagating upwards to containing loops */ 2465 2466 dcl i fixed binary; 2467 dcl (lp, p) pointer; 2468 2469 do i = 1 to n_loops; 2470 lp = loop_vector (i); 2471 2472 do p = lp -> loop.members repeat p -> flow_unit.next_in_loop while (p ^= null); 2473 lp -> loop.set_multiple -> bits = 2474 lp -> loop.set_multiple -> bits 2475 | ((lp -> loop.set -> bits & p -> flow_unit.set -> bits) | p -> flow_unit.set_multiple -> bits); 2476 lp -> loop.set -> bits = lp -> loop.set -> bits | p -> flow_unit.set -> bits; 2477 lp -> loop.used -> bits = lp -> loop.used -> bits | p -> flow_unit.used -> bits; 2478 lp -> loop.has_side_effects = lp -> loop.has_side_effects | p -> flow_unit.has_side_effects; 2479 end; 2480 2481 do p = lp -> loop.son repeat p -> loop.brother while (p ^= null); 2482 lp -> loop.set_multiple -> bits = 2483 lp -> loop.set_multiple -> bits 2484 | ((lp -> loop.set -> bits & p -> loop.set -> bits) | p -> loop.set_multiple -> bits); 2485 lp -> loop.set -> bits = lp -> loop.set -> bits | p -> loop.set -> bits; 2486 lp -> loop.used -> bits = lp -> loop.used -> bits | p -> loop.used -> bits; 2487 lp -> loop.has_side_effects = lp -> loop.has_side_effects | p -> loop.has_side_effects; 2488 end; 2489 end; 2490 2491 end summarize_loop_usage; 2492 2493 summarize_loop_busy_on_exit: 2494 procedure (); 2495 2496 /* summarize busy_on_exit info by using busy_on_entry of loop exit targets */ 2497 2498 dcl i fixed binary; 2499 dcl (c, lp) pointer; 2500 2501 do i = 1 to n_loops; 2502 lp = loop_vector (i); 2503 2504 do c = lp -> loop.exits repeat c -> chain.next while (c ^= null); 2505 lp -> loop.busy_on_exit -> bits = 2506 lp -> loop.busy_on_exit -> bits 2507 | c -> chain.value -> edge.to.value -> flow_unit.busy_on_entry -> bits; 2508 end; 2509 end; 2510 2511 end summarize_loop_busy_on_exit; 2512 2513 create_label: 2514 procedure (q_statement) returns (fixed binary (18)); 2515 2516 /* creates a label for a statement */ 2517 2518 dcl q_statement fixed binary (18); /* stmt to which label is to be attached */ 2519 2520 dcl qlabel fixed binary (18); 2521 dcl qlab pointer; 2522 2523 qlabel = create_node (label_node, size (label)); 2524 qlab = addr (rands (qlabel)); 2525 2526 addr (quad (q_statement)) -> opt_statement.label = qlabel; 2527 qlab -> label.statement = q_statement; 2528 qlab -> label.operand_type = rel_constant; 2529 qlab -> label.referenced, qlab -> label.referenced_executable = "1"b; 2530 addr (rands (cs -> subprogram.last_label)) -> label.next_label = qlabel; 2531 cs -> subprogram.last_label = qlabel; 2532 2533 return (qlabel); 2534 2535 end create_label; 2536 2537 unthread_flow_unit: 2538 procedure (fu); 2539 2540 dcl fu pointer; /* -> flow_unit to be unthreaded */ 2541 2542 fu -> flow_unit.back -> flow_unit.next = fu -> flow_unit.next; 2543 fu -> flow_unit.next -> flow_unit.back = fu -> flow_unit.back; 2544 2545 fu -> flow_unit.next = freefu; 2546 freefu = fu; 2547 2548 fu -> flow_unit.removed = "1"b; 2549 2550 end unthread_flow_unit; 2551 2552 insert_statement_after: 2553 procedure (last_statement) returns (fixed binary (18)); 2554 2555 /* used by create_new_back_target and move to insert a new opt_statement node after an existing one. 2556* There must be a statement already after the existing one for this to work */ 2557 2558 dcl last_statement fixed binary (18); 2559 2560 dcl (our_statement, next_statement) fixed binary (18); 2561 dcl (next_operator, last_operator) fixed binary (18); 2562 dcl (lastp, ourp, nextp, nextop, lastop) pointer; 2563 2564 /* get an opt_statement node */ 2565 2566 our_statement = get_quad_space (size (opt_statement)); 2567 ourp = addr (quad (our_statement)); 2568 2569 /* initialize the node */ 2570 2571 unspec (ourp -> opt_statement) = "0"b; 2572 ourp -> opt_statement.op_code = stat_op; 2573 ourp -> opt_statement.location = (18)"1"b; 2574 ourp -> opt_statement.put_in_map = "1"b; 2575 ourp -> opt_statement.operator_list = null; 2576 2577 /* get last and next statement pointers */ 2578 2579 lastp = addr (quad (last_statement)); 2580 next_statement = fixed (lastp -> opt_statement.next, 18); 2581 nextp = addr (quad (next_statement)); 2582 2583 /* get next and last operator pointers */ 2584 2585 next_operator = next_statement; 2586 nextop = nextp; 2587 last_operator = nextp -> opt_statement.prev_operator; 2588 lastop = addr (quad (last_operator)); 2589 2590 /* thread in our opt_statement */ 2591 2592 ourp -> opt_statement.next = bit (next_statement, 18); 2593 ourp -> opt_statement.back = bit (last_statement, 18); 2594 lastp -> opt_statement.next = bit (our_statement, 18); 2595 nextp -> opt_statement.back = bit (our_statement, 18); 2596 ourp -> opt_statement.first_operator = next_operator; 2597 ourp -> opt_statement.prev_operator = last_operator; 2598 nextop -> operator.back = our_statement; 2599 lastop -> operator.next = our_statement; 2600 2601 /* use lastp's source_id and flow_unit */ 2602 2603 unspec (ourp -> opt_statement.source_id) = unspec (lastp -> opt_statement.source_id); 2604 ourp -> opt_statement.flow_unit = lastp -> opt_statement.flow_unit; 2605 2606 return (our_statement); 2607 2608 end insert_statement_after; 2609 2610 insert_operator_after: 2611 procedure (op_code, number, last_operator) returns (fixed binary (18)); 2612 2613 dcl op_code fixed binary (18), 2614 number fixed binary (18), 2615 last_operator fixed binary (18); 2616 2617 dcl (o, next_o, last_o) pointer; 2618 dcl op fixed binary (18); 2619 2620 /* allocate the space */ 2621 2622 n_operands = number; 2623 op = get_quad_space (size (operator)); 2624 o = addr (quad (op)); 2625 2626 /* initialize the space */ 2627 2628 o -> operator.op_code = op_code; 2629 o -> operator.number = n_operands; 2630 o -> operator.assigns_constant_to_symbol = "0"b; 2631 o -> operator.freed = "0"b; 2632 o -> operator.primary = null; 2633 2634 /* if the operator is reducible, assign it a coordinate */ 2635 2636 if op_class (op_code) <= highest_reducible_class 2637 then do; 2638 n_operators = n_operators + 1; 2639 2640 if n_operators <= max_operators 2641 then o -> operator.coordinate = n_operators; 2642 else do; 2643 call print_message (390); 2644 stop; 2645 end; 2646 end; 2647 2648 /* insert the operator */ 2649 2650 last_o = addr (quad (last_operator)); 2651 next_o = addr (quad (last_o -> operator.next)); 2652 o -> operator.next = last_o -> operator.next; 2653 o -> operator.back = last_operator; 2654 last_o -> operator.next = op; 2655 next_o -> operator.back = op; 2656 2657 return (op); 2658 2659 end insert_operator_after; 2660 2661 create_flow_unit: 2662 procedure () returns (pointer); 2663 2664 dcl p pointer; 2665 dcl 1 fort_node_templates_$flow_unit_template ext static aligned like flow_unit; 2666 2667 2668 /* allocates flow unit */ 2669 2670 if freefu = null 2671 then p = get_opt_space (size (flow_unit)); 2672 else do; 2673 p = freefu; 2674 freefu = freefu -> flow_unit.next; 2675 end; 2676 2677 p -> flow_unit = fort_node_templates_$flow_unit_template; 2678 2679 p -> flow_unit.loop = adam_loop; 2680 p -> flow_unit.set = get_opt_space (size (bits)); 2681 p -> flow_unit.used = get_opt_space (size (bits)); 2682 p -> flow_unit.busy_on_entry = get_opt_space (size (bits)); 2683 p -> flow_unit.set_multiple = get_opt_space (size (bits)); 2684 p -> flow_unit.busy_on_exit = get_opt_space (size (bits)); 2685 p -> flow_unit.always_completely_set = get_opt_space (size (bits)); 2686 if max_flow_units > 0 2687 then p -> flow_unit.dominated_by = get_opt_space (size (dbits)); 2688 2689 return (p); 2690 2691 end create_flow_unit; 2692 2693 create_loop: 2694 procedure (dad) returns (pointer); 2695 2696 dcl dad pointer; /* ptr to containing loop */ 2697 2698 dcl (p, prev) pointer; 2699 2700 p = get_opt_space (size (loop)); 2701 2702 if dad ^= null 2703 then do; 2704 2705 /* derive information from containing loop */ 2706 2707 p -> loop.father = dad; 2708 p -> loop.prev_brother, prev = dad -> loop.last_son; 2709 dad -> loop.last_son = p; 2710 if prev ^= null 2711 then prev -> loop.brother = p; 2712 else dad -> loop.son = p; 2713 p -> loop.depth = dad -> loop.depth + 1; 2714 p -> loop.is_member = get_opt_space (size (dbits)); 2715 p -> loop.is_exit = get_opt_space (size (dbits)); 2716 p -> loop.articulation_blocks = get_opt_space (size (dbits)); 2717 p -> loop.induction_var = get_opt_space (size (bits)); 2718 p -> loop.may_keep_in_xr = get_opt_space (size (bits)); 2719 p -> loop.computed = get_opt_space (size (obits)); 2720 end; 2721 2722 else do; 2723 2724 /* initialize information for adam_loop */ 2725 2726 p -> loop.father, p -> loop.prev_brother, p -> loop.is_member, p -> loop.is_exit, 2727 p -> loop.articulation_blocks, p -> loop.induction_var, p -> loop.may_keep_in_xr, p -> loop.computed = 2728 null; 2729 p -> loop.depth = 0; 2730 end; 2731 2732 p -> loop.xregs_used, p -> loop.pregs_used, p -> loop.number = 0; 2733 2734 p -> loop.has_side_effects = "0"b; 2735 2736 p -> loop.ancestors_and_me, p -> loop.brother, p -> loop.son, p -> loop.last_son, p -> loop.entry_unit, 2737 p -> loop.exits, p -> loop.back_target, p -> loop.first_unit, p -> loop.last_unit, p -> loop.members, 2738 p -> loop.global_xr_items, p -> loop.global_pr_items, p -> loop.range_list, p -> loop.msp, 2739 p -> loop.eligible_ind_var_op_var, p -> loop.left_shift_chain = null; 2740 2741 p -> loop.used = get_opt_space (size (bits)); 2742 p -> loop.set = get_opt_space (size (bits)); 2743 p -> loop.set_multiple = get_opt_space (size (bits)); 2744 p -> loop.busy_on_exit = get_opt_space (size (bits)); 2745 2746 n_loops = n_loops + 1; 2747 2748 return (p); 2749 2750 end create_loop; 2751 2752 optimize_subprogram: 2753 procedure (); 2754 2755 /* optimize_subprogram has a choice of 2 different optimization algorithms. In the first algortihm, loops are 2756* processed inside-out, front to back (in other words, bottom-up). After all loops except the non-iterative 2757* outer loop are processed, the whole program is passed over for a consoldation pass to remove common 2758* subexpressions that were made removable by earlier optimizations. In the second algorithm, loops are 2759* processed top-down recursively. After an inner loop is processed, all expressions moved out of that 2760* loop are processed to see if they can be further moved, commoned, etc. 2761* 2762* NOTE: Commoning MUST occur in the same pass that candidates for strength 2763* reduction are found because otherwise candidates for common 2764* expressions may be found so far apart that inefficient init 2765* code may be produced. By commoning at the same time, fewer 2766* candidates are found, thus init code will be better. */ 2767 2768 /* GLOBAL VARS */ 2769 2770 dcl our_depth fixed binary (18); 2771 dcl (fu, lp, bt, lpf) pointer; 2772 dcl (sr_chain, sr_tail, incr_chain, ass_chain, da_chain) pointer; 2773 dcl free_var_list pointer; 2774 dcl used_invariant_symbol bit (1) aligned; 2775 dcl doing_loop bit (1) aligned; 2776 2777 /* LOCAL VARS */ 2778 2779 dcl (i, j, k, new_statement, op, opt_mode) fixed binary (18); 2780 dcl (stm, q, t, o, c, lastc) pointer; 2781 dcl srvp pointer; 2782 2783 /* initialize */ 2784 2785 da_chain, free_var_list = null; 2786 2787 if need_consolidation_pass 2788 then do; 2789 incr_chain, sr_chain, sr_tail, ass_chain = null; 2790 2791 do i = 1 to n_loops - 1; 2792 lp = loop_vector (i); 2793 call optimize_loop (lp); 2794 end; 2795 2796 call consolidate_subprogram; 2797 end; 2798 2799 else call process_loops_top_down; 2800 2801 /* recompute all usage bits */ 2802 2803 call timer (9); 2804 2805 call recompute_usage; 2806 2807 /* remove dead assignments */ 2808 2809 if da_chain ^= null 2810 then do; 2811 call timer (7); 2812 call remove_dead_assignments; 2813 end; 2814 2815 call timer (4); 2816 2817 /* convert the loop_end_chains into operators and operands */ 2818 2819 do i = 2 to n_flow_units; /* want to look at detached as well as attached units */ 2820 fu = flow_unit_vector (i); 2821 if fu -> flow_unit.n_in_loop_end > 0 2822 then do; 2823 new_statement = insert_statement_after ((fu -> flow_unit.last_statement)); 2824 addr (quad (new_statement)) -> opt_statement.put_in_map = "0"b; 2825 /* no code */ 2826 j = fu -> flow_unit.n_in_loop_end; 2827 k = 0; 2828 2829 do c = fu -> flow_unit.loop_end_chain repeat c -> lchain.next while (c ^= null); 2830 if k <= 0 2831 then do; 2832 k = min (j, max_operands); 2833 op = insert_operator_after (loop_end_op, k, new_statement); 2834 o = addr (quad (op)); 2835 end; 2836 lastc = c; 2837 o -> operand (k) = c -> lchain.value; 2838 k = k - 1; 2839 j = j - 1; 2840 end; 2841 2842 lastc -> lchain.next = free (size (chain)); 2843 free (size (chain)) = fu -> flow_unit.loop_end_chain; 2844 2845 fu -> flow_unit.last_statement = new_statement; 2846 2847 fu -> flow_unit.n_in_loop_end = 0; 2848 fu -> flow_unit.loop_end_chain = null; 2849 end; 2850 end; 2851 2852 /* free all sr_var nodes */ 2853 2854 do srvp = free_var_list repeat q while (srvp ^= null); 2855 if srvp -> sr_var.used_in -> lbits 2856 then do; 2857 q = addr (rands (srvp -> sr_var.variable)); 2858 q -> symbol.allocate, q -> symbol.referenced, q -> symbol.set = "1"b; 2859 end; 2860 q = srvp -> sr_var.next; 2861 srvp -> sr_var.next = freesrv; 2862 freesrv = srvp; 2863 end; 2864 2865 free_var_list = null; 2866 2867 optimize_loop: 2868 procedure (p_lp); 2869 2870 /* optimizes loops for the bottom-up algorithm */ 2871 2872 dcl (lp, p_lp) pointer; /* ptr to loop */ 2873 2874 dcl (last_fu, next_lp) pointer; 2875 2876 /* initialize */ 2877 2878 lp = p_lp; 2879 2880 state_discarded = "1"b; 2881 our_depth = lp -> loop.depth; 2882 bt = lp -> loop.back_target; 2883 doing_loop = "1"b; 2884 2885 call derive_insert_for_bt (bt); 2886 2887 /* We now mask out the used bits of invariant symbols. process_moved_descendants 2888* will turn on the bits of those invariant symbols containing uses not actually 2889* moved out of the loop. */ 2890 2891 lp -> loop.used -> bits = lp -> loop.used -> bits & lp -> loop.set -> bits; 2892 2893 /* process the loop */ 2894 2895 last_fu, next_lp = null; 2896 2897 do fu = lp -> loop.members repeat fu -> flow_unit.next_in_loop while (fu ^= null); 2898 if last_fu ^= fu -> flow_unit.back 2899 then do; 2900 2901 /* we have passed over flow_units from other loops */ 2902 2903 if ^fu -> flow_unit.back -> flow_unit.falls_through 2904 then state_discarded = "1"b; 2905 else if ^state_discarded 2906 then if next_lp ^= fu -> flow_unit.back -> flow_unit.loop 2907 then state_discarded = "1"b; 2908 end; 2909 2910 if fu -> flow_unit.loop_entry 2911 then call clear ("0"b); /* Leave hash index intact */ 2912 2913 call optimize_flow_unit (fu, full_optimization, complete_fu, our_depth); 2914 2915 if fu -> flow_unit.next_in_loop ^= fu -> flow_unit.next 2916 then do; 2917 2918 /* we are about to pass over flow_units from other loops */ 2919 2920 if ^fu -> flow_unit.falls_through 2921 then state_discarded = "1"b; 2922 else do; 2923 next_lp = fu -> flow_unit.next -> flow_unit.loop; 2924 2925 if our_depth < next_lp -> loop.depth 2926 then call set_loop_variants (next_lp); 2927 else do; 2928 call process_jump_target ((fu -> flow_unit.next -> flow_unit.first_statement)); 2929 state_discarded = "1"b; 2930 end; 2931 end; 2932 end; 2933 2934 last_fu = fu; 2935 end; 2936 2937 call finish_loop; 2938 2939 call clear ("1"b); 2940 2941 end optimize_loop; 2942 2943 consolidate_subprogram: 2944 procedure (); 2945 2946 /* runs the consolidation pass for the bottom-up algorithm */ 2947 2948 /* uses optimize_subprogram's variables */ 2949 2950 call timer (8); 2951 2952 consolidating = "1"b; 2953 2954 /* remove all vestiges of the previous optimizations' effects from the opt_statement nodes */ 2955 2956 do fu = exit_unit -> flow_unit.back repeat fu -> flow_unit.back while (fu ^= entry_unit); 2957 stm = addr (quad (fu -> flow_unit.first_statement)); 2958 if stm -> opt_statement.has_operator_list 2959 then do; 2960 if stm -> opt_statement.operator_list ^= null 2961 then do; 2962 2963 /* release useless primaries on operator_list */ 2964 2965 t = stm -> opt_statement.operator_list; 2966 do q = t repeat t while (q ^= null); 2967 call release_node (q, t, 0); 2968 end; 2969 stm -> opt_statement.operator_list = null; 2970 end; 2971 2972 fu -> flow_unit.is_active_operator -> obits = "0"b; 2973 stm -> opt_statement.has_operator_list = "0"b; 2974 end; 2975 2976 fu -> flow_unit.processed = "0"b; 2977 end; 2978 2979 /* Pass over all the flow_units. */ 2980 2981 do fu = entry_unit -> flow_unit.next repeat fu -> flow_unit.next while (fu ^= exit_unit); 2982 lp = fu -> flow_unit.loop; 2983 if lp = adam_loop 2984 then opt_mode = full_optimization; 2985 else opt_mode = common_only; 2986 our_depth = lp -> loop.depth; 2987 2988 call optimize_flow_unit (fu, opt_mode, complete_fu, our_depth); 2989 end; 2990 2991 if meter_hash_buckets 2992 then call print_hash_bucket_meters; 2993 2994 call clear ("1"b); 2995 2996 consolidating = "0"b; 2997 2998 end consolidate_subprogram; 2999 3000 process_loops_top_down: 3001 procedure (); 3002 3003 /* this routine does top - down processing of loops */ 3004 3005 /* uses declaration in optimize_subprogram */ 3006 3007 /* begin processing of loops */ 3008 3009 if init_lp_frame = null 3010 then init_lp_frame, lpf = create_lp_frame (null); 3011 else lpf = init_lp_frame; 3012 3013 lp = adam_loop; 3014 call start_loop; 3015 3016 /* These nested loops simulate a recursive walk of the loop tree */ 3017 3018 do while (lp ^= null); 3019 3020 do while (lpf -> lp_frame.this_fu ^= null); 3021 fu = lpf -> lp_frame.this_fu; 3022 lpf -> lp_frame.this_fu = fu -> flow_unit.next_in_loop; 3023 3024 if lpf -> lp_frame.last_fu ^= fu -> flow_unit.back 3025 then do; 3026 3027 /* we have passed over flow_units from other loops */ 3028 3029 if ^fu -> flow_unit.back -> flow_unit.falls_through 3030 then state_discarded = "1"b; 3031 else if ^state_discarded 3032 then if lpf -> lp_frame.next_lp ^= fu -> flow_unit.back -> flow_unit.loop 3033 then state_discarded = "1"b; 3034 end; 3035 3036 call optimize_flow_unit (fu, full_optimization, complete_fu, our_depth); 3037 3038 if fu -> flow_unit.is_back_target 3039 then do; 3040 3041 /* we have a back target, so we now process inner loop */ 3042 3043 call push_loop; 3044 call start_loop; 3045 end; 3046 3047 else do; 3048 if fu -> flow_unit.next_in_loop ^= fu -> flow_unit.next 3049 then do; 3050 3051 /* we are about to pass over flow_units from other loops */ 3052 3053 if ^fu -> flow_unit.falls_through 3054 then state_discarded = "1"b; 3055 else do; 3056 lpf -> lp_frame.next_lp = fu -> flow_unit.next -> flow_unit.loop; 3057 3058 if our_depth < lpf -> lp_frame.next_lp -> loop.depth 3059 then call set_loop_variants ((lpf -> lp_frame.next_lp)); 3060 else do; 3061 call process_jump_target ((fu -> flow_unit.next -> flow_unit.first_statement)); 3062 state_discarded = "1"b; 3063 end; 3064 end; 3065 end; 3066 3067 lpf -> lp_frame.last_fu = fu; 3068 end; 3069 end; 3070 3071 /* processing of flow_units in this loop is done, we now wind up processing of the loop */ 3072 3073 if doing_loop 3074 then call finish_loop; 3075 3076 call clear ("1"b); 3077 3078 /* now pop the loop so we can resume processing of outer loop */ 3079 3080 call pop_loop; 3081 3082 end; 3083 3084 3085 end process_loops_top_down; 3086 3087 start_loop: 3088 procedure (); 3089 3090 /* initializes processing of a loop for the top-down algorithm */ 3091 3092 state_discarded = "1"b; 3093 our_depth = lp -> loop.depth; 3094 bt = lp -> loop.back_target; 3095 doing_loop = bt ^= null; 3096 incr_chain, sr_chain, sr_tail, ass_chain = null; 3097 lpf -> lp_frame.this_fu = lp -> loop.members; 3098 lpf -> lp_frame.last_fu, lpf -> lp_frame.next_lp = null; 3099 3100 end start_loop; 3101 3102 finish_loop: 3103 procedure (); 3104 3105 dcl (c, o, p, q, outp) pointer; 3106 dcl i fixed binary (18); 3107 dcl exit_target pointer unaligned; 3108 dcl has_multiple_exits bit (1) aligned; 3109 3110 /* Because of the refinement of the used bits, we have to OR in the used 3111* bits of inner loops, which have, of course, already been completely processed. */ 3112 3113 do p = lp -> loop.son repeat p -> loop.brother while (p ^= null); 3114 lp -> loop.used -> bits = lp -> loop.used -> bits | p -> loop.used -> bits; 3115 end; 3116 3117 /* OR back target's primaries into entry unit */ 3118 3119 if ^need_consolidation_pass 3120 then call union ((lp -> loop.entry_unit), bt_list_st); 3121 3122 /* DO STRENGTH REDUCTION */ 3123 3124 call timer (5); 3125 3126 call reduce_strength (lp); 3127 3128 call timer (4); 3129 3130 /* Optionally, print out metering information on the primary lists. */ 3131 3132 if meter_hash_buckets 3133 then call print_hash_bucket_meters; 3134 3135 /* Free all primaries in the back target. 3136* 3137* For each temporary (or array_ref) in the bt_list 3138* that still has used_across_loops bit on and is already 3139* in a loop_end list for an inner loop, put the temp in 3140* the loop_end list for this loop. This fixes bug 218. */ 3141 3142 do i = 0 to hbound (bt_list, 1); 3143 3144 do p = bt_list (i) repeat q while (p ^= null); 3145 q = p -> primary.next; 3146 3147 o = p -> primary.expression; 3148 outp = addr (rands (o -> operator.output)); 3149 if outp -> node.node_type = temporary_node | o -> operator.op_code = opt_subscript_op 3150 then if outp -> temporary.used_across_loops 3151 then if outp -> temporary.loop_end_fu_pos > 0 3152 & outp -> temporary.loop_end_fu_pos < lp -> loop.last_unit -> flow_unit.position 3153 then call put_in_loop_end (outp, lp); 3154 3155 call release_primary (p); 3156 end; 3157 3158 end; 3159 3160 /* consider removing loop */ 3161 3162 if ^lp -> loop.has_side_effects 3163 then if (lp -> loop.set -> bits & lp -> loop.busy_on_exit -> bits) = "0"b 3164 then do; 3165 3166 /* loop must have only 1 exit target */ 3167 3168 if lp -> loop.exits = null 3169 then do; 3170 call print_message (389); /* loop has no exit */ 3171 return; 3172 end; 3173 3174 exit_target = lp -> loop.exits -> chain.value -> edge.to.value; 3175 has_multiple_exits = "0"b; 3176 3177 do c = lp -> loop.exits -> chain.next repeat c -> chain.next while (c ^= null & ^has_multiple_exits); 3178 if exit_target ^= c -> chain.value -> edge.to.value 3179 then has_multiple_exits = "1"b; 3180 end; 3181 3182 if ^has_multiple_exits 3183 then call remove_loop (lp); 3184 end; 3185 3186 end finish_loop; 3187 3188 push_loop: 3189 procedure (); 3190 3191 /* prepares for processing of inner loop for the top-down algorithm */ 3192 3193 dcl i fixed binary (18); 3194 dcl (o, p, q, hold_list, outp, next_lp, last_p) pointer; 3195 3196 /* save the present machine state so we can resume it later */ 3197 3198 hold_list = null; 3199 3200 do i = 0 to hbound (p_list, 1); 3201 do p = p_list (i) repeat p -> primary.next while (p ^= null); 3202 q = create_o_node (hold_list, 0); 3203 q -> primary.data = p -> primary.data; 3204 end; 3205 end; 3206 3207 lpf -> lp_frame.hold_p_list = hold_list; 3208 3209 hold_list = null; 3210 3211 do i = 0 to hbound (bt_list, 1); 3212 do p = bt_list (i) repeat p -> primary.next while (p ^= null); 3213 q = create_o_node (hold_list, 0); 3214 q -> primary.data = p -> primary.data; 3215 end; 3216 end; 3217 3218 lpf -> lp_frame.hold_bt_list = hold_list; 3219 3220 /* save strength reduction candidate state */ 3221 3222 lpf -> lp_frame.hold_incr_chain = incr_chain; 3223 lpf -> lp_frame.hold_sr_chain = sr_chain; 3224 lpf -> lp_frame.hold_sr_tail = sr_tail; 3225 lpf -> lp_frame.hold_ass_chain = ass_chain; 3226 3227 /* now set the loop variants for the new loop */ 3228 3229 next_lp = fu -> flow_unit.successors -> edge.to.value -> flow_unit.loop; 3230 call set_loop_variants (next_lp); 3231 3232 /* add p_list onto bt_list & null out p_list */ 3233 3234 do i = 0 to hbound (p_list, 1); 3235 last_p = null; 3236 3237 do p = p_list (i) repeat p -> primary.next while (p ^= null); 3238 o = p -> primary.expression; 3239 outp = addr (rands (o -> operator.output)); 3240 if outp -> node.node_type = temporary_node | o -> operator.op_code = opt_subscript_op 3241 then outp -> temporary.invariant = "1"b; 3242 last_p = p; 3243 end; 3244 3245 if last_p ^= null 3246 then do; 3247 last_p -> primary.next = bt_list (i); 3248 if bt_list (i) ^= null 3249 then bt_list (i) -> primary.last = last_p; 3250 bt_list (i) = p_list (i); 3251 bt_list (i) -> primary.last = addr (bt_list (i)); 3252 p_list (i) = null; 3253 end; 3254 end; 3255 3256 /* we can now detach secondaries (except for constant assignments), since only loop invariants are left */ 3257 3258 call detach_secondaries ("0"b); 3259 3260 /* fill in insert_* fields in back target of next_lp */ 3261 3262 bt = fu; 3263 3264 call derive_insert_for_bt (bt); 3265 3266 /* build a new opt_statement node to mark place we should resume operation in pop_loop */ 3267 3268 call insert_stm_in_back_target (bt, addr (quad (bt -> flow_unit.insert_statement))); 3269 3270 lpf -> lp_frame.resume_st = bt -> flow_unit.insert_statement; 3271 3272 /* UPDATE lp */ 3273 3274 lp = next_lp; 3275 3276 if lpf -> lp_frame.next = null 3277 then lpf = create_lp_frame (lpf); 3278 else lpf = lpf -> lp_frame.next; 3279 3280 /* We now mask out the used bits of invariant symbols. process_moved_descendants 3281* will turn on the bits of those invariant symbols whose uses are not moved 3282* out of the loop. */ 3283 3284 lp -> loop.used -> bits = lp -> loop.used -> bits & lp -> loop.set -> bits; 3285 3286 end push_loop; 3287 3288 pop_loop: 3289 procedure (); 3290 3291 /* prepares to resume processing of an outer loop after the inner loop is completed. All 3292* expressions moved to the outer loop are now processed. */ 3293 3294 dcl (hold_has_label, hold_has_operator_list, hold_entry_pt, possibly_found) bit (1) aligned; 3295 dcl (p, q, hold_list, new, stm, o, outp, c, last_c, old_lp) pointer; 3296 dcl (hash_index, hold_first_statement) fixed binary (18); 3297 3298 fu = lp -> loop.back_target; 3299 3300 /* RESTORE lp */ 3301 3302 old_lp = lp; 3303 lp = lp -> loop.father; 3304 lpf = lpf -> lp_frame.back; 3305 3306 if lp = null 3307 then return; 3308 3309 /* restore machine state */ 3310 3311 hold_list = lpf -> lp_frame.hold_p_list; 3312 lpf -> lp_frame.hold_p_list = null; 3313 3314 do p = hold_list repeat q while (p ^= null); 3315 q = p -> primary.next; 3316 o = p -> primary.expression; 3317 3318 if ^o -> operator.freed 3319 then do; 3320 outp = addr (rands (o -> operator.output)); 3321 if outp -> node.node_type = temporary_node | o -> operator.op_code = opt_subscript_op 3322 then outp -> temporary.invariant = "0"b; 3323 3324 hash_index = hash (o, possibly_found); 3325 new = create_primary (p_list_st (hash_index)); 3326 new -> primary.data = p -> primary.data; 3327 o -> operator.primary = new; 3328 call record_secondaries (o, 0); 3329 end; 3330 3331 call release_node (p, hold_list, 0); 3332 end; 3333 3334 hold_list = lpf -> lp_frame.hold_bt_list; 3335 lpf -> lp_frame.hold_bt_list = null; 3336 3337 do p = hold_list repeat q while (p ^= null); 3338 q = p -> primary.next; 3339 o = p -> primary.expression; 3340 3341 if ^o -> operator.freed 3342 then do; 3343 hash_index = hash (o, possibly_found); 3344 new = create_primary (bt_list_st (hash_index)); 3345 new -> primary.data = p -> primary.data; 3346 o -> operator.primary = new; 3347 if o -> operator.assigns_constant_to_symbol 3348 then call record_secondaries (o, -1); 3349 end; 3350 3351 call release_node (p, hold_list, 0); 3352 end; 3353 3354 state_discarded = "0"b; 3355 3356 /* restore strength reduction candidate state */ 3357 3358 incr_chain = lpf -> lp_frame.hold_incr_chain; 3359 sr_chain = lpf -> lp_frame.hold_sr_chain; 3360 sr_tail = lpf -> lp_frame.hold_sr_tail; 3361 ass_chain = lpf -> lp_frame.hold_ass_chain; 3362 3363 /* restore other global vars */ 3364 3365 our_depth = lp -> loop.depth; 3366 bt = lp -> loop.back_target; 3367 doing_loop = bt ^= null; 3368 3369 /* process new operators that have been moved up from the inner loop. 3370* This will be done by fooling optimize_flow_unit into doing it. */ 3371 3372 hold_first_statement = fu -> flow_unit.first_statement; 3373 fu -> flow_unit.first_statement = lpf -> lp_frame.resume_st; 3374 stm = addr (quad (fu -> flow_unit.first_statement)); 3375 hold_has_operator_list = stm -> opt_statement.has_operator_list; 3376 stm -> opt_statement.has_operator_list = "0"b; 3377 hold_has_label = fu -> flow_unit.has_label; 3378 fu -> flow_unit.has_label = "0"b; 3379 hold_entry_pt = fu -> flow_unit.entry_pt; 3380 fu -> flow_unit.entry_pt = "0"b; 3381 3382 call optimize_flow_unit (fu, full_optimization, partial_fu, our_depth); 3383 3384 fu -> flow_unit.entry_pt = hold_entry_pt; 3385 fu -> flow_unit.has_label = hold_has_label; 3386 stm -> opt_statement.has_operator_list = hold_has_operator_list; 3387 fu -> flow_unit.first_statement = hold_first_statement; 3388 3389 /* union new p_list with jump_targets first referenced by inner loop */ 3390 3391 if lpf -> lp_frame.first_jump_target ^= null 3392 then do; 3393 call set_loop_variants (old_lp); 3394 3395 last_c = null; 3396 do c = lpf -> lp_frame.first_jump_target repeat c -> chain.next while (c ^= null); 3397 call union ((c -> chain.value), p_list_st); 3398 last_c = c; 3399 end; 3400 3401 last_c -> chain.next = free (size (chain)); 3402 free (size (chain)) = lpf -> lp_frame.first_jump_target; 3403 lpf -> lp_frame.first_jump_target = null; 3404 end; 3405 3406 end pop_loop; 3407 3408 create_lp_frame: 3409 procedure (last_p) returns (pointer); 3410 3411 /* creates lp_frame to help in recursive processing of loops */ 3412 3413 dcl last_p pointer; /* -> lp_frame we are to connect to the new one */ 3414 3415 dcl p pointer; 3416 3417 p = get_opt_space (size (lp_frame)); 3418 3419 p -> lp_frame.next = null; 3420 p -> lp_frame.back = last_p; 3421 if last_p ^= null 3422 then last_p -> lp_frame.next = p; 3423 p -> lp_frame.first_jump_target = null; 3424 3425 return (p); 3426 3427 end create_lp_frame; 3428 3429 optimize_flow_unit: 3430 procedure (p_fu, mode, how_much, p_our_depth); 3431 3432 /* optimize_flow_unit implements an optimization algorithm that has been developed (with many improvements) from 3433* the algorithm used by the Multics PL/I common subexpression optimizer (as of 1977). The two primary lists, 3434* p_list and bt_list, are lists of expressions available for commoning; bt_list is the list of expressions 3435* originating outside of the loop. The secondary list, s_list, is a list of variables upon which the exprs 3436* in the p_list depend. When a variable in s_list is set, all expressions in the p_list depending on that 3437* variable are removed. No expressions are removed from bt_list since they are loop invariant. bt_list 3438* is only used if mode = full_optimization. */ 3439 3440 dcl (fu, p_fu) pointer; /* flow_unit being optimized */ 3441 dcl mode fixed binary (18); /* full_optimization, common_only */ 3442 dcl how_much fixed binary (18); /* complete_fu, partial_fu */ 3443 dcl (our_depth, p_our_depth) fixed binary (18); /* flow_unit's nesting depth */ 3444 3445 dcl ipol fixed bin (18); /* polish index for read_namelist */ 3446 dcl (bt, o, outp, p, q, stm, lp) pointer; 3447 dcl (bd_level_number, coord, i, next_op, next_statement, next_unit_statement, op_code, opnd, outp_node_type, hash_index) 3448 fixed binary (18); 3449 dcl (invariant, is_articulation_block, used_across_loops, reducible, all_constant, have_sr_candidate, 3450 doing_full_optimization, succeeded, optimizing_loop, possibly_found, constant_assignment) bit (1) aligned; 3451 3452 fu = p_fu; 3453 doing_full_optimization = mode = full_optimization; 3454 our_depth = p_our_depth; 3455 3456 if fu -> flow_unit.first_statement = 0 3457 then return; 3458 3459 stm = addr (quad (fu -> flow_unit.first_statement)); 3460 3461 /* process possible label or operator_list starting the flow unit */ 3462 3463 if fu -> flow_unit.has_label | stm -> opt_statement.has_operator_list 3464 then do; 3465 3466 if state_discarded 3467 then do; 3468 call intersection (stm, 1); 3469 call intersection (stm, 3); 3470 end; 3471 3472 if stm -> opt_statement.referenced_backwards & ^stm -> opt_statement.referenced_by_assign 3473 then do; 3474 call set_loop_variants ((fu -> flow_unit.loop)); 3475 3476 /* determine level number of most recently processed back dominator */ 3477 3478 do p = fu -> flow_unit.dominator repeat p -> flow_unit.dominator while (^p -> flow_unit.processed); 3479 end; 3480 3481 bd_level_number = p -> flow_unit.level_number; 3482 3483 /* remove computations first evaluated in a flow unit of higher level number */ 3484 3485 do i = 0 to hbound (p_list, 1); 3486 p = p_list (i); 3487 do while (p ^= null); 3488 if p -> primary.flow_unit -> flow_unit.level_number > bd_level_number 3489 then do; 3490 q = p -> primary.next; 3491 call release_primary (p); 3492 p = q; 3493 end; 3494 else p = p -> primary.next; 3495 end; 3496 end; 3497 3498 if state_discarded 3499 then call intersection (stm, 2); 3500 end; 3501 3502 if ^state_discarded 3503 then do; 3504 call intersection (stm, 1); 3505 call intersection (stm, 2); 3506 end; 3507 3508 if ^fu -> flow_unit.loop_entry 3509 then call trim_operator_list (stm); 3510 3511 state_discarded = "0"b; 3512 3513 end; 3514 3515 /* initialize for optimization loop */ 3516 3517 lp = fu -> flow_unit.loop; 3518 is_articulation_block = substr (lp -> loop.articulation_blocks -> dbits, fu -> flow_unit.number, 1); 3519 bt = lp -> loop.back_target; 3520 if fu -> flow_unit.next ^= null 3521 then next_unit_statement = fu -> flow_unit.next -> flow_unit.first_statement; 3522 else next_unit_statement = 0; 3523 3524 /* mask out used bits for invariant symbols as process_moved_descendants will recalculate these bits */ 3525 3526 if doing_full_optimization & bt ^= null 3527 then do; 3528 if how_much = complete_fu 3529 then fu -> flow_unit.used -> bits = fu -> flow_unit.used -> bits & lp -> loop.set -> bits; 3530 optimizing_loop = "1"b; 3531 end; 3532 else optimizing_loop = "0"b; 3533 3534 /* optimization loop */ 3535 3536 do cur_statement = fu -> flow_unit.first_statement repeat next_statement 3537 while (cur_statement ^= next_unit_statement); 3538 stm = addr (quad (cur_statement)); 3539 next_statement = fixed (stm -> opt_statement.next, 18); 3540 3541 do op = stm -> opt_statement.first_operator repeat next_op while (op ^= next_statement); 3542 o = addr (quad (op)); 3543 op_code = o -> operator.op_code; 3544 next_op = o -> operator.next; 3545 if o -> operator.output > 0 3546 then do; 3547 outp = addr (rands (o -> operator.output)); 3548 outp_node_type = outp -> node.node_type; 3549 end; 3550 else do; 3551 outp = null; 3552 outp_node_type = 0b; 3553 end; 3554 3555 /* determine reducibility and moveability of operands */ 3556 3557 constant_assignment, have_sr_candidate, used_invariant_symbol, used_across_loops = "0"b; 3558 all_constant = "1"b; 3559 reducible = "1"b; 3560 invariant = optimizing_loop; 3561 3562 do i = 1 to o -> operator.number; 3563 opnd = o -> operand (i); 3564 3565 if opnd > 0 3566 then do; 3567 p = addr (rands (opnd)); 3568 3569 if p -> node.node_type = constant_node 3570 then do; 3571 if op_code = opt_subscript_op & i = 3 3572 then call make_constant_opt_subscript (o); 3573 else if have_identity (o, i) 3574 then go to step; 3575 end; 3576 3577 else if p -> node.node_type = array_ref_node 3578 then do; 3579 used_across_loops = used_across_loops | p -> array_ref.used_across_loops; 3580 if p -> array_ref.irreducible 3581 then reducible = "0"b; 3582 invariant = invariant & p -> array_ref.invariant; 3583 p = addr (rands (p -> array_ref.parent)); 3584 all_constant = "0"b; 3585 coord = p -> symbol.coordinate; 3586 if coord > 0 3587 then if substr (lp -> loop.set -> bits, coord, 1) 3588 then invariant = "0"b; 3589 else used_invariant_symbol = optimizing_loop; 3590 p -> symbol.has_constant_value = "0"b; 3591 /* Optimizer botches substring whose parent has constant value. */ 3592 end; 3593 3594 else if p -> node.node_type = symbol_node 3595 then do; 3596 if p -> symbol.has_constant_value & (op_code ^= call_op) & (op_code ^= func_ref_op) 3597 & (op_code ^= opt_subscript_op | i ^= 1) 3598 then do; 3599 o -> operand (i) = 3600 p -> symbol.secondary -> secondary.primary -> chain.value 3601 -> primary.expression -> operand (1); 3602 3603 if op_code = opt_subscript_op & i = 3 3604 then call make_constant_opt_subscript (o); 3605 else if have_identity (o, i) 3606 then go to step; 3607 end; 3608 3609 else do; 3610 all_constant = "0"b; 3611 3612 if i ^= 1 | op_code ^= opt_subscript_op 3613 then do; 3614 coord = p -> symbol.coordinate; 3615 if coord > 0 3616 then if substr (lp -> loop.set -> bits, coord, 1) 3617 then invariant = "0"b; 3618 else used_invariant_symbol = optimizing_loop; 3619 end; 3620 end; 3621 end; 3622 3623 else if p -> node.node_type = temporary_node 3624 then do; 3625 if p -> temporary.frozen_for_do 3626 then call process_frozen_for_do (p); 3627 3628 else do; 3629 all_constant = "0"b; 3630 used_across_loops = used_across_loops | p -> temporary.used_across_loops; 3631 if p -> temporary.irreducible 3632 then reducible = "0"b; 3633 invariant = invariant & p -> temporary.invariant; 3634 end; 3635 end; 3636 end; 3637 end; 3638 3639 if outp_node_type = array_ref_node 3640 then do; 3641 if outp -> array_ref.irreducible 3642 then reducible = "0"b; 3643 used_across_loops = used_across_loops | outp -> array_ref.used_across_loops; 3644 end; 3645 3646 else if outp_node_type = temporary_node 3647 then if outp -> temporary.frozen_for_do 3648 then if addr (rands (o -> operand (1))) -> node.node_type ^= array_ref_node 3649 then invariant = "0"b; 3650 else ; 3651 else ; 3652 3653 else if all_constant & op_code = assign_op 3654 then constant_assignment = constant_assign (o); 3655 3656 if reducible & op_class (op_code) <= highest_reducible_class 3657 then do; 3658 3659 /* handle reducible operators */ 3660 3661 if outp_node_type = temporary_node | op_code = opt_subscript_op 3662 then outp -> temporary.used_across_loops, outp -> temporary.invariant = "0"b; 3663 3664 /* search current machine state for equivalent expression */ 3665 3666 hash_index = hash (o, possibly_found); 3667 3668 if possibly_found 3669 then do; 3670 do p = p_list (hash_index) repeat p -> primary.next while (p ^= null); 3671 q = p -> primary.expression; 3672 if compare_expression (o, q) 3673 then do; 3674 call common (o, q, succeeded); 3675 if succeeded 3676 then go to step; 3677 end; 3678 end; 3679 3680 /* search back target for equivalent expression */ 3681 3682 if invariant 3683 then do p = bt_list (hash_index) repeat p -> primary.next while (p ^= null); 3684 q = p -> primary.expression; 3685 if compare_expression (o, q) 3686 then do; 3687 call common (o, q, succeeded); 3688 go to step; 3689 end; 3690 end; 3691 end; 3692 3693 /* attempt to fold the operation if all operands are constants */ 3694 3695 if all_constant & op_class (op_code) < assignment_class 3696 then if constant_expression (o) 3697 then go to step; 3698 3699 /* try to move the expression */ 3700 3701 if invariant & (is_articulation_block | op_class (op_code) <= always_safe_to_move_class) 3702 then do; 3703 p = outp; 3704 3705 /* check the output operand for suitability */ 3706 3707 if outp_node_type ^= temporary_node 3708 then do; 3709 if outp_node_type = array_ref_node & op_code ^= opt_subscript_op 3710 then do; 3711 invariant = invariant & p -> array_ref.invariant; 3712 if invariant 3713 then p = addr (rands (p -> array_ref.parent)); 3714 end; 3715 3716 if p -> node.node_type = symbol_node 3717 then do; 3718 coord = p -> symbol.coordinate; 3719 if substr (bt -> flow_unit.busy_on_exit -> bits, coord, 1) 3720 | substr (lp -> loop.set_multiple -> bits, coord, 1) 3721 then invariant = "0"b; 3722 end; 3723 end; 3724 3725 if invariant 3726 then do; 3727 3728 /* We can move it! */ 3729 3730 call move (o, stm, fu, bt); 3731 3732 /* add the operator to the back target's machine state */ 3733 3734 p = create_primary (bt_list_st (hash_index)); 3735 p -> primary.expression = o; 3736 p -> primary.flow_unit = bt; 3737 o -> operator.primary = p; 3738 3739 if constant_assignment 3740 then do; 3741 o -> operator.assigns_constant_to_symbol = "1"b; 3742 call record_secondaries (o, -1); 3743 end; 3744 3745 go to step; 3746 end; 3747 end; 3748 3749 /* not moved or commoned, add the expression to the primary list, 3750* process set contexts, and process moved descendants */ 3751 3752 p = create_primary (p_list_st (hash_index)); 3753 p -> primary.expression = o; 3754 p -> primary.flow_unit = fu; 3755 o -> operator.primary = p; 3756 call record_secondaries (o, 1); /* record input operands as secondaries */ 3757 3758 if outp_node_type ^= temporary_node & op_code ^= opt_subscript_op 3759 then do; 3760 call set (outp); 3761 3762 if o -> operator.primary ^= null 3763 /* the primary could have been removed if the target */ 3764 then do; /* also appeared on the right hand side. */ 3765 if constant_assignment 3766 then do; 3767 o -> operator.assigns_constant_to_symbol = "1"b; 3768 if doing_full_optimization & ^outp -> symbol.aliasable 3769 then call chain_dac ((o -> operator.output), fu); 3770 end; 3771 3772 call record_secondaries (o, -1); 3773 /* record output operand as secondary */ 3774 end; 3775 end; 3776 3777 /* look for add, subtract, multiply, or increment by a loop invariant */ 3778 3779 if doing_full_optimization & outp -> node.data_type = int_mode 3780 then if (op_code = mult_op | op_code = add_op | op_code = sub_op) & optimizing_loop 3781 then have_sr_candidate = check_str_reducibility (); 3782 else if op_code = assign_op 3783 then call check_increment; 3784 3785 if ^have_sr_candidate & (used_across_loops | used_invariant_symbol) 3786 then call process_moved_descendants (o, fu); 3787 end; 3788 3789 else do; 3790 3791 /* irreducible operators (and operands) */ 3792 3793 if used_across_loops | used_invariant_symbol 3794 then call process_moved_descendants (o, fu); 3795 3796 if outp_node_type ^= 0b & outp_node_type ^= temporary_node & op_code ^= opt_subscript_op 3797 then call set (outp); 3798 3799 /* handle special cases */ 3800 3801 go to case (op_class (op_code)); 3802 3803 case (4): /* assignment */ 3804 if doing_full_optimization & outp -> node.data_type = int_mode & op_code = assign_op 3805 then call check_increment; 3806 go to join; 3807 3808 case (6): /* call & func_ref */ 3809 do i = 3 to o -> operator.number; 3810 call set (addr (rands (o -> operand (i)))); 3811 end; 3812 3813 call set_externals; 3814 go to join; 3815 3816 case (7): /* entry points */ 3817 call clear ("1"b); 3818 state_discarded = "0"b; 3819 go to join; 3820 3821 case (8): /* jump */ 3822 call process_jump_label ((o -> operand (1))); 3823 state_discarded = "1"b; 3824 go to join; 3825 3826 case (9): /* jump_arithmetic */ 3827 do i = 2 to 4; 3828 call process_jump_label ((o -> operand (i))); 3829 end; 3830 state_discarded = "1"b; 3831 go to join; 3832 3833 case (10): /* jump_computed */ 3834 do i = 1 to o -> operand (1) + bias; 3835 call process_jump_label ((o -> operand (i + 1))); 3836 end; 3837 go to join; 3838 3839 case (11): /* jump_assigned */ 3840 case (13): /* return, stop */ 3841 state_discarded = "1"b; 3842 go to join; 3843 3844 case (12): /* jump_true, jump_false */ 3845 call process_jump_label ((o -> operand (2))); 3846 go to join; 3847 3848 case (18): /* read_namelist */ 3849 ipol = addr (rands (o -> operand (1))) -> symbol.initial; 3850 do i = 1 to polish (ipol); 3851 call set (addr (rands (polish (ipol + i)))); 3852 end; 3853 goto join; 3854 3855 case (1): /* reducible */ 3856 case (2): /* .. */ 3857 case (3): /* .. */ 3858 case (5): /* assignment */ 3859 case (14): /* error_label, end_label */ 3860 case (15): /* irreducible */ 3861 case (16): /* assign_label */ 3862 case (17): /* end_unit */ 3863 case (19): /* write_namelist */ 3864 case (20): /* non_executable, no_op */ 3865 case (21): /* irreducible, partially sets */ 3866 case (22): /* inquire */ 3867 join: 3868 if outp_node_type = temporary_node | op_code = opt_subscript_op 3869 then outp -> temporary.irreducible = "1"b; 3870 end; 3871 3872 step: 3873 end; 3874 3875 end; 3876 3877 fu -> flow_unit.processed = "1"b; 3878 3879 compare_expression: 3880 procedure (pa, pb) returns (bit (1) aligned); 3881 3882 dcl (pa, pb) pointer; 3883 3884 dcl (a, b, r1, r2) pointer; 3885 dcl i fixed binary (18); 3886 3887 a = pa; 3888 b = pb; 3889 3890 /* Although it is inelegant, we compare operand(1) outside the loop 3891* for speed. This is valid because all reducible operators must 3892* have at least one input operand. */ 3893 3894 if a -> operand (1) ^= b -> operand (1) 3895 then go to fail; 3896 3897 if a -> operator.op_code ^= b -> operator.op_code 3898 then go to fail; 3899 3900 if a -> operator.number ^= b -> operator.number 3901 then go to fail; 3902 3903 do i = 2 to a -> operator.number; 3904 if a -> operand (i) ^= b -> operand (i) 3905 then go to fail; 3906 end; 3907 3908 if a -> operator.output ^= b -> operator.output 3909 then do; 3910 r1 = addr (rands (a -> operator.output)); 3911 r2 = addr (rands (b -> operator.output)); 3912 if r1 -> node.node_type ^= r2 -> node.node_type 3913 then go to fail; 3914 if r1 -> node.node_type ^= temporary_node 3915 then if b -> operator.op_code ^= opt_subscript_op 3916 then go to fail; 3917 end; 3918 3919 return ("1"b); 3920 3921 fail: 3922 return ("0"b); 3923 3924 end compare_expression; 3925 3926 common: 3927 procedure (p_old, p_new, succeeded); 3928 3929 /* removes common (or redundant) expressions */ 3930 3931 dcl (p_old, old) pointer, /* ptr to operator to be commoned (input) */ 3932 (p_new, new) pointer, /* ptr to operator already in machine state (input) */ 3933 succeeded bit (1) aligned; /* "1"b if commoning succeeds (output) */ 3934 3935 dcl (old_outp, new_outp, old_startp, new_fu) pointer; 3936 dcl (new_out, old_out, i) fixed binary (18); 3937 3938 old = p_old; 3939 new = p_new; 3940 3941 /* replace instances of old's output with new's output */ 3942 3943 old_out = old -> operator.output; 3944 new_out = new -> operator.output; 3945 new_outp = addr (rands (new_out)); 3946 old_outp = addr (rands (old_out)); 3947 3948 /* if loop nesting depths of new and old differ, then appropriate action must be taken */ 3949 3950 new_fu = new -> operator.primary -> primary.flow_unit; 3951 3952 if new_fu -> flow_unit.loop ^= fu -> flow_unit.loop 3953 then if new_fu -> flow_unit.loop -> loop.depth <= our_depth 3954 then do; 3955 if doing_full_optimization 3956 then new_outp -> temporary.invariant = "1"b; 3957 new_outp -> temporary.used_across_loops = "1"b; 3958 end; 3959 3960 else do; 3961 3962 /* we will allow commoning from inside to ouside only if inner temp has high ref count */ 3963 3964 if new_outp -> node.node_type = temporary_node 3965 then if new_outp -> temporary.ref_count = 1 3966 then do; 3967 succeeded = "0"b; 3968 return; 3969 end; 3970 3971 new -> operator.primary -> primary.flow_unit = fu; 3972 end; 3973 3974 succeeded = "1"b; 3975 3976 /* Do actual commoning */ 3977 3978 if old_outp -> node.node_type = temporary_node | old -> operator.op_code = opt_subscript_op 3979 then do; 3980 if old_outp -> temporary.ref_count > 0 3981 then do; 3982 new_outp -> temporary.ref_count = new_outp -> temporary.ref_count + old_outp -> temporary.ref_count; 3983 old_outp -> temporary.ref_count = 0; 3984 old_startp = addr (polish (old_outp -> temporary.start_input_to)); 3985 3986 call replace_inputs (old_startp, new_out); 3987 3988 addr (polish (new_outp -> temporary.end_input_to)) -> input_to.next = old_startp; 3989 new_outp -> temporary.end_input_to = old_outp -> temporary.end_input_to; 3990 end; 3991 end; 3992 3993 else do; 3994 if old_outp -> node.node_type = array_ref_node 3995 then do; /* ref_count will be decremented by free_operator (disconnect_temporary) */ 3996 old_outp = addr (rands (old_outp -> array_ref.parent)); 3997 end; 3998 3999 /* old_outp is now a symbol, so update busy_on_exit */ 4000 4001 if fu ^= new_fu 4002 then do; 4003 i = old_outp -> symbol.coordinate; 4004 substr (new_fu -> flow_unit.busy_on_exit -> bits, i, 1) = 4005 substr (new_fu -> flow_unit.busy_on_exit -> bits, i, 1) 4006 | (substr (fu -> flow_unit.busy_on_exit -> bits, i, 1) 4007 | substr (fu -> flow_unit.used -> bits, i, 1)); 4008 end; 4009 end; 4010 4011 /* decrement ref counts of inputs and free the operator */ 4012 4013 call decrement_input_ref_counts (old); 4014 4015 call free_operator (old); 4016 4017 end common; 4018 4019 have_identity: 4020 procedure (o, i) returns (bit (1) aligned); 4021 4022 /* this routine looks for adds or subtracts of zero or multiplies by one. These should only have 4023* been produced by the optimizer during strength reduction + constant_expression. This has the problem 4024* of not setting the used bits for symbols replacing the temporary so that the effect must be locally 4025* restricted. */ 4026 4027 dcl o pointer, /* -> operator being checked */ 4028 i fixed binary (18); /* index of operand having a constant value */ 4029 4030 dcl other fixed binary (18); 4031 dcl (otherp, inp) pointer; 4032 4033 if o -> operand (i) = one & op_code = mult_op 4034 | o -> operand (i) = zero & (op_code = add_op | (op_code = sub_op & i = 2)) 4035 then do; 4036 other = o -> operand (3 - i); 4037 otherp = addr (rands (other)); 4038 inp = addr (polish (outp -> temporary.start_input_to)); 4039 4040 call replace_inputs (inp, other); 4041 4042 if otherp -> node.node_type = temporary_node | otherp -> node.node_type = array_ref_node 4043 then do; 4044 otherp -> temporary.ref_count = otherp -> temporary.ref_count - 1 + outp -> temporary.ref_count; 4045 addr (polish (otherp -> temporary.end_input_to)) -> input_to.next = inp; 4046 otherp -> temporary.end_input_to = outp -> temporary.end_input_to; 4047 end; 4048 4049 call free_operator (o); 4050 4051 return ("1"b); 4052 end; 4053 4054 else return ("0"b); 4055 4056 end have_identity; 4057 4058 check_str_reducibility: 4059 procedure () returns (bit (1) aligned); 4060 4061 /* this routine chains together all multiplies, adds, and subtracts by a loop 4062* invariant of a simple integer variable as long as they are not increments or decrements */ 4063 4064 dcl (p, next_op) pointer; 4065 dcl i fixed binary (18); 4066 dcl is_loop_invariant (2) bit (1) aligned; 4067 4068 if op_code ^= mult_op 4069 then do; 4070 next_op = addr (polish (outp -> temporary.start_input_to)) -> input_to.operator; 4071 if next_op -> operator.op_code = assign_op 4072 then if next_op -> operator.output = o -> operand (1) | next_op -> operator.output = o -> operand (2) 4073 then return ("0"b); 4074 end; 4075 4076 is_loop_invariant (1), is_loop_invariant (2) = "0"b; 4077 4078 do i = 1 to 2; 4079 p = addr (rands (o -> operand (i))); 4080 4081 if p -> node.node_type = array_ref_node 4082 then return ("0"b); 4083 4084 else if p -> node.node_type = constant_node 4085 then is_loop_invariant (i) = "1"b; 4086 4087 else if p -> node.node_type = temporary_node 4088 then if p -> temporary.invariant 4089 then is_loop_invariant (i) = "1"b; 4090 else return ("0"b); 4091 4092 else if ^substr (lp -> loop.set -> bits, p -> symbol.coordinate, 1) 4093 then is_loop_invariant (i) = "1"b; 4094 else if p -> symbol.aliasable | p -> symbol.dimensioned 4095 | substr (lp -> loop.set_multiple -> bits, p -> symbol.coordinate, 1) 4096 then return ("0"b); 4097 4098 end; 4099 4100 /* if both or neither are loop invariant, then give up */ 4101 4102 if is_loop_invariant (1) = is_loop_invariant (2) 4103 then return ("0"b); 4104 4105 if is_loop_invariant (1) 4106 then i = 2; 4107 else i = 1; 4108 4109 /* chain this on sr_chain */ 4110 4111 call chain_sr_cand (o, i, stm); 4112 4113 return ("1"b); 4114 4115 end check_str_reducibility; 4116 4117 check_increment: 4118 procedure (); 4119 4120 /* this routine optimizes incrementing and decrementing of an integer variable by replacing the 2 operations 4121* with a "to_storage" op. It then chains operators that update induction variables. */ 4122 4123 dcl (oexpr, inp, incrp) pointer; 4124 dcl (target, i, op_code, input) fixed binary (18); 4125 dcl is_temp_or_array_ref bit (1) aligned; 4126 4127 input = o -> operand (1); 4128 inp = addr (rands (input)); 4129 4130 if inp -> node.node_type ^= temporary_node 4131 then do; 4132 if bt ^= null & inp -> node.node_type = symbol_node & outp_node_type = symbol_node 4133 & full_strength_reduction 4134 then do; 4135 4136 /* The assignment is of the form i = j. If both variables 4137* could be induction variables, then chain the assignment 4138* on ass_chain. Obviously, if RHS is known to be an 4139* induction variable, we can chain directly on incr_chain. */ 4140 4141 if ^outp -> symbol.aliasable & ^substr (lp -> loop.set_multiple -> bits, outp -> symbol.coordinate, 1) 4142 then if substr (lp -> loop.induction_var -> bits, inp -> symbol.coordinate, 1) 4143 then do; 4144 substr (lp -> loop.induction_var -> bits, outp -> symbol.coordinate, 1) = "1"b; 4145 call chain_incr (o, stm, incr_chain); 4146 end; 4147 else if ^inp -> symbol.aliasable & substr (lp -> loop.set -> bits, inp -> symbol.coordinate, 1) 4148 & ^substr (lp -> loop.set_multiple -> bits, inp -> symbol.coordinate, 1) 4149 then call chain_incr (o, stm, ass_chain); 4150 end; 4151 4152 return; 4153 end; 4154 4155 /* See if this operation is an incrementing or decrementing of an integer. */ 4156 4157 oexpr = addr (quad (inp -> temporary.output_by)); 4158 op_code = oexpr -> operator.op_code; 4159 4160 if op_code ^= add_op & op_code ^= sub_op 4161 then return; 4162 4163 target = o -> operator.output; 4164 4165 do i = 1 to 2 while (oexpr -> operand (i) ^= target); 4166 end; 4167 4168 if i > 2 4169 then return; 4170 4171 /* we have an optimizable incrementing or decrementing. Make the new operator. */ 4172 4173 incrp = addr (rands (oexpr -> operand (3 - i))); 4174 is_temp_or_array_ref = incrp -> node.node_type = array_ref_node | incrp -> node.node_type = temporary_node; 4175 4176 if op_code = add_op 4177 then if incrp = onep 4178 then do; 4179 o -> operator.op_code = storage_add_one_op; 4180 o -> operator.number = 0; 4181 end; 4182 else do; 4183 o -> operator.op_code = storage_add_op; 4184 o -> operand (1) = oexpr -> operand (3 - i); 4185 end; 4186 4187 else do; 4188 o -> operand (1) = oexpr -> operand (3 - i); 4189 if i = 1 4190 then o -> operator.op_code = neg_storage_add_op; 4191 else o -> operator.op_code = storage_sub_op; 4192 end; 4193 4194 /* now adjust ref counts */ 4195 4196 if inp -> temporary.ref_count <= 1 4197 then do; 4198 if outp_node_type = array_ref_node 4199 then outp -> array_ref.ref_count = outp -> array_ref.ref_count - 1; 4200 4201 call free_operator (oexpr); 4202 end; 4203 4204 else do; 4205 call disconnect_temporary (inp, o); 4206 if is_temp_or_array_ref 4207 then incrp -> temporary.ref_count = incrp -> temporary.ref_count + 1; 4208 end; 4209 4210 /* adjust the input chains */ 4211 4212 if is_temp_or_array_ref 4213 then call chain_input (incrp, o, 1); 4214 4215 /* see if this incrementing should go on the incr_chain. */ 4216 4217 if o -> operator.op_code = storage_sub_op | bt = null 4218 then return; 4219 4220 /* the target must be a simple integer, set only once in the loop */ 4221 4222 if outp_node_type = array_ref_node 4223 then return; 4224 4225 if outp -> symbol.aliasable | substr (lp -> loop.set_multiple -> bits, outp -> symbol.coordinate, 1) 4226 then return; 4227 4228 /* the increment must be loop invariant and not an array element */ 4229 4230 if incrp -> node.node_type = array_ref_node 4231 then return; 4232 4233 else if incrp -> node.node_type = symbol_node 4234 then if incrp -> symbol.aliasable | substr (lp -> loop.set -> bits, incrp -> symbol.coordinate, 1) 4235 then return; 4236 else ; 4237 4238 else if incrp -> node.node_type = temporary_node 4239 then if incrp -> temporary.invariant 4240 then if addr (quad (incrp -> temporary.output_by)) -> operator.primary -> primary.flow_unit 4241 -> flow_unit.loop = lp 4242 then return; 4243 else ; 4244 else return; 4245 4246 /* We have found an induction variable, mark and chain it. */ 4247 4248 substr (lp -> loop.induction_var -> bits, outp -> symbol.coordinate, 1) = "1"b; 4249 4250 call chain_incr (o, stm, incr_chain); 4251 4252 end check_increment; 4253 4254 process_frozen_for_do: 4255 procedure (pt); 4256 4257 /* either sets appropriate bits for temp used to freeze do increment or limit, or replaces it with a symbol */ 4258 4259 dcl (p, pt) pointer; /* -> temporary with frozen_for_do bit on */ 4260 4261 dcl (assp, s) pointer; 4262 dcl hash_index fixed binary (18); 4263 dcl possibly_found bit (1) aligned; 4264 4265 p = pt; 4266 4267 /* get ptr to operator producing this temp (it must be assign_op) */ 4268 4269 assp = addr (quad (p -> temporary.output_by)); 4270 4271 /* if rhs is invariant symbol or constant, then we will replace the temp */ 4272 4273 s = addr (rands (assp -> operand (1))); 4274 4275 if s -> node.node_type = constant_node 4276 then do; 4277 call replace_lhs_with_rhs; 4278 return; 4279 end; 4280 4281 if s -> node.node_type = symbol_node 4282 then if ^substr (lp -> loop.set -> bits, s -> symbol.coordinate, 1) 4283 then if bt ^= null () 4284 then if ^substr (bt -> flow_unit.set -> bits, s -> symbol.coordinate, 1) 4285 then do; 4286 call replace_lhs_with_rhs; 4287 4288 used_invariant_symbol = "1"b; 4289 all_constant = "0"b; 4290 4291 return; 4292 end; 4293 4294 all_constant, p -> temporary.irreducible, p -> temporary.frozen_for_do = "0"b; 4295 4296 /* following code should be executed only if we're in a real loop */ 4297 4298 if bt ^= null 4299 then do; 4300 p -> temporary.invariant, p -> temporary.used_across_loops, used_across_loops = "1"b; 4301 4302 4303 /* we have to make sure there is a primary for assp so that 4304* process_moved_descendants will work */ 4305 4306 if assp -> operator.primary = null 4307 then do; 4308 hash_index = hash (assp, possibly_found); 4309 p = create_primary (bt_list_st (hash_index)); 4310 p -> primary.expression = assp; 4311 p -> primary.flow_unit = bt; 4312 assp -> operator.primary = p; 4313 end; 4314 end; 4315 4316 replace_lhs_with_rhs: 4317 procedure (); 4318 4319 call replace_inputs (addr (polish (p -> temporary.start_input_to)), (assp -> operand (1))); 4320 call free_operator (assp); 4321 4322 end replace_lhs_with_rhs; 4323 4324 end process_frozen_for_do; 4325 4326 end optimize_flow_unit; 4327 4328 decrement_input_ref_counts: 4329 procedure (p_o); 4330 4331 /* decrements input operand ref_counts */ 4332 4333 dcl (i, opnd) fixed binary (18); 4334 dcl (p_o, o, p) pointer; 4335 4336 o = p_o; 4337 4338 do i = 1 to o -> operator.number; 4339 opnd = o -> operand (i); 4340 if opnd > 0 4341 then do; 4342 p = addr (rands (opnd)); 4343 if p -> node.node_type = temporary_node | p -> node.node_type = array_ref_node 4344 then p -> temporary.ref_count = p -> temporary.ref_count - 1; 4345 end; 4346 end; 4347 4348 end decrement_input_ref_counts; 4349 4350 chain_sr_cand: 4351 procedure (o, i, stm); 4352 4353 /* adds a new sr_cand to the tail of the sr_chain */ 4354 4355 dcl o pointer, 4356 i fixed binary (18), 4357 stm pointer; 4358 4359 dcl src pointer; 4360 4361 if free (size (sr_cand)) = null 4362 then src = get_opt_space (size (sr_cand)); 4363 else do; 4364 src = free (size (sr_cand)); 4365 free (size (sr_cand)) = free (size (sr_cand)) -> sr_cand.next; 4366 end; 4367 4368 src -> sr_cand.operator = o; 4369 src -> sr_cand.which = i; 4370 src -> sr_cand.statement = stm; 4371 src -> sr_cand.next = null; 4372 4373 if sr_tail = null 4374 then sr_chain = src; 4375 else sr_tail -> sr_cand.next = src; 4376 4377 sr_tail = src; 4378 4379 end chain_sr_cand; 4380 4381 chain_incr: 4382 procedure (o, stm, incr_chain); 4383 4384 /* chain incr node on incr_chain */ 4385 4386 dcl (o, stm, incr_chain) pointer; 4387 4388 dcl c pointer; 4389 4390 if free (size (incr)) = null 4391 then c = get_opt_space (size (incr)); 4392 else do; 4393 c = free (size (incr)); 4394 free (size (incr)) = free (size (incr)) -> incr.next; 4395 end; 4396 4397 c -> incr.value = o; 4398 c -> incr.statement = stm; 4399 c -> incr.var_chain = null; 4400 c -> incr.next = incr_chain; 4401 incr_chain = c; 4402 4403 end chain_incr; 4404 4405 replace_inputs: 4406 procedure (p_inp, p_new_out); 4407 4408 dcl p_inp pointer; /* beginning of inputs chain to be processed */ 4409 dcl (new_out, p_new_out) fixed binary (18); /* operand that replaces present output */ 4410 4411 dcl inp pointer; 4412 4413 new_out = p_new_out; 4414 4415 do inp = p_inp repeat inp -> input_to.next while (inp ^= null); 4416 if inp -> input_to.which > 0 4417 then inp -> input_to.operator -> operator.operand (inp -> input_to.which) = new_out; 4418 else if inp -> input_to.which = 0 4419 then inp -> input_to.operator -> operator.output = new_out; 4420 else inp -> input_to.operator -> lchain.value = new_out; 4421 end; 4422 4423 end replace_inputs; 4424 4425 set: 4426 procedure (pt); 4427 4428 /* set is called whenever a variable is seen to be set */ 4429 4430 dcl (p, pt, q, secp) pointer; 4431 dcl dt fixed binary (4); 4432 4433 p = pt; 4434 if p -> node.node_type = array_ref_node 4435 then p = addr (rands (p -> array_ref.parent)); 4436 4437 if p -> node.node_type = symbol_node 4438 then do; 4439 if ^p -> symbol.aliasable 4440 then do; 4441 secp = p -> symbol.secondary; 4442 if secp ^= null 4443 then do; 4444 call free_them (secp); 4445 call release_node (secp, s_list, 2); 4446 end; 4447 return; 4448 end; 4449 4450 if p -> symbol.parameter 4451 then do; 4452 dt = p -> symbol.data_type; 4453 4454 secp = s_list; 4455 do while (secp ^= null); 4456 q = secp -> secondary.symbol; 4457 if (q -> symbol.parameter | q -> symbol.in_common) & q -> symbol.data_type = dt 4458 then call free_secondary (secp); 4459 else secp = secp -> secondary.next; 4460 end; 4461 4462 return; 4463 end; 4464 4465 if ^p -> symbol.in_equiv_stmnt 4466 then do; 4467 4468 /* must be in common, but not equivalenced */ 4469 4470 dt = p -> symbol.data_type; 4471 4472 secp = s_list; 4473 do while (secp ^= null); 4474 q = secp -> secondary.symbol; 4475 if q = p | (q -> symbol.parameter & q -> symbol.data_type = dt) 4476 then call free_secondary (secp); 4477 else secp = secp -> secondary.next; 4478 end; 4479 4480 return; 4481 end; 4482 4483 /* must be equivalenced */ 4484 4485 dt = p -> symbol.data_type; 4486 4487 call set_equivalences (p, dt); /* set our symbol and possible aliases */ 4488 4489 /* reals and complex vars may be equivalenced together and 4490* be defined at the same time */ 4491 4492 if dt = real_mode 4493 then call set_equivalences (p, cmpx_mode); 4494 4495 else if dt = cmpx_mode 4496 then call set_equivalences (p, real_mode); 4497 4498 return; 4499 end; 4500 4501 end set; 4502 4503 set_externals: 4504 procedure (); 4505 4506 dcl (s, secp) pointer; 4507 4508 secp = s_list; 4509 do while (secp ^= null); 4510 s = secp -> secondary.symbol; 4511 if s -> symbol.parameter | s -> symbol.in_common 4512 then call free_secondary (secp); 4513 else secp = secp -> secondary.next; 4514 end; 4515 4516 end set_externals; 4517 4518 set_equivalences: 4519 procedure (pt, p_dt); 4520 4521 dcl (pt, p) pointer, /* points to equivalenced symbol that was set */ 4522 (p_dt, dt) fixed binary (4); /* data_type of equivalenced symbols to be set */ 4523 4524 dcl (q, secp) pointer; 4525 dcl (head, off) fixed binary (18); 4526 dcl delta fixed binary (1); 4527 4528 p = pt; 4529 dt = p_dt; 4530 head = p -> symbol.parent; 4531 off = p -> symbol.offset; 4532 4533 delta = fixed (p -> symbol.data_type ^= dt, 1); 4534 4535 secp = s_list; 4536 do while (secp ^= null); 4537 q = secp -> secondary.symbol; 4538 if q -> symbol.aliasable & q -> symbol.data_type = dt 4539 & ((q -> symbol.parameter & p -> symbol.in_common) 4540 | (q -> symbol.parent = head & q -> symbol.in_equiv_stmnt 4541 & (q -> symbol.dimensioned | p -> symbol.dimensioned | abs (q -> symbol.offset - off) <= delta))) 4542 then call free_secondary (secp); 4543 else secp = secp -> secondary.next; 4544 end; 4545 4546 end set_equivalences; 4547 4548 free_secondary: 4549 procedure (p_secp); 4550 4551 dcl (p_secp, secp) pointer; 4552 4553 secp = p_secp; 4554 p_secp = secp -> secondary.next; 4555 call free_them (secp); 4556 call release_node (secp, s_list, 2); 4557 4558 end free_secondary; 4559 4560 set_loop_variants: 4561 procedure (p_lp); 4562 4563 dcl (lp, p_lp, secp, s) pointer; 4564 4565 lp = p_lp; 4566 secp = s_list; 4567 do while (secp ^= null); 4568 s = secp -> secondary.symbol; 4569 if substr (lp -> loop.set -> bits, s -> symbol.coordinate, 1) 4570 then call free_secondary (secp); 4571 else secp = secp -> secondary.next; 4572 end; 4573 4574 end set_loop_variants; 4575 4576 free_them: 4577 procedure (p_secp); 4578 4579 dcl (p_secp, secp) pointer; 4580 4581 dcl (o, outp, p, c, inp, lastc) pointer; 4582 dcl (j, lvec) fixed binary (18); 4583 dcl queue (256) pointer unaligned; 4584 4585 lastc = null; 4586 secp = p_secp; 4587 4588 do c = secp -> secondary.primary repeat c -> chain.next while (c ^= null); 4589 p = c -> chain.value; 4590 if p -> primary.expression ^= null 4591 then do; 4592 o = p -> primary.expression; 4593 o -> operator.primary = null; 4594 queue (1) = o; 4595 j = 0; 4596 lvec = 1; 4597 call release_primary (p); 4598 4599 /* use a queue to avoid recursive walk */ 4600 4601 do while (j ^= lvec); 4602 j = j + 1; 4603 if j > hbound (queue, 1) 4604 then j = 1; 4605 4606 o = queue (j); 4607 outp = addr (rands (o -> operator.output)); 4608 4609 if outp -> node.node_type = temporary_node | o -> operator.op_code = opt_subscript_op 4610 then if outp -> temporary.start_input_to > 0 4611 then do inp = addr (polish (outp -> temporary.start_input_to)) 4612 repeat inp -> input_to.next while (inp ^= null); 4613 o = inp -> input_to.operator; 4614 4615 if inp -> input_to.which >= 0 4616 /* must be an operator */ 4617 then if o -> operator.primary ^= null 4618 then do; 4619 p = o -> operator.primary; 4620 o -> operator.primary = null; 4621 4622 lvec = lvec + 1; 4623 if lvec > hbound (queue, 1) 4624 then lvec = 1; 4625 if lvec ^= j 4626 then queue (lvec) = o; 4627 else call print_message (414, "The set queue", hbound (queue, 1) - bias) 4628 ; 4629 4630 call release_primary (p); 4631 end; 4632 end; 4633 end; 4634 end; 4635 lastc = c; 4636 end; 4637 4638 if lastc ^= null 4639 then do; 4640 lastc -> chain.next = free (size (chain)); 4641 free (size (chain)) = secp -> secondary.primary; 4642 end; 4643 4644 end free_them; 4645 4646 record_secondaries: 4647 procedure (p_o, p_code); 4648 4649 dcl (p_o, o) pointer, /* ptr to operator node whose operands are being recorded */ 4650 (p_code, code) fixed binary (18); /* setting of code is: 4651* -1 record output only 4652* 0 record all operands 4653* +1 record input only */ 4654 4655 dcl i fixed binary (18); 4656 dcl have_opt_subscript bit (1) aligned; 4657 4658 o = p_o; 4659 have_opt_subscript = o -> operator.op_code = opt_subscript_op; 4660 code = p_code; 4661 4662 if code >= 0 4663 then do i = 1 to o -> operator.number; 4664 if ^have_opt_subscript | i ^= 1 4665 then call record ((o -> operand (i))); 4666 end; 4667 4668 if code <= 0 4669 then if ^have_opt_subscript 4670 then do; 4671 i = o -> operator.output; 4672 if o -> operator.assigns_constant_to_symbol 4673 then addr (rands (i)) -> symbol.has_constant_value = "1"b; 4674 4675 call record (i); 4676 end; 4677 4678 record: 4679 procedure (opnd); 4680 4681 dcl opnd fixed binary (18); 4682 4683 dcl (s, secp, c) pointer; 4684 4685 if opnd > 0 4686 then do; 4687 s = addr (rands (opnd)); 4688 4689 if s -> node.node_type = array_ref_node 4690 then s = addr (rands (s -> array_ref.parent)); 4691 4692 if s -> node.node_type = symbol_node 4693 then if s -> symbol.coordinate > 0 4694 then do; 4695 if s -> symbol.secondary = null 4696 then do; 4697 secp = create_o_node (s_list, 2); 4698 secp -> secondary.symbol = s; 4699 secp -> secondary.primary = null; 4700 s -> symbol.secondary = secp; 4701 end; 4702 else secp = s -> symbol.secondary; 4703 4704 c = create_chain (); 4705 c -> chain.value = o -> operator.primary; 4706 c -> chain.next = secp -> secondary.primary; 4707 secp -> secondary.primary = c; 4708 end; 4709 end; 4710 4711 end record; 4712 4713 end record_secondaries; 4714 4715 process_jump_label: 4716 procedure (lab); 4717 4718 dcl lab fixed binary (18); /* operand number of label */ 4719 4720 dcl (stm, q, t, new, target_fu, target_lp, c, last, p, pf, target_optr) pointer; 4721 dcl i fixed binary (18); 4722 4723 stm = addr (quad (addr (rands (lab)) -> label.statement)); 4724 go to join; 4725 4726 process_jump_target: 4727 entry (stmnt); 4728 4729 dcl stmnt fixed binary (18); /* offset in quad of statement */ 4730 4731 stm = addr (quad (stmnt)); 4732 4733 join: 4734 target_fu = stm -> opt_statement.flow_unit; 4735 4736 if target_fu -> flow_unit.position > fu -> flow_unit.position & ^stm -> opt_statement.referenced_by_assign 4737 then if stm -> opt_statement.has_operator_list 4738 then call intersection (stm, 2); 4739 else do; 4740 4741 /* this is the first forward jump to the target to be processed, so create an operator list */ 4742 4743 if target_fu -> flow_unit.is_active_operator = null 4744 then target_fu -> flow_unit.is_active_operator = get_opt_space (size (obits)); 4745 target_optr = target_fu -> flow_unit.is_active_operator; 4746 4747 t = null; 4748 4749 do i = 0 to hbound (p_list, 1); 4750 do q = p_list (i) repeat q -> primary.next while (q ^= null); 4751 new = create_o_node (t, 0); 4752 new -> primary.data = q -> primary.data; 4753 substr (target_optr -> obits, q -> primary.expression -> operator.coordinate, 1) = "1"b; 4754 end; 4755 end; 4756 4757 /* if going to an outer loop, stick the bt_list in too */ 4758 4759 if ^need_consolidation_pass & our_depth > target_fu -> flow_unit.loop -> loop.depth 4760 then do; 4761 do i = 0 to hbound (bt_list, 1); 4762 do q = bt_list (i) repeat q -> primary.next while (q ^= null); 4763 new = create_o_node (t, 0); 4764 new -> primary.data = q -> primary.data; 4765 substr (target_optr -> obits, q -> primary.expression -> operator.coordinate, 1) = 4766 "1"b; 4767 end; 4768 end; 4769 4770 /* Add this target to the chain of targets to be processed when the loop is done. 4771* Anything added to bt_list will then be added to the target's operator_list. */ 4772 4773 target_lp = target_fu -> flow_unit.loop; 4774 last = null; 4775 pf = lpf -> lp_frame.back; 4776 4777 do p = lp -> loop.father repeat p -> loop.father while (last ^= target_lp); 4778 c = create_chain (); 4779 c -> chain.value = target_fu; 4780 c -> chain.next = pf -> lp_frame.first_jump_target; 4781 pf -> lp_frame.first_jump_target = c; 4782 pf = pf -> lp_frame.back; 4783 last = p; 4784 end; 4785 end; 4786 4787 if t ^= null 4788 then stm -> opt_statement.operator_list = t; 4789 stm -> opt_statement.has_operator_list = "1"b; 4790 end; 4791 4792 end process_jump_label; 4793 4794 intersection: 4795 procedure (p_state, p_i); 4796 4797 /* this routine gets the intersection of the p_list and the primary list attached to the statement node. 4798* If i = 2 the statement node list is replaced by the intersection. 4799* If i = 1, the primary list p_list is replaced by the intersection. 4800* If i = 3, the primary list p_list is replaced by the union of p_list and the statement node list. */ 4801 4802 dcl (p_state, state, o, p, st_list, t, next_p, obptr) pointer; 4803 dcl (i, p_i, j) fixed binary (18); 4804 dcl possibly_found bit (1) aligned; 4805 4806 state = p_state; 4807 i = p_i; 4808 4809 if i = 1 & state -> opt_statement.referenced_by_assign 4810 then do; 4811 call clear ("1"b); 4812 return; 4813 end; 4814 4815 if ^state -> opt_statement.has_operator_list 4816 then return; 4817 4818 st_list = state -> opt_statement.operator_list; 4819 4820 obptr = state -> opt_statement.flow_unit -> flow_unit.is_active_operator; 4821 4822 if i = 1 4823 then do; 4824 do j = 0 to hbound (p_list, 1); 4825 do p = p_list (j) repeat next_p while (p ^= null); 4826 next_p = p -> primary.next; 4827 4828 if ^substr (obptr -> obits, p -> primary.expression -> operator.coordinate, 1) 4829 then call release_primary (p); 4830 4831 end; 4832 end; 4833 4834 return; 4835 end; 4836 4837 p = st_list; 4838 4839 do while (p ^= null); 4840 next_p = p -> primary.next; 4841 4842 /* we can use operator.primary to determine if an operator 4843* is in the primary list! */ 4844 4845 if p -> primary.expression -> operator.primary ^= null 4846 then go to next; 4847 4848 /* this element is not common to both lists */ 4849 4850 go to case (i); 4851 4852 case (2): 4853 substr (obptr -> obits, p -> primary.expression -> operator.coordinate, 1) = "0"b; 4854 call release_node (p, st_list, 0); 4855 go to end_case; 4856 4857 case (3): 4858 o = p -> primary.expression; 4859 4860 if ^o -> operator.freed /* op must not be freed */ 4861 then do; 4862 j = hash (o, possibly_found); 4863 t = create_primary (p_list_st (j)); 4864 t -> primary.data = p -> primary.data; 4865 o -> operator.primary = t; 4866 call record_secondaries (o, 0); 4867 end; 4868 4869 end_case: 4870 next: 4871 p = next_p; 4872 end; 4873 4874 if i = 2 4875 then state -> opt_statement.operator_list = st_list; 4876 4877 end intersection; 4878 4879 union: 4880 procedure (fu, p_list_st); 4881 4882 /* this routine replaces the primary list hanging off the first statement of the given flow unit with the 4883* union of that list and the given primary list */ 4884 4885 dcl fu pointer, /* given flow_unit */ 4886 1 p_list_st (0:10) aligned, /* given primary list */ 4887 2 p_list pointer unaligned; 4888 4889 dcl (stm, st_list, p, q, t, obptr) pointer; 4890 dcl i fixed binary (18); 4891 4892 stm = addr (quad (fu -> flow_unit.first_statement)); 4893 if stm -> opt_statement.referenced_by_assign 4894 then return; 4895 4896 if fu -> flow_unit.is_active_operator = null 4897 then fu -> flow_unit.is_active_operator = get_opt_space (size (obits)); 4898 obptr = fu -> flow_unit.is_active_operator; 4899 4900 if stm -> opt_statement.operator_list = null 4901 then do; 4902 st_list = null; 4903 do i = 0 to hbound (p_list, 1); 4904 do q = p_list (i) repeat q -> primary.next while (q ^= null); 4905 p = create_o_node (st_list, 0); 4906 p -> primary.data = q -> primary.data; 4907 substr (obptr -> obits, p -> primary.expression -> operator.coordinate, 1) = "1"b; 4908 end; 4909 end; 4910 stm -> opt_statement.operator_list = st_list; 4911 end; 4912 4913 else do; 4914 st_list = stm -> opt_statement.operator_list; 4915 4916 do i = 0 to hbound (p_list, 1); 4917 do p = p_list (i) repeat p -> primary.next while (p ^= null); 4918 if ^substr (obptr -> obits, p -> primary.expression -> operator.coordinate, 1) 4919 then do; 4920 substr (obptr -> obits, p -> primary.expression -> operator.coordinate, 1) = "1"b; 4921 t = create_o_node (st_list, 0); 4922 t -> primary.data = p -> primary.data; 4923 end; 4924 end; 4925 end; 4926 4927 stm -> opt_statement.operator_list = st_list; 4928 end; 4929 4930 stm -> opt_statement.has_operator_list = "1"b; 4931 4932 end union; 4933 4934 trim_operator_list: 4935 procedure (stm); 4936 4937 /* this routine is called after all intersections on a statement have been processed. 4938* It releases those primaries not needed for the code generator. */ 4939 4940 dcl stm pointer; /* -> opt_statement whose operator_list is to be trimmed */ 4941 4942 dcl (p, q, st_list) pointer; 4943 dcl our_depth fixed binary (18); 4944 4945 if stm -> opt_statement.operator_list ^= null 4946 then do; 4947 our_depth = lp -> loop.depth; 4948 st_list = stm -> opt_statement.operator_list; 4949 4950 do p = st_list repeat q while (p ^= null); 4951 q = p -> primary.next; 4952 if our_depth > p -> primary.flow_unit -> flow_unit.loop -> loop.depth 4953 then call release_node (p, st_list, 0); 4954 end; 4955 4956 stm -> opt_statement.operator_list = st_list; 4957 end; 4958 4959 end trim_operator_list; 4960 4961 clear: 4962 procedure (zero_hash_mask); 4963 4964 /* this routine releases all primaries on p_list and releases all secondaries. bt_list is left unchanged. */ 4965 4966 dcl zero_hash_mask bit (1) aligned; 4967 dcl (p, q) pointer; 4968 dcl i fixed binary (18); 4969 4970 do i = 0 to hbound (p_list, 1); 4971 do p = p_list (i) repeat q while (p ^= null); 4972 q = p -> primary.next; 4973 call release_primary (p); 4974 end; 4975 end; 4976 4977 if zero_hash_mask 4978 then hash_mask = "0"b; 4979 4980 call detach_secondaries ("1"b); 4981 4982 end clear; 4983 4984 detach_secondaries: 4985 procedure (p_detach_constant_assignments); 4986 4987 /* this routine releases all secondaries */ 4988 4989 dcl (detach_constant_assignments, p_detach_constant_assignments) bit (1) aligned; 4990 4991 dcl (p, q, c, lastc) pointer; 4992 4993 detach_constant_assignments = p_detach_constant_assignments; 4994 4995 do p = s_list repeat q while (p ^= null); 4996 q = p -> secondary.next; 4997 4998 if detach_constant_assignments | ^p -> secondary.symbol -> symbol.has_constant_value 4999 then do; 5000 lastc = null; 5001 do c = p -> secondary.primary repeat c -> chain.next while (c ^= null); 5002 lastc = c; 5003 end; 5004 5005 if lastc ^= null 5006 then do; 5007 lastc -> chain.next = free (size (chain)); 5008 free (size (chain)) = p -> secondary.primary; 5009 end; 5010 5011 call release_node (p, s_list, 2); 5012 end; 5013 end; 5014 5015 /* put free primaries on the free list. It is safe to do this because no more secondaries exist 5016* that point to the free primaries. */ 5017 5018 if freep_tail ^= null 5019 then do; 5020 freep_tail -> primary.next = free (size (primary)); 5021 free (size (primary)) = freep; 5022 freep_tail, freep = null; 5023 end; 5024 5025 end detach_secondaries; 5026 5027 release_node: 5028 procedure (pt, list_head, i); 5029 5030 /* these routines are utility routines to create and free nodes. i = 0 for statement list primary nodes. 5031* i = 1 for p_list or bt_list primary nodes (no longer implemented here). i = 2 for secondary nodes. */ 5032 5033 dcl (p, pt, list_head) pointer; 5034 dcl i fixed binary (18); 5035 5036 p = pt; 5037 5038 if p -> primary.next ^= null 5039 then p -> primary.next -> primary.last = p -> primary.last; 5040 if p -> primary.last = null 5041 then list_head = p -> primary.next; 5042 else p -> primary.last -> primary.next = p -> primary.next; 5043 5044 if i = 2 /* secondary node */ 5045 then do; 5046 p -> secondary.symbol -> symbol.secondary = null; 5047 p -> secondary.symbol -> symbol.has_constant_value = "0"b; 5048 end; 5049 5050 p -> primary.next = free (size (primary)); 5051 free (size (primary)) = p; 5052 5053 p -> primary.last = null; 5054 5055 end release_node; 5056 5057 create_o_node: 5058 procedure (list_head, i) returns (pointer); 5059 5060 dcl (list_head, p) pointer; 5061 dcl i fixed binary (18); 5062 5063 if free (size (primary)) = null 5064 then p = get_opt_space (size (primary)); 5065 else do; 5066 p = free (size (primary)); 5067 free (size (primary)) = free (size (primary)) -> primary.next; 5068 end; 5069 5070 p -> primary.last = null; 5071 p -> primary.next = list_head; 5072 if list_head ^= null 5073 then list_head -> primary.last = p; 5074 list_head = p; 5075 return (p); 5076 5077 end create_o_node; 5078 5079 release_primary: 5080 procedure (pt); 5081 5082 /* these routines are utility routines to create and free primary nodes for the hash lists: 5083* p_list & bt_list. They take advantage of the fact that primary.next is the first 5084* word of the primary node. */ 5085 5086 dcl (p, pt, o) pointer; 5087 5088 p = pt; 5089 5090 if p -> primary.next ^= null 5091 then p -> primary.next -> primary.last = p -> primary.last; 5092 p -> primary.last -> primary.next = p -> primary.next; 5093 5094 if freep = null 5095 then freep_tail = p; 5096 5097 o = p -> primary.expression; 5098 o -> operator.primary = null; 5099 if o -> operator.assigns_constant_to_symbol 5100 then addr (rands (o -> operator.output)) -> symbol.has_constant_value = "0"b; 5101 5102 p -> primary.expression = null; 5103 p -> primary.next = freep; 5104 freep = p; 5105 5106 p -> primary.last = null; 5107 5108 end release_primary; 5109 5110 create_primary: 5111 procedure (list_head_st) returns (pointer); 5112 5113 dcl 1 list_head_st aligned, 5114 2 list_head pointer unaligned; 5115 5116 dcl p pointer; 5117 5118 if free (size (primary)) = null 5119 then p = get_opt_space (size (primary)); 5120 else do; 5121 p = free (size (primary)); 5122 free (size (primary)) = free (size (primary)) -> primary.next; 5123 end; 5124 5125 p -> primary.last = addr (list_head); 5126 p -> primary.next = list_head; 5127 if list_head ^= null 5128 then list_head -> primary.last = p; 5129 list_head = p; 5130 5131 return (p); 5132 5133 end create_primary; 5134 5135 hash: 5136 procedure (p_o, possibly_found) returns (fixed binary (18)) irreducible; 5137 5138 /* function to provide a hash_index for an operator to speed up searching of 5139* a primary list */ 5140 5141 dcl (o, p_o) pointer, /* operator for which hash function 5142* is calculated (input) */ 5143 possibly_found bit (1) aligned; /* "1"b if hash_mask is ON for this 5144* operator (output) */ 5145 5146 dcl mod_2_sum fixed binary (34); 5147 dcl (i, hash_mask_index) fixed binary (18); 5148 5149 o = p_o; 5150 5151 mod_2_sum = o -> operator.op_code; 5152 do i = 1 to o -> operator.number; 5153 mod_2_sum = mod_2_sum + o -> operand (i); 5154 end; 5155 5156 hash_mask_index = mod (mod_2_sum, length (hash_mask)); 5157 5158 possibly_found = substr (hash_mask, hash_mask_index + 1, 1); 5159 substr (hash_mask, hash_mask_index + 1, 1) = "1"b; 5160 5161 return (mod (mod_2_sum, dim (p_list, 1))); 5162 5163 end hash; 5164 5165 move: 5166 procedure (p_o, p_stm, p_fu, p_bt); 5167 5168 dcl (o, p_o) pointer, /* -> operator to be moved */ 5169 (stm, p_stm) pointer, /* -> stm from which o is moved */ 5170 (fu, p_fu) pointer, /* -> flow_unit from which o is moved */ 5171 (bt, p_bt) pointer; /* -> flow_unit to which o is moved (back_target) */ 5172 5173 dcl (c, i, opnd, op, outp_node_type, op_code) fixed binary (18); 5174 dcl (o_before, o_after, p, outp) pointer; 5175 5176 o = p_o; 5177 stm = p_stm; 5178 fu = p_fu; 5179 bt = p_bt; 5180 5181 if unspec (addr (quad (bt -> flow_unit.insert_statement)) -> opt_statement.source_id) 5182 ^= unspec (stm -> opt_statement.source_id) 5183 then call insert_stm_in_back_target (bt, stm); 5184 5185 call unthread (o); 5186 5187 /* insert o (op) in the back target */ 5188 5189 o_before = addr (quad (bt -> flow_unit.insert_operator)); 5190 o_after = addr (quad (o_before -> operator.next)); 5191 o -> operator.back = bt -> flow_unit.insert_operator; 5192 o -> operator.next = o_before -> operator.next; 5193 op = fixed (rel (o), 18); 5194 o_before -> operator.next = op; 5195 o_after -> operator.back = op; 5196 bt -> flow_unit.insert_operator = op; 5197 5198 /* change bit vectors that are referenced later */ 5199 5200 op_code = o -> operator.op_code; 5201 p, outp = addr (rands (o -> operator.output)); 5202 outp_node_type = outp -> node.node_type; 5203 5204 if outp_node_type = array_ref_node 5205 then if op_code ^= opt_subscript_op 5206 then p = addr (rands (p -> array_ref.parent)); 5207 5208 if p -> node.node_type = symbol_node 5209 then do; 5210 c = p -> symbol.coordinate; 5211 if ^substr (bt -> flow_unit.set -> bits, c, 1) 5212 then substr (bt -> flow_unit.set -> bits, c, 1) = "1"b; 5213 else substr (bt -> flow_unit.set_multiple -> bits, c, 1) = "1"b; 5214 substr (lp -> loop.set -> bits, c, 1) = "0"b; 5215 substr (fu -> flow_unit.set -> bits, c, 1) = "0"b; 5216 substr (bt -> flow_unit.busy_on_exit -> bits, c, 1) = 5217 substr (fu -> flow_unit.busy_on_exit -> bits, c, 1) | substr (fu -> flow_unit.used -> bits, c, 1); 5218 end; 5219 5220 do i = 1 to o -> operator.number; 5221 opnd = o -> operand (i); 5222 if opnd > 0 5223 then do; 5224 p = addr (rands (opnd)); 5225 5226 if p -> node.node_type = symbol_node & (i ^= 1 | op_code ^= opt_subscript_op) 5227 & p -> symbol.coordinate > 0 5228 then do; 5229 c = p -> symbol.coordinate; 5230 substr (bt -> flow_unit.used -> bits, c, 1) = "1"b; 5231 end; 5232 5233 else if p -> node.node_type = array_ref_node 5234 then do; 5235 p = addr (rands (p -> array_ref.parent)); 5236 c = p -> symbol.coordinate; 5237 substr (bt -> flow_unit.used -> bits, c, 1) = "1"b; 5238 end; 5239 end; 5240 end; 5241 5242 /* show that this operator is invariant and was used across loops */ 5243 5244 if outp_node_type = temporary_node | op_code = opt_subscript_op 5245 then do; 5246 outp -> temporary.invariant = "1"b; 5247 outp -> temporary.used_across_loops = "1"b; 5248 end; 5249 5250 end move; 5251 5252 insert_stm_in_back_target: 5253 procedure (bt, stm); 5254 5255 dcl bt pointer, /* -> back target where new statement is to be inserted */ 5256 stm pointer; /* -> stm from which the statement_id is copied */ 5257 5258 dcl new_statement fixed binary (18); 5259 dcl (new_stm, first_stm) pointer; 5260 5261 /* make a statement that indicates "moved" code */ 5262 5263 new_statement = insert_statement_after ((bt -> flow_unit.insert_statement)); 5264 new_stm = addr (quad (new_statement)); 5265 5266 if unspec (new_stm -> opt_statement.source_id) ^= unspec (stm -> opt_statement.source_id) 5267 then do; 5268 new_stm -> opt_statement.moved = "1"b; 5269 unspec (new_stm -> opt_statement.source_id) = unspec (stm -> opt_statement.source_id); 5270 end; 5271 else new_stm -> opt_statement.moved = stm -> opt_statement.moved; 5272 5273 if bt -> flow_unit.falls_through 5274 then bt -> flow_unit.last_statement = new_statement; 5275 else if bt -> flow_unit.first_statement = bt -> flow_unit.last_statement 5276 then do; 5277 first_stm = addr (quad (bt -> flow_unit.first_statement)); 5278 bt -> flow_unit.first_statement = new_statement; 5279 new_stm -> opt_statement.flow_unit = bt; 5280 new_stm -> opt_statement.has_operator_list = first_stm -> opt_statement.has_operator_list; 5281 first_stm -> opt_statement.has_operator_list = "0"b; 5282 new_stm -> opt_statement.operator_list = first_stm -> opt_statement.operator_list; 5283 first_stm -> opt_statement.operator_list = null; 5284 if first_stm -> opt_statement.label ^= 0 5285 then do; 5286 new_stm -> opt_statement.label = first_stm -> opt_statement.label; 5287 addr (rands (first_stm -> opt_statement.label)) -> label.statement = new_statement; 5288 first_stm -> opt_statement.label = 0; 5289 new_stm -> opt_statement.referenced_backwards = first_stm -> opt_statement.referenced_backwards; 5290 first_stm -> opt_statement.referenced_backwards = "0"b; 5291 new_stm -> opt_statement.referenced_by_assign = first_stm -> opt_statement.referenced_by_assign; 5292 first_stm -> opt_statement.referenced_by_assign = "0"b; 5293 end; 5294 end; 5295 5296 bt -> flow_unit.insert_statement = new_statement; 5297 bt -> flow_unit.insert_operator = new_statement; 5298 5299 end insert_stm_in_back_target; 5300 5301 free_operator: 5302 procedure (p_o); 5303 5304 /* frees an operator node and its associated output. The operator may NOT 5305* be reused because of potential references to it by input_to nodes, but its output may be reused. */ 5306 5307 dcl (o, p_o) pointer; /* -> operator node */ 5308 5309 dcl (t, pr) pointer; 5310 dcl temp fixed binary (18); 5311 5312 o = p_o; 5313 5314 /* if the operator still has a primary, release it. */ 5315 5316 if o -> operator.primary ^= null 5317 then do; 5318 pr = o -> operator.primary; 5319 call release_primary (pr); 5320 end; 5321 5322 /* free the output if it is a temp or the operator is opt_subscript. 5323* Note that temps & array_refs are the same size and that array_refs 5324* will not be "created" after fort_converter. */ 5325 5326 temp = o -> operator.output; 5327 if temp > 0 5328 then do; 5329 t = addr (rands (temp)); 5330 5331 if t -> node.node_type = temporary_node | o -> operator.op_code = opt_subscript_op 5332 then do; 5333 t -> temporary.next = next_free_temp; 5334 next_free_temp = temp; 5335 end; 5336 5337 else if t -> node.node_type = array_ref_node 5338 then call disconnect_temporary (t, o); 5339 end; 5340 5341 /* mark the operator so it will be obvious that it has been freed */ 5342 5343 o -> operator.output = 0; 5344 o -> operator.freed = "1"b; 5345 5346 /* unthread the operator */ 5347 5348 call unthread (o); 5349 5350 end free_operator; 5351 5352 process_moved_descendants: 5353 procedure (p_o, fu); 5354 5355 /* This routine ensures that expressions that have been moved out of a loop or commoned with expressions 5356* outside a loop stay active throughout the loop. The reference count of each such expression is 5357* incremented by one and it is hung off a loop_end_chain which appears at the end of the loop. 5358* This routine also refines the used strings. */ 5359 5360 dcl (o, p_o) pointer; /* -> operator whose descendants are used across loops 5361* or are invariant symbols */ 5362 dcl fu pointer; /* -> flow_unit being processed */ 5363 5364 dcl (i, c, opnd, op_code) fixed binary (18); 5365 dcl (outp, p) pointer; 5366 5367 o = p_o; 5368 op_code = o -> operator.op_code; 5369 5370 opnd = o -> operator.output; 5371 if opnd > 0 5372 then do; 5373 outp = addr (rands (opnd)); 5374 if outp -> node.node_type = array_ref_node & op_code ^= opt_subscript_op 5375 then if outp -> array_ref.used_across_loops 5376 then call put_in_a_loop_end (outp); 5377 end; 5378 5379 do i = 1 to o -> operator.number; 5380 opnd = o -> operand (i); 5381 if opnd > 0 5382 then do; 5383 p = addr (rands (opnd)); 5384 5385 if p -> node.node_type = temporary_node 5386 then if p -> temporary.used_across_loops 5387 then call put_in_a_loop_end (p); 5388 else ; 5389 5390 else do; 5391 if p -> node.node_type = array_ref_node 5392 then do; 5393 if p -> array_ref.used_across_loops 5394 then call put_in_a_loop_end (p); 5395 p = addr (rands (p -> array_ref.parent)); 5396 end; 5397 5398 if used_invariant_symbol 5399 & (p -> node.node_type = symbol_node & (i ^= 1 | op_code ^= opt_subscript_op)) 5400 then do; 5401 c = p -> symbol.coordinate; 5402 if c ^= 0 5403 then do; 5404 substr (lp -> loop.used -> bits, c, 1) = "1"b; 5405 substr (fu -> flow_unit.used -> bits, c, 1) = "1"b; 5406 end; 5407 end; 5408 end; 5409 end; 5410 end; 5411 5412 put_in_a_loop_end: 5413 procedure (pt); 5414 5415 dcl (p, pt, lp_evaluated, lp_to_put, q) pointer; 5416 dcl max_fu_pos fixed binary (18); 5417 5418 p = pt; 5419 5420 /* figure out in which containing loop's end chain this temp or array_ref should go. 5421* This is complicated by the possibility of extended range loops. We therefore find 5422* the loop whose last statement is furthest down in the program. */ 5423 5424 lp_evaluated = 5425 addr (quad (p -> temporary.output_by)) -> operator.primary -> primary.flow_unit -> flow_unit.loop; 5426 max_fu_pos = 0; 5427 5428 do q = lp repeat q -> loop.father 5429 while (^substr (lp_evaluated -> loop.ancestors_and_me -> lbits, q -> loop.number, 1)); 5430 if q -> loop.last_unit -> flow_unit.position > max_fu_pos 5431 then do; 5432 max_fu_pos = q -> loop.last_unit -> flow_unit.position; 5433 lp_to_put = q; 5434 end; 5435 end; 5436 5437 /* unless this operand is in a loop end chain after this one, stich it in */ 5438 5439 if max_fu_pos > p -> temporary.loop_end_fu_pos 5440 then call put_in_loop_end (p, lp_to_put); 5441 5442 p -> temporary.used_across_loops = "0"b; 5443 5444 end put_in_a_loop_end; 5445 5446 end process_moved_descendants; 5447 5448 constant_expression: 5449 procedure (p_o) returns (bit (1) aligned); 5450 5451 /* this routine attempts to fold constant expressions */ 5452 5453 dcl (o, p_o) pointer; /* ptr to operator with possible constant operands */ 5454 5455 dcl ( 5456 p (2), 5457 inp, 5458 outp, 5459 q, 5460 start_inp 5461 ) pointer; 5462 dcl (opnd, i, op_code) fixed binary (18); 5463 5464 dcl data_type (2) fixed bin (4); 5465 dcl max_data_type fixed bin (4); 5466 dcl result bit (72) aligned; 5467 dcl source (2) bit (72); 5468 5469 dcl 01 source_as_int (2) based (addr (source)), 5470 02 int_source fixed bin (18), 5471 02 pad bit (36); 5472 5473 dcl error_condition char (16), 5474 literal_expression char (33 + 4 + 33) varying, 5475 literal_operand char (33) varying, 5476 literal_operator (2:13) char (4) varying static options (constant) 5477 init ("+", "-", "*", "/", "**", "-", ".lt.", ".le.", ".eq.", ".ne.", ".ge.", ".gt."); 5478 5479 dcl error condition, 5480 fixedoverflow condition, 5481 overflow condition, 5482 size condition, 5483 underflow condition, 5484 zerodivide condition; 5485 5486 /* initialize */ 5487 5488 o = p_o; 5489 5490 /* make sure operands fit in our arrays */ 5491 5492 if o -> operator.number > hbound (p, 1) 5493 then return ("0"b); 5494 5495 outp = addr (rands (o -> operator.output)); 5496 5497 /* see if all operands are constant and collect their values */ 5498 5499 do i = 1 to o -> operator.number; 5500 opnd = o -> operand (i); 5501 if opnd > 0 5502 then do; 5503 p (i) = addr (rands (opnd)); 5504 5505 if p (i) -> node.node_type = constant_node 5506 then do; 5507 data_type (i) = p (i) -> constant.data_type; 5508 source (i) = p (i) -> constant.value; 5509 end; 5510 5511 else return ("0"b); 5512 end; 5513 end; 5514 5515 /* Catch arithmetic errors in the folding. */ 5516 5517 on error goto error_condition_detected; 5518 on fixedoverflow goto fixedoverflow_condition_detected; 5519 on overflow goto overflow_condition_detected; 5520 on size goto size_condition_detected; 5521 on underflow goto underflow_condition_detected; 5522 on zerodivide goto zerodivide_condition_detected; 5523 5524 op_code = o -> operator.op_code; 5525 5526 /* dispatch on op_code */ 5527 5528 go to case (op_code); 5529 5530 case (1): /* assign - handled by constant_assign */ 5531 case (14): /* or */ 5532 case (15): /* and */ 5533 case (16): /* not */ 5534 case (17): /* jump */ 5535 case (18): /* jump_logical */ 5536 case (19): /* jump_arithmetic */ 5537 case (20): /* jump_computed */ 5538 case (21): /* jump_assigned */ 5539 case (22): /* assign_label */ 5540 case (23): /* read */ 5541 case (24): /* write */ 5542 case (25): /* format */ 5543 case (26): /* end_label */ 5544 case (27): /* error_label */ 5545 case (28): /* xmit_scalar */ 5546 case (29): /* xmit_array */ 5547 case (30): /* xmit_vector */ 5548 case (31): /* endfile */ 5549 case (32): /* rewind */ 5550 case (33): /* backspace */ 5551 case (34): /* margin */ 5552 case (35): /* openfile */ 5553 case (36): /* closefile */ 5554 case (37): /* record_number */ 5555 case (38): /* string */ 5556 case (39): /* string_length */ 5557 case (40): /* terminate */ 5558 case (41): /* return */ 5559 case (42): /* pause */ 5560 case (43): /* stop */ 5561 case (44): /* item */ 5562 case (45): /* exit */ 5563 case (46): /* eol */ 5564 case (47): /* do */ 5565 case (48): /* builtin */ 5566 case (49): /* sf */ 5567 case (50): /* sf_def */ 5568 case (51): /* subscript */ 5569 case (52): /* func_ref */ 5570 case (53): /* block_data */ 5571 case (54): /* increment_polish */ 5572 case (55): /* main */ 5573 case (56): /* func */ 5574 case (57): /* subr */ 5575 case (58): /* stat */ 5576 case (59): /* label */ 5577 case (60): /* call */ 5578 case (61): /* chain */ 5579 case (62): /* endunit */ 5580 case (63): /* non_executable */ 5581 case (64): /* no */ 5582 case (65): /* indirect_scan */ 5583 case (66): /* opt_subscript */ 5584 case (67): /* left_shift */ 5585 case (68): /* right_shift */ 5586 case (69): /* store_zero */ 5587 case (70): /* storage_add */ 5588 case (71): /* storage_sub */ 5589 case (72): /* neg_storage_add */ 5590 case (73): /* storage_add_one */ 5591 case (74): /* namelist */ 5592 case (75): /* open */ 5593 case (76): /* close */ 5594 case (77): /* iostat */ 5595 case (82): /* read_scalar */ 5596 case (83): /* read_array */ 5597 case (84): /* read_vector */ 5598 case (85): /* write_scalar */ 5599 case (86): /* write_array */ 5600 case (87): /* write_vector */ 5601 case (88): /* jump_true */ 5602 case (89): /* jump_false */ 5603 case (91): /* loop_end */ 5604 case (92): /* read_namelist */ 5605 case (93): /* write_namelist */ 5606 case (94): /* decode_string */ 5607 case (95): /* encode_string */ 5608 case (96): /* cat */ 5609 case (97): /* substr */ 5610 case (98): /* load_xreg */ 5611 case (99): /* load_preg */ 5612 case (100): /* block_if */ 5613 case (101): /* else_if */ 5614 case (102): /* else */ 5615 case (103): /* equiv */ 5616 case (104): /* not_equiv */ 5617 case (105): /* read_internal_file */ 5618 case (106): /* write_internal_file */ 5619 case (107): /* inquire */ 5620 case (108): /* process_param_list */ 5621 return ("0"b); 5622 5623 5624 case (2): /* add */ 5625 case (3): /* sub */ 5626 case (4): /* mult */ 5627 case (5): /* div */ 5628 case (6): /* exponentiation */ 5629 max_data_type = max (data_type (1), data_type (2)); 5630 if data_type (1) ^= max_data_type 5631 then source (1) = conv_round (max_data_type, data_type (1)) (source (1), 0); 5632 else if data_type (2) ^= max_data_type 5633 then source (2) = conv_round (max_data_type, data_type (2)) (source (2), 0); 5634 result = binop_round (max_data_type, max_data_type) (op_code - 1, source (1), source (2), 0); 5635 goto join; 5636 5637 case (7): /* negate */ 5638 result = negate_round (data_type (1)) (op_code - 1, source (1), ""b, 0); 5639 goto join; 5640 5641 case (8): /* less */ 5642 case (9): /* less_or_equal */ 5643 case (10): /* equal */ 5644 case (11): /* not_equal */ 5645 case (12): /* greater_or_equal */ 5646 case (13): /* greater */ 5647 result = comp_parm (data_type (1), data_type (2)) ((op_code), source (1), source (2), 0); 5648 goto join; 5649 5650 case (78): /* convert_to_int */ 5651 case (79): /* convert_to_real */ 5652 case (80): /* convert_to_dp */ 5653 case (81): /* convert_to_cmpx */ 5654 result = conv_round (op_code - 77, data_type (1)) (source (1), 0); 5655 goto join; 5656 5657 case (90): /* sub_index */ 5658 /* ** If the sub_index is used as the variable offset of an 5659* opt_subscript operator, then combine the variable offset which 5660* happens to be constant and the real constant offset. If the 5661* sub_index is used for a length (for a substring reference or 5662* concatenation operator) simply replace the output of the 5663* sub_index with the constant. 5664* ** */ 5665 opnd = create_integer_constant (int_source (1)); 5666 5667 start_inp = addr (polish (outp -> temporary.start_input_to)); 5668 5669 do inp = start_inp repeat inp -> input_to.next while (inp ^= null); 5670 q = inp -> input_to.operator; 5671 if inp -> input_to.which > 0 5672 then do; 5673 if q -> operator.op_code = opt_subscript_op & inp -> input_to.which = 3 5674 then do; 5675 unspec (i) = addr (rands (q -> operator.operand (2))) -> constant.value; 5676 (size): 5677 q -> operator.operand (2) = create_integer_constant (i + int_source (1)); 5678 q -> operator.operand (3) = 0; 5679 end; 5680 else q -> operand (inp -> input_to.which) = opnd; 5681 end; 5682 else q -> lchain.value = o -> operand (1); 5683 end; 5684 5685 go to done; 5686 5687 join: 5688 opnd = create_constant ((outp -> temporary.data_type), result); 5689 5690 start_inp = addr (polish (outp -> temporary.start_input_to)); 5691 5692 call replace_inputs (start_inp, opnd); 5693 5694 done: /* free the input chain */ 5695 addr (polish (outp -> temporary.end_input_to)) -> input_to.next = freei; 5696 freei = start_inp; 5697 5698 /* free the operator */ 5699 5700 call free_operator (o); 5701 5702 return ("1"b); 5703 5704 5705 /* An arithmetic error occurred during folding. Set 'literal_expression' */ 5706 /* to the literal form of the constant expression that was being folded, */ 5707 /* then issue an error message indicating the error and showing the value */ 5708 /* of 'literal_expression'. Return 'false' to the caller to indicate that */ 5709 /* the expression was not folded. */ 5710 5711 arithmetic_error_detected: 5712 if o -> operator.number = 2 5713 then do; /* Synthesize binary expression. */ 5714 literal_operand = literal_value (p (1) -> constant.data_type, p (1) -> constant.value); 5715 if substr (literal_operand, 1, 1) = "-" 5716 then do; 5717 literal_expression = "("; 5718 literal_expression = literal_expression || literal_operand; 5719 literal_expression = literal_expression || ")"; 5720 end; 5721 else literal_expression = literal_operand; 5722 if op_code >= lbound (literal_operator, 1) & op_code <= hbound (literal_operator, 1) 5723 then literal_expression = literal_expression || literal_operator (op_code); 5724 else literal_expression = literal_expression || "?"; 5725 literal_operand = literal_value (p (2) -> constant.data_type, p (2) -> constant.value); 5726 if substr (literal_operand, 1, 1) = "-" 5727 then do; 5728 literal_expression = literal_expression || "("; 5729 literal_expression = literal_expression || literal_operand; 5730 literal_expression = literal_expression || ")"; 5731 end; 5732 else literal_expression = literal_expression || literal_operand; 5733 end; 5734 else if op_code = negate_op 5735 then do; 5736 literal_expression = "-"; 5737 literal_operand = literal_value (p (1) -> constant.data_type, p (1) -> constant.value); 5738 if substr (literal_operand, 1, 1) = "-" 5739 then do; 5740 literal_expression = literal_expression || "("; 5741 literal_expression = literal_expression || literal_operand; 5742 literal_expression = literal_expression || ")"; 5743 end; 5744 else literal_expression = literal_expression || literal_operand; 5745 end; 5746 else if op_code = convert_to_int_op 5747 then do; 5748 literal_expression = "int("; 5749 literal_expression = 5750 literal_expression || literal_value (p (1) -> constant.data_type, p (1) -> constant.value); 5751 literal_expression = literal_expression || ")"; 5752 end; 5753 else if op_code = convert_to_real_op 5754 then do; 5755 literal_expression = "real("; 5756 literal_expression = 5757 literal_expression || literal_value (p (1) -> constant.data_type, p (1) -> constant.value); 5758 literal_expression = literal_expression || ")"; 5759 end; 5760 else if op_code = convert_to_dp_op 5761 then do; 5762 literal_expression = "dble("; 5763 literal_expression = 5764 literal_expression || literal_value (p (1) -> constant.data_type, p (1) -> constant.value); 5765 literal_expression = literal_expression || ")"; 5766 end; 5767 else if op_code = convert_to_cmpx_op 5768 then do; 5769 literal_expression = "cmplx("; 5770 literal_expression = 5771 literal_expression || literal_value (p (1) -> constant.data_type, p (1) -> constant.value); 5772 literal_expression = literal_expression || ")"; 5773 end; 5774 else if op_code = sub_index_op 5775 then do; 5776 literal_expression = literal_value ((int_mode), unspec (i)); 5777 literal_expression = literal_expression || "+"; 5778 literal_expression = literal_value ((int_mode), unspec (int_source (1))); 5779 end; 5780 else literal_expression = "?"; 5781 call print_message (174, error_condition, "constant expression: " || literal_expression); 5782 return ("0"b); 5783 5784 error_condition_detected: 5785 error_condition = "error"; 5786 goto arithmetic_error_detected; 5787 5788 fixedoverflow_condition_detected: 5789 error_condition = "fixedoverflow"; 5790 goto arithmetic_error_detected; 5791 5792 overflow_condition_detected: 5793 error_condition = "overflow"; 5794 goto arithmetic_error_detected; 5795 5796 size_condition_detected: 5797 error_condition = "size"; 5798 goto arithmetic_error_detected; 5799 5800 underflow_condition_detected: 5801 error_condition = "underflow"; 5802 goto arithmetic_error_detected; 5803 5804 zerodivide_condition_detected: 5805 error_condition = "zerodivide"; 5806 goto arithmetic_error_detected; 5807 5808 literal_value: 5809 proc (data_type, bit_value) recursive returns (char (35) varying); 5810 5811 /* Function: to return the literal value of a FORTRAN numeric datum. */ 5812 5813 /* Arguments: */ 5814 /* */ 5815 /* data_type (Input) */ 5816 /* is the type of the datum: 'int_mode', 'real_mode', 'dp_mode' or */ 5817 /* 'cmpx_mode'. */ 5818 /* */ 5819 /* bit_value (Input) */ 5820 /* is the bit string representing the value of the datum. */ 5821 5822 /* Notes: */ 5823 /* */ 5824 /* (1) The result is set to "?" if an invalid data type is specified. */ 5825 5826 dcl data_type fixed bin (4) unsigned unaligned, 5827 bit_value bit (72) aligned; 5828 5829 dcl assign_ entry (ptr, fixed bin, fixed bin (35), ptr, fixed bin, fixed bin (35)); 5830 5831 dcl imag builtin, 5832 real builtin; 5833 5834 dcl Packed fixed bin (1) static options (constant) init (1), 5835 Unpacked fixed bin (1) static options (constant) init (0); 5836 5837 dcl descriptor_type fixed bin, 5838 dp_picture pic "-9v.999999999999999999es999", 5839 idx_of_e fixed bin, 5840 int_value fixed bin (35), 5841 real_picture pic "-9v.99999999es999", 5842 result char (35) varying; 6 1 /* BEGIN INCLUDE FILE ... std_descriptor_types.incl.pl1 */ 6 2 6 3 6 4 /****^ HISTORY COMMENTS: 6 5* 1) change(86-09-05,JMAthane), approve(86-09-05,MCR7525), 6 6* audit(86-09-11,Martinson), install(86-11-12,MR12.0-1208): 6 7* Added pascal_string_type_dtype descriptor type. Its number is 87. 6 8* Objects of this type are PASCAL string types. 6 9* 2) change(88-09-20,WAAnderson), approve(88-09-20,MCR7952), 6 10* audit(88-09-30,JRGray), install(88-10-24,MR12.2-1184): 6 11* Added the new C types. 6 12* END HISTORY COMMENTS */ 6 13 6 14 /* This include file defines mnemonic names for the Multics 6 15* standard descriptor types, using both pl1 and cobol terminology. 6 16* PG 780613 6 17* JRD 790530 6 18* JRD 791016 6 19* MBW 810731 6 20* TGO 830614 Add hex types. 6 21* Modified June 83 JMAthane to add PASCAL data types 6 22* TGO 840120 Add float dec extended and generic, float binary generic 6 23**/ 6 24 6 25 dcl (real_fix_bin_1_dtype init (1), 6 26 real_fix_bin_2_dtype init (2), 6 27 real_flt_bin_1_dtype init (3), 6 28 real_flt_bin_2_dtype init (4), 6 29 cplx_fix_bin_1_dtype init (5), 6 30 cplx_fix_bin_2_dtype init (6), 6 31 cplx_flt_bin_1_dtype init (7), 6 32 cplx_flt_bin_2_dtype init (8), 6 33 real_fix_dec_9bit_ls_dtype init (9), 6 34 real_flt_dec_9bit_dtype init (10), 6 35 cplx_fix_dec_9bit_ls_dtype init (11), 6 36 cplx_flt_dec_9bit_dtype init (12), 6 37 pointer_dtype init (13), 6 38 offset_dtype init (14), 6 39 label_dtype init (15), 6 40 entry_dtype init (16), 6 41 structure_dtype init (17), 6 42 area_dtype init (18), 6 43 bit_dtype init (19), 6 44 varying_bit_dtype init (20), 6 45 char_dtype init (21), 6 46 varying_char_dtype init (22), 6 47 file_dtype init (23), 6 48 real_fix_dec_9bit_ls_overp_dtype init (29), 6 49 real_fix_dec_9bit_ts_overp_dtype init (30), 6 50 real_fix_bin_1_uns_dtype init (33), 6 51 real_fix_bin_2_uns_dtype init (34), 6 52 real_fix_dec_9bit_uns_dtype init (35), 6 53 real_fix_dec_9bit_ts_dtype init (36), 6 54 real_fix_dec_4bit_uns_dtype init (38), /* digit-aligned */ 6 55 real_fix_dec_4bit_ts_dtype init (39), /* byte-aligned */ 6 56 real_fix_dec_4bit_bytealigned_uns_dtype init (40), /* COBOL */ 6 57 real_fix_dec_4bit_ls_dtype init (41), /* digit-aligned */ 6 58 real_flt_dec_4bit_dtype init (42), /* digit-aligned */ 6 59 real_fix_dec_4bit_bytealigned_ls_dtype init (43), 6 60 real_flt_dec_4bit_bytealigned_dtype init (44), 6 61 cplx_fix_dec_4bit_bytealigned_ls_dtype init (45), 6 62 cplx_flt_dec_4bit_bytealigned_dtype init (46), 6 63 real_flt_hex_1_dtype init (47), 6 64 real_flt_hex_2_dtype init (48), 6 65 cplx_flt_hex_1_dtype init (49), 6 66 cplx_flt_hex_2_dtype init (50), 6 67 c_typeref_dtype init (54), 6 68 c_enum_dtype init (55), 6 69 c_enum_const_dtype init (56), 6 70 c_union_dtype init (57), 6 71 algol68_straight_dtype init (59), 6 72 algol68_format_dtype init (60), 6 73 algol68_array_descriptor_dtype init (61), 6 74 algol68_union_dtype init (62), 6 75 6 76 cobol_comp_6_dtype init (1), 6 77 cobol_comp_7_dtype init (1), 6 78 cobol_display_ls_dtype init (9), 6 79 cobol_structure_dtype init (17), 6 80 cobol_char_string_dtype init (21), 6 81 cobol_display_ls_overp_dtype init (29), 6 82 cobol_display_ts_overp_dtype init (30), 6 83 cobol_display_uns_dtype init (35), 6 84 cobol_display_ts_dtype init (36), 6 85 cobol_comp_8_uns_dtype init (38), /* digit aligned */ 6 86 cobol_comp_5_ts_dtype init (39), /* byte aligned */ 6 87 cobol_comp_5_uns_dtype init (40), 6 88 cobol_comp_8_ls_dtype init (41), /* digit aligned */ 6 89 real_flt_dec_extended_dtype init (81), /* 9-bit exponent */ 6 90 cplx_flt_dec_extended_dtype init (82), /* 9-bit exponent */ 6 91 real_flt_dec_generic_dtype init (83), /* generic float decimal */ 6 92 cplx_flt_dec_generic_dtype init (84), 6 93 real_flt_bin_generic_dtype init (85), /* generic float binary */ 6 94 cplx_flt_bin_generic_dtype init (86)) fixed bin internal static options (constant); 6 95 6 96 dcl (ft_integer_dtype init (1), 6 97 ft_real_dtype init (3), 6 98 ft_double_dtype init (4), 6 99 ft_complex_dtype init (7), 6 100 ft_complex_double_dtype init (8), 6 101 ft_external_dtype init (16), 6 102 ft_logical_dtype init (19), 6 103 ft_char_dtype init (21), 6 104 ft_hex_real_dtype init (47), 6 105 ft_hex_double_dtype init (48), 6 106 ft_hex_complex_dtype init (49), 6 107 ft_hex_complex_double_dtype init (50) 6 108 ) fixed bin internal static options (constant); 6 109 6 110 dcl (algol68_short_int_dtype init (1), 6 111 algol68_int_dtype init (1), 6 112 algol68_long_int_dtype init (2), 6 113 algol68_real_dtype init (3), 6 114 algol68_long_real_dtype init (4), 6 115 algol68_compl_dtype init (7), 6 116 algol68_long_compl_dtype init (8), 6 117 algol68_bits_dtype init (19), 6 118 algol68_bool_dtype init (19), 6 119 algol68_char_dtype init (21), 6 120 algol68_byte_dtype init (21), 6 121 algol68_struct_struct_char_dtype init (22), 6 122 algol68_struct_struct_bool_dtype init (20) 6 123 ) fixed bin internal static options (constant); 6 124 6 125 dcl (label_constant_runtime_dtype init (24), 6 126 int_entry_runtime_dtype init (25), 6 127 ext_entry_runtime_dtype init (26), 6 128 ext_procedure_runtime_dtype init (27), 6 129 picture_runtime_dtype init (63) 6 130 ) fixed bin internal static options (constant); 6 131 6 132 dcl (pascal_integer_dtype init (1), 6 133 pascal_real_dtype init (4), 6 134 pascal_label_dtype init (24), 6 135 pascal_internal_procedure_dtype init (25), 6 136 pascal_exportable_procedure_dtype init (26), 6 137 pascal_imported_procedure_dtype init (27), 6 138 pascal_typed_pointer_type_dtype init (64), 6 139 pascal_char_dtype init (65), 6 140 pascal_boolean_dtype init (66), 6 141 pascal_record_file_type_dtype init (67), 6 142 pascal_record_type_dtype init (68), 6 143 pascal_set_dtype init (69), 6 144 pascal_enumerated_type_dtype init (70), 6 145 pascal_enumerated_type_element_dtype init (71), 6 146 pascal_enumerated_type_instance_dtype init (72), 6 147 pascal_user_defined_type_dtype init (73), 6 148 pascal_user_defined_type_instance_dtype init (74), 6 149 pascal_text_file_dtype init (75), 6 150 pascal_procedure_type_dtype init (76), 6 151 pascal_variable_formal_parameter_dtype init (77), 6 152 pascal_value_formal_parameter_dtype init (78), 6 153 pascal_entry_formal_parameter_dtype init (79), 6 154 pascal_parameter_procedure_dtype init (80), 6 155 pascal_string_type_dtype init (87)) fixed bin int static options (constant); 6 156 6 157 6 158 /* END INCLUDE FILE ... std_descriptor_types.incl.pl1 */ 5843 5844 5845 5846 if data_type = cmpx_mode 5847 then do; 5848 result = "("; 5849 result = result || literal_value ((real_mode), substr (bit_value, 1, 36)); 5850 result = result || ","; 5851 result = result || literal_value ((real_mode), substr (bit_value, 37, 36)); 5852 result = result || ")"; 5853 end; 5854 else if data_type = dp_mode 5855 then do; 5856 if cs -> subprogram.hfp 5857 then descriptor_type = real_flt_hex_2_dtype; 5858 else descriptor_type = real_flt_bin_2_dtype; 5859 call assign_ (addr (dp_picture), 2 * char_dtype + Packed, length (dp_picture), addr (bit_value), 5860 2 * descriptor_type + Unpacked, 63); 5861 idx_of_e = index (dp_picture, "e"); 5862 result = rtrim (rtrim (ltrim (substr (dp_picture, 1, idx_of_e - 1)), "0"), "."); 5863 result = result || "D"; 5864 result = result || substr (dp_picture, idx_of_e + 1, 1); 5865 result = result || ltrim (substr (dp_picture, idx_of_e + 2, 2), "0"); 5866 result = result || substr (dp_picture, idx_of_e + 3, 1); 5867 end; 5868 else if data_type = int_mode 5869 then do; 5870 unspec (int_value) = substr (bit_value, 1, 36); 5871 result = ltrim (char (int_value)); 5872 end; 5873 else if data_type = real_mode 5874 then do; 5875 if cs -> subprogram.hfp 5876 then descriptor_type = real_flt_hex_1_dtype; 5877 else descriptor_type = real_flt_bin_1_dtype; 5878 call assign_ (addr (real_picture), 2 * char_dtype + Packed, length (real_picture), addr (bit_value), 5879 2 * descriptor_type + Unpacked, 27); 5880 idx_of_e = index (real_picture, "e"); 5881 result = rtrim (rtrim (ltrim (substr (real_picture, 1, idx_of_e - 1)), "0"), "."); 5882 result = result || "E"; 5883 result = result || substr (real_picture, idx_of_e + 1, 1); 5884 result = result || ltrim (substr (real_picture, idx_of_e + 2, 2), "0"); 5885 result = result || substr (real_picture, idx_of_e + 3, 1); 5886 end; 5887 else result = "?"; 5888 return (result); 5889 end literal_value; 5890 5891 end constant_expression; 5892 5893 constant_assign: 5894 procedure (p_o) returns (bit (1) aligned); 5895 5896 /* This routine does special processing for assigments of constants to 5897* symbols. The constant right hand side must be converted to the data type 5898* of the left hand side so that subsequent uses of the constant in place of 5899* the symbol come out with the right value and the right data type. If the 5900* assign operator passed in does assign a constant to a symbol, "1"b is 5901* returned. As there are no typeless constants, there is no code to support 5902* data type 7. */ 5903 5904 dcl p_o pointer; /* Pointer to assign operator */ 5905 5906 dcl (o, inp, outp) pointer; 5907 dcl (in_dt, out_dt) fixed binary (4); 5908 5909 dcl target bit (72) aligned; /* Value of constant */ 5910 5911 dcl char4_target character (4); 5912 dcl char8_target character (8); 5913 5914 5915 return ("0"b); /* Temporarily disable 'constant_assign' to bypass bug 441. */ 5916 ignore_this_procedure: 5917 o = p_o; 5918 inp = addr (rands (o -> operator.operand (1))); 5919 outp = addr (rands (o -> operator.output)); 5920 5921 in_dt = inp -> node.data_type; 5922 out_dt = outp -> node.data_type; 5923 5924 /* Dispatch on data types of LHS and RHS */ 5925 5926 go to conv (6 * (out_dt - 1) + in_dt); 5927 5928 conv (2): /* int = real */ 5929 conv (3): /* int = dp */ 5930 conv (4): /* int = cmpx */ 5931 conv (7): /* real = int */ 5932 conv (9): /* real = dp */ 5933 conv (10): /* real = cmpx */ 5934 conv (13): /* dp = int */ 5935 conv (14): /* dp = real */ 5936 conv (16): /* dp = cmpx */ 5937 conv (19): /* cmpx = int */ 5938 conv (20): /* cmpx = real */ 5939 conv (21): /* cmpx = dp */ 5940 target = conv_round (out_dt, in_dt) ((inp -> constant.value), 0); 5941 goto change_constant; 5942 5943 conv (6): /* int = char */ 5944 conv (12): /* real = char */ 5945 conv (30): /* logical = char */ 5946 char4_target = inp -> char_constant.value; 5947 target = unspec (char4_target); 5948 goto change_constant; 5949 5950 conv (18): /* dp = char */ 5951 conv (24): /* cmpx = char */ 5952 char8_target = inp -> char_constant.value; 5953 target = unspec (char8_target); 5954 goto change_constant; 5955 5956 conv (36): /* char = char */ 5957 if outp -> node.node_type = symbol_node 5958 then if outp -> symbol.v_length = 0 5959 then do; 5960 o -> operator.operand (1) = 5961 create_char_constant (char (inp -> char_constant.value, outp -> symbol.char_size + 1)); 5962 return ("1"b); 5963 end; 5964 return ("0"b); 5965 5966 5967 change_constant: 5968 o -> operator.operand (1) = create_constant (out_dt, target); 5969 5970 5971 conv (1): /* int = int */ 5972 conv (8): /* real = real */ 5973 conv (15): /* dp = dp */ 5974 conv (22): /* cmpx = cmpx */ 5975 conv (29): /* logical = logical */ 5976 return (outp -> node.node_type = symbol_node); 5977 5978 5979 conv (5): /* int = logical */ 5980 conv (11): /* real = logical */ 5981 conv (17): /* dp = logical */ 5982 conv (23): /* cmpx = logical */ 5983 conv (25): /* logical = int */ 5984 conv (26): /* logical = real */ 5985 conv (27): /* logical = dp */ 5986 conv (28): /* logical = cmpx */ 5987 conv (31): /* char = int */ 5988 conv (32): /* char = real */ 5989 conv (33): /* char = dp */ 5990 conv (34): /* char = cmpx */ 5991 conv (35): /* char = logical */ 5992 return ("0"b); 5993 5994 end constant_assign; 5995 5996 reduce_strength: 5997 procedure (p_lp); 5998 5999 /* routine to do strength reduction */ 6000 6001 dcl (lp, p_lp) pointer; /* loop in which strength reduction is to be done */ 6002 6003 dcl (srp, incrp, src, incrc, cur_frame, cur_o, inp, o, bt, assp, outp, deltap, stm, fu, srvp, p, last, varp, new_incrp, 6004 q) pointer; 6005 dcl (i, induction_var, coord, op_code, number, new_increment, delta, which, insert_delta, variable, assignment, j, 6006 insert_new) fixed binary (18); 6007 dcl (inc_found, inc_found_before) bit (1) aligned; 6008 dcl induction_busy_on_exit bit (1) aligned; /* "1"b -- induction var is busy_on_exit from lp */ 6009 dcl have_test_replacement_candidate bit (1) aligned; 6010 dcl found_new_induction_variable bit (1) aligned; 6011 dcl induction_boe_from_bt bit (1) aligned; 6012 dcl update_insert_operator bit (1) aligned; 6013 6014 dcl 1 sr_frame based aligned, /* stack frame used in strength reduction */ 6015 2 prev pointer unaligned, 6016 2 next pointer unaligned, 6017 2 data structure aligned, 6018 3 operator pointer unaligned, /* operator being reduced */ 6019 3 inp pointer unaligned, /* input to be processed */ 6020 3 delta fixed binary (18), /* increment to associate with this operator */ 6021 3 init fixed binary (18), /* last operator used in initializing expression */ 6022 3 variable fixed binary (18), /* new variable (if nonzero) made for this operator */ 6023 3 ninst fixed binary (18), /* number of tuples to generate this result */ 6024 3 all_constant bit (1) aligned, /* ON if all opnds except orig ind var are constant */ 6025 3 which fixed binary (18), /* which operand was previous operator */ 6026 3 sign bit (1) aligned, /* sign of the increment */ 6027 3 sign_unknown bit (1) aligned; /* sign of increment unknown */ 6028 6029 lp = p_lp; 6030 bt = lp -> loop.back_target; 6031 6032 inc_found_before, have_test_replacement_candidate = "0"b; 6033 6034 retry: 6035 found_new_induction_variable = "0"b; 6036 6037 /* See if we can find additional induction variables updated by stmts 6038* of the form i = j. */ 6039 6040 if full_strength_reduction 6041 then call find_new_induction_vars_on_ass_chain (lp); 6042 6043 /* loop through the candidates for strength reduction */ 6044 6045 do src = sr_chain repeat src -> sr_cand.next while (src ^= null); 6046 srp = src -> sr_cand.operator; 6047 which = src -> sr_cand.which; 6048 if which = 0 6049 then go to step; 6050 if srp -> operator.freed 6051 then go to step; 6052 stm = src -> sr_cand.statement; 6053 fu = stm -> opt_statement.flow_unit; 6054 6055 induction_var = srp -> operand (which); 6056 6057 /* see if this candidate involves a legitimate induction variable */ 6058 6059 inc_found = "0"b; 6060 incrc = incr_chain; 6061 6062 do while (incrc ^= null & ^inc_found); 6063 incrp = incrc -> incr.value; 6064 if induction_var = incrp -> operator.output 6065 then inc_found = "1"b; 6066 else incrc = incrc -> incr.next; 6067 end; 6068 6069 if inc_found 6070 then do; 6071 6072 /* the following code is the main logic of strength reduction. It will 6073* make one or more new induction variables to replace uses of this expression 6074* or expressions containing this expression that also involve loop invariants */ 6075 6076 /* remember the busyness_on_exit of this induction variable */ 6077 6078 induction_busy_on_exit = 6079 substr (lp -> loop.busy_on_exit -> bits, addr (rands (induction_var)) -> symbol.coordinate, 1); 6080 6081 induction_boe_from_bt = 6082 substr (bt -> flow_unit.busy_on_exit -> bits, addr (rands (induction_var)) -> symbol.coordinate, 6083 1); 6084 6085 if ^inc_found_before 6086 then do; 6087 6088 /* initialize for inserting delta */ 6089 6090 if ^bt -> flow_unit.falls_through 6091 then if bt -> flow_unit.first_statement = bt -> flow_unit.last_statement 6092 then call insert_stm_in_back_target (bt, stm); 6093 insert_delta = bt -> flow_unit.insert_operator; 6094 bt -> flow_unit.insert_operator = insert_operator_after (no_op, 0, insert_delta); 6095 inc_found_before = "1"b; 6096 end; 6097 6098 /* create an initial frame to represent the induction variable */ 6099 6100 if init_frame ^= null 6101 then cur_frame = init_frame; 6102 else init_frame, cur_frame = create_sr_frame (null); 6103 6104 cur_frame -> sr_frame.all_constant = "1"b; 6105 cur_frame -> sr_frame.ninst = 0; 6106 6107 cur_frame -> sr_frame.sign = "0"b; 6108 cur_frame -> sr_frame.sign_unknown = "0"b; 6109 6110 if incrp -> operator.op_code = assign_op 6111 then cur_frame -> sr_frame.delta = 0; 6112 6113 else if incrp -> operator.op_code = storage_add_one_op 6114 then cur_frame -> sr_frame.delta = one; 6115 6116 else do; 6117 if incrp -> operator.op_code = neg_storage_add_op 6118 then cur_frame -> sr_frame.sign = "1"b; 6119 cur_frame -> sr_frame.delta = incrp -> operand (1); 6120 end; 6121 6122 /* build a frame for our candidate */ 6123 6124 call reduce (srp, which); 6125 6126 6127 /* this set of loops processes all expressions containing our candidate */ 6128 6129 do while (cur_frame ^= init_frame); 6130 6131 do while (cur_frame -> sr_frame.inp ^= null); 6132 inp = cur_frame -> sr_frame.inp; 6133 cur_frame -> sr_frame.inp = inp -> input_to.next; 6134 6135 o = inp -> input_to.operator; 6136 which = inp -> input_to.which; 6137 6138 if which > 0 /* must be an operator */ 6139 then if ^o -> operator.freed /* must not have been freed */ 6140 then if is_reducible (o, which) 6141 then call reduce (o, which); 6142 6143 else do; 6144 if cur_frame -> sr_frame.variable = 0 6145 then do; 6146 6147 /* we have a non-reducible operator, so, unless an equivalent already 6148* exists, we must create and initialize a new induction variable to 6149* substitute for the reducible code that has been processed. */ 6150 6151 variable = search_for_equivalent (/* cur_frame, incrc */); 6152 6153 outp = addr (rands (cur_frame -> sr_frame.operator -> operator.output)); 6154 inp = addr (polish (outp -> temporary.start_input_to)); 6155 6156 if variable = 0 6157 then do; 6158 srvp = create_var (lp); 6159 6160 variable = srvp -> sr_var.variable; 6161 6162 outp -> temporary.start_input_to, outp -> temporary.end_input_to = 6163 0; 6164 6165 if induction_boe_from_bt 6166 then do; 6167 outp -> temporary.ref_count = 1; 6168 6169 /* build initializing code */ 6170 6171 update_insert_operator = 6172 cur_frame -> sr_frame.init 6173 = bt -> flow_unit.insert_operator; 6174 6175 assignment = 6176 insert_operator_after (assign_op, 1, 6177 (cur_frame -> sr_frame.init)); 6178 6179 if update_insert_operator 6180 then bt -> flow_unit.insert_operator = assignment; 6181 6182 assp = addr (quad (assignment)); 6183 assp -> operator.output = variable; 6184 assp -> operand (1) = 6185 cur_frame -> sr_frame.operator -> operator.output; 6186 6187 call chain_input (outp, assp, 1); 6188 end; 6189 6190 else outp -> temporary.ref_count = 0; 6191 6192 /* Note: following code sets usage and busy_on_exit bits needed by 6193* this pass of the optimizer. Recompute_usage will do a better 6194* job for later. */ 6195 6196 varp = addr (rands (variable)); 6197 coord = varp -> symbol.coordinate; 6198 substr (bt -> flow_unit.set -> bits, coord, 1) = 6199 induction_boe_from_bt; 6200 substr (bt -> flow_unit.busy_on_exit -> bits, coord, 1) = 6201 induction_boe_from_bt; 6202 substr (lp -> loop.used -> bits, coord, 1) = "1"b; 6203 substr (lp -> loop.set -> bits, coord, 1) = "1"b; 6204 substr (lp -> loop.induction_var -> bits, coord, 1) = "1"b; 6205 6206 do p = lp -> loop.father repeat p -> loop.father while (p ^= null); 6207 substr (p -> loop.used -> bits, coord, 1) = "1"b; 6208 if induction_boe_from_bt 6209 | substr (p -> loop.set -> bits, coord, 1) 6210 then substr (p -> loop.set_multiple -> bits, coord, 1) = "1"b; 6211 substr (p -> loop.set -> bits, coord, 1) = "1"b; 6212 end; 6213 6214 /* build incrementing or updating code */ 6215 6216 insert_new = fixed (rel (incrp), 18); 6217 delta = cur_frame -> sr_frame.delta; 6218 6219 if delta = 0 6220 then do; 6221 6222 /* original induction var not updated by increment */ 6223 6224 number = 1; 6225 op_code = assign_op; 6226 delta = incrp -> operand (1); 6227 last = init_frame; 6228 6229 do p = init_frame -> sr_frame.next 6230 repeat p -> sr_frame.next while (last ^= cur_frame); 6231 q = p -> sr_frame.operator; 6232 j = p -> sr_frame.which; 6233 6234 insert_new = 6235 insert_operator_after ((q -> operator.op_code), 2, 6236 (insert_new)); 6237 6238 call connect_expression (delta, insert_new, j); 6239 call connect_expression ((q -> operand (3 - j)), 6240 insert_new, 3 - j); 6241 6242 delta, addr (quad (insert_new)) -> operator.output = 6243 create_integer_temporary (insert_new); 6244 6245 if last = init_frame 6246 then call chain_sr_cand (addr (quad (insert_new)), j, 6247 (incrc -> incr.statement)); 6248 6249 last = p; 6250 end; 6251 end; 6252 6253 else do; 6254 number = 1; 6255 if cur_frame -> sr_frame.sign 6256 then op_code = neg_storage_add_op; 6257 else if delta = one 6258 then do; 6259 op_code = storage_add_one_op; 6260 number = 0; 6261 end; 6262 else op_code = storage_add_op; 6263 end; 6264 6265 new_increment = 6266 insert_operator_after (op_code, number, insert_new); 6267 6268 new_incrp = addr (quad (new_increment)); 6269 new_incrp -> operator.output = variable; 6270 6271 if number > 0 6272 then do; 6273 call connect_expression (delta, new_increment, 1); 6274 6275 /* if this is a temp, add to loop end chain */ 6276 6277 if op_code ^= assign_op 6278 then do; 6279 deltap = addr (rands (delta)); 6280 if deltap -> node.node_type = temporary_node 6281 then if deltap -> temporary.loop_end_fu_pos = 0 6282 then call put_in_loop_end (deltap, lp); 6283 end; 6284 end; 6285 6286 /* remember the new induction variable for 6287* commoning and test replacement */ 6288 6289 /* fill in the sr_var node */ 6290 6291 srvp -> sr_var.next = incrc -> incr.var_chain; 6292 incrc -> incr.var_chain = srvp; 6293 6294 /* fill in information */ 6295 6296 srvp -> sr_var.all_constant = cur_frame -> sr_frame.all_constant; 6297 srvp -> sr_var.sign_differs = 6298 init_frame -> sr_frame.sign ^= cur_frame -> sr_frame.sign; 6299 srvp -> sr_var.sign_unknown = cur_frame -> sr_frame.sign_unknown; 6300 srvp -> sr_var.updated_by = new_incrp; 6301 6302 if varp -> symbol.secondary ^= null 6303 then do; 6304 call free_them ((varp -> symbol.secondary)); 6305 call release_node ((varp -> symbol.secondary), s_list, 2); 6306 end; 6307 varp -> symbol.secondary = srvp; 6308 6309 srvp -> sr_var.ninst = cur_frame -> sr_frame.ninst; 6310 if srvp -> sr_var.ninst <= hbound (srvp -> sr_var.tuple, 1) 6311 then do; 6312 if ^induction_busy_on_exit 6313 then have_test_replacement_candidate = "1"b; 6314 p = cur_frame; 6315 do i = srvp -> sr_var.ninst to 1 by -1; 6316 srvp -> sr_var (i).operator = p -> sr_frame.operator; 6317 srvp -> sr_var (i).which = p -> sr_frame.which; 6318 p = p -> sr_frame.prev; 6319 end; 6320 end; 6321 end; 6322 6323 else do; 6324 6325 /* An equivalent variable exists; 6326* just free the operator. */ 6327 6328 cur_o = cur_frame -> sr_frame.operator; 6329 if fixed (rel (cur_o), 18) = bt -> flow_unit.insert_operator 6330 then bt -> flow_unit.insert_operator = cur_o -> operator.back; 6331 6332 call decrement_input_ref_counts (cur_o); 6333 call free_operator (cur_o); 6334 6335 end; 6336 6337 call replace_inputs (inp, variable); 6338 6339 cur_frame -> sr_frame.variable = variable; 6340 end; 6341 6342 if o -> operator.op_code = assign_op 6343 then if full_strength_reduction 6344 then if output_is_new_induction_var (o) 6345 then call add_new_induction_var (o); 6346 else ; 6347 else ; 6348 6349 else if o -> operator.op_code = sub_index_op 6350 then do; 6351 6352 /* we don't need sub_index since opnd2 is now a variable */ 6353 6354 outp = addr (rands (o -> operator.output)); 6355 inp = addr (polish (outp -> temporary.start_input_to)); 6356 call replace_inputs (inp, cur_frame -> sr_frame.variable); 6357 call free_operator (o); 6358 end; 6359 end; 6360 end; 6361 6362 cur_o = cur_frame -> sr_frame.operator; 6363 if ^cur_o -> operator.freed 6364 then do; 6365 outp = addr (rands (cur_o -> operator.output)); 6366 6367 if ^induction_boe_from_bt 6368 then do; 6369 6370 /* This operator was unthreaded by reduce; 6371* finish freeing it now. If the output has a 6372* nonzero ref_count, it had better only be in 6373* loop end lists. */ 6374 6375 call decrement_input_ref_counts (cur_o); 6376 6377 if outp -> temporary.ref_count > 0 6378 then do; 6379 6380 /* Walk the input_to list. */ 6381 6382 do inp = addr (polish (outp -> temporary.start_input_to)) 6383 repeat (inp -> input_to.next) while (inp ^= null ()); 6384 if inp -> input_to.which >= 0 6385 then if ^inp -> input_to.operator -> operator.freed 6386 then call print_message (391); 6387 /* Fatal */ 6388 else ; 6389 else inp -> input_to.operator -> lchain.value = 0; 6390 end; 6391 end; 6392 6393 outp -> temporary.next = next_free_temp; 6394 next_free_temp = cur_o -> operator.output; 6395 cur_o -> operator.output = 0; 6396 /* mark as free */ 6397 cur_o -> operator.freed = "1"b; 6398 end; 6399 6400 else if outp -> temporary.ref_count = 0 6401 then do; 6402 6403 /* The output of this operator was input 6404* only to an expression for which there 6405* was already an equivalent induction 6406* variable. */ 6407 6408 if fixed (rel (cur_o), 18) = bt -> flow_unit.insert_operator 6409 then bt -> flow_unit.insert_operator = cur_o -> operator.back; 6410 6411 call decrement_input_ref_counts (cur_o); 6412 call free_operator (cur_o); 6413 6414 end; 6415 end; 6416 6417 cur_frame = cur_frame -> sr_frame.prev; 6418 end; 6419 6420 /* mark successful candidate */ 6421 6422 src -> sr_cand.which = 0; 6423 end; 6424 6425 step: 6426 end; 6427 6428 6429 if found_new_induction_variable 6430 then go to retry; 6431 6432 6433 finish: /* Do test replacement */ 6434 if have_test_replacement_candidate 6435 then do; 6436 call timer (6); 6437 call replace_tests; 6438 end; 6439 6440 /* free the chains */ 6441 6442 last = null; 6443 do incrc = incr_chain repeat incrc -> incr.next while (incrc ^= null); 6444 6445 /* remember which new induction vars were used in this loop and surrounding loops */ 6446 6447 do srvp = incrc -> incr.var_chain repeat p while (srvp ^= null); 6448 addr (rands (srvp -> sr_var.variable)) -> symbol.secondary = null; 6449 i = addr (rands (srvp -> sr_var.variable)) -> symbol.coordinate; 6450 if substr (lp -> loop.used -> bits, i, 1) | substr (bt -> flow_unit.used -> bits, i, 1) 6451 then srvp -> sr_var.used_in -> lbits = 6452 srvp -> sr_var.used_in -> lbits | lp -> loop.ancestors_and_me -> lbits; 6453 p = srvp -> sr_var.next; 6454 srvp -> sr_var.next = free_var_list; 6455 free_var_list = srvp; 6456 end; 6457 6458 incrc -> incr.var_chain = null; 6459 last = incrc; 6460 end; 6461 6462 if sr_chain ^= null 6463 then do; 6464 6465 /* do loop end processing for the unsuccessful candidates */ 6466 6467 do src = sr_chain repeat src -> sr_cand.next while (src ^= null); 6468 if src -> sr_cand.which ^= 0 6469 then do; 6470 stm = src -> sr_cand.statement; 6471 srp = src -> sr_cand.operator; 6472 fu = stm -> opt_statement.flow_unit; 6473 used_invariant_symbol = "1"b; /* for safety's sake */ 6474 call process_moved_descendants (srp, fu); 6475 end; 6476 end; 6477 6478 sr_tail -> sr_cand.next = free (size (sr_cand)); 6479 free (size (sr_cand)) = sr_chain; 6480 end; 6481 6482 if incr_chain ^= null 6483 then do; 6484 last -> incr.next = free (size (incr)); 6485 free (size (incr)) = incr_chain; 6486 end; 6487 6488 last = null; 6489 do incrc = ass_chain repeat incrc -> incr.next while (incrc ^= null); 6490 last = incrc; 6491 end; 6492 6493 if last ^= null 6494 then do; 6495 last -> incr.next = free (size (incr)); 6496 free (size (incr)) = ass_chain; 6497 end; 6498 6499 incr_chain, sr_chain, sr_tail, ass_chain = null; 6500 6501 return; 6502 6503 is_reducible: 6504 procedure (o, which) returns (bit (1) aligned); 6505 6506 /* decides if an expression is a candidate for strength reduction */ 6507 6508 dcl o pointer, /* pts to candidate operator */ 6509 which fixed binary (18); /* operand number of induction variable */ 6510 6511 6512 if o -> operator.op_code = add_op | o -> operator.op_code = sub_op | o -> operator.op_code = mult_op 6513 then return (is_invariant ((o -> operand (3 - which)))); 6514 6515 return ("0"b); 6516 6517 end is_reducible; 6518 6519 is_invariant: 6520 procedure (opnd) returns (bit (1) aligned); 6521 6522 dcl opnd fixed binary (18); 6523 6524 dcl p pointer; 6525 6526 p = addr (rands (opnd)); 6527 6528 if p -> node.node_type = array_ref_node 6529 then return ("0"b); 6530 6531 else if p -> node.node_type = constant_node 6532 then return ("1"b); 6533 6534 else if p -> node.node_type = temporary_node 6535 then return (p -> temporary.invariant); 6536 6537 else return (^substr (lp -> loop.set -> bits, p -> symbol.coordinate, 1)); 6538 6539 end is_invariant; 6540 6541 reduce: 6542 procedure (p_o, p_which); 6543 6544 /* builds an sr_frame to hold info about this operator, moves initializing code to back target, and derives 6545* delta for incrementing */ 6546 6547 dcl (o, p_o) pointer, /* points at operator to be reduced */ 6548 (which, p_which) fixed binary (18); /* operand number of induction variable */ 6549 6550 dcl (next_frame, outp, deltap, p, p1, p2) pointer; 6551 dcl i fixed binary (18); 6552 dcl factor fixed binary (18); 6553 dcl (cvalue1, cvalue2) fixed binary (18); 6554 6555 o = p_o; 6556 which = p_which; 6557 6558 if induction_boe_from_bt 6559 then do; 6560 6561 /* move this expression to the back target as initialization code. Turn off bits set by move so 6562* as not to confuse optimizer later */ 6563 6564 call move (o, stm, fu, bt); 6565 outp = addr (rands (o -> operator.output)); 6566 outp -> temporary.invariant, outp -> temporary.used_across_loops = "0"b; 6567 end; 6568 6569 else do; 6570 6571 /* Don't need initializaton code, so unthread the operator. It 6572* will be be freed later by reduce_strength when its sr_frame 6573* is popped. */ 6574 6575 call unthread (o); 6576 end; 6577 6578 /* build a new sr_frame */ 6579 6580 if cur_frame -> sr_frame.next ^= null 6581 then next_frame = cur_frame -> sr_frame.next; 6582 else next_frame = create_sr_frame (cur_frame); 6583 6584 next_frame -> sr_frame.operator = o; 6585 next_frame -> sr_frame.variable = 0; 6586 next_frame -> sr_frame.which = which; 6587 next_frame -> sr_frame.inp = addr (polish (addr (rands (o -> operator.output)) -> temporary.start_input_to)); 6588 next_frame -> sr_frame.ninst = cur_frame -> sr_frame.ninst + 1; 6589 next_frame -> sr_frame.init = bt -> flow_unit.insert_operator; 6590 6591 p2 = addr (rands (o -> operand (3 - which))); 6592 next_frame -> sr_frame.all_constant = 6593 cur_frame -> sr_frame.all_constant & (p2 -> node.node_type = constant_node); 6594 6595 /* calculate delta and sign for new frame. Put operations for delta in back target */ 6596 6597 next_frame -> sr_frame.sign = cur_frame -> sr_frame.sign; 6598 next_frame -> sr_frame.sign_unknown = cur_frame -> sr_frame.sign_unknown; 6599 6600 if cur_frame -> sr_frame.delta = 0 /* induction var updated by assignment */ 6601 then next_frame -> sr_frame.delta = 0; 6602 6603 else if o -> operator.op_code = mult_op 6604 then do; 6605 factor = o -> operand (3 - which); 6606 6607 if p2 -> node.node_type ^= constant_node 6608 then next_frame -> sr_frame.sign_unknown = "1"b; 6609 else do; 6610 unspec (cvalue2) = p2 -> constant.value; 6611 if cvalue2 < 0 6612 then do; 6613 factor = create_integer_constant (-cvalue2); 6614 p2 = addr (rands (factor)); 6615 next_frame -> sr_frame.sign = ^next_frame -> sr_frame.sign; 6616 end; 6617 end; 6618 6619 if cur_frame -> sr_frame.delta = one 6620 then next_frame -> sr_frame.delta = factor; 6621 6622 else do; 6623 p1 = addr (rands (cur_frame -> sr_frame.delta)); 6624 6625 if p1 -> node.node_type = constant_node & p2 -> node.node_type = constant_node 6626 then do; 6627 unspec (cvalue1) = p1 -> constant.value; 6628 unspec (cvalue2) = p2 -> constant.value; 6629 next_frame -> sr_frame.delta = create_integer_constant (cvalue1 * cvalue2); 6630 end; 6631 else do; 6632 insert_delta = insert_operator_after (mult_op, 2, (insert_delta)); 6633 deltap = addr (quad (insert_delta)); 6634 next_frame -> sr_frame.delta, deltap -> operator.output = 6635 create_integer_temporary (insert_delta); 6636 6637 call connect_expression ((cur_frame -> sr_frame.delta), insert_delta, which); 6638 call connect_expression (factor, insert_delta, 3 - which); 6639 6640 /* set appropriate used bits in back target */ 6641 6642 do i = 1 to 2; 6643 p = addr (rands (deltap -> operand (i))); 6644 if p -> node.node_type = symbol_node 6645 then substr (bt -> flow_unit.used -> bits, p -> symbol.coordinate, 1) = "1"b; 6646 end; 6647 end; 6648 end; 6649 end; 6650 6651 else do; 6652 6653 /* we have + or -, delta is unchanged, but the sign may change if we have c - i */ 6654 6655 if o -> operator.op_code = sub_op & which = 2 6656 then next_frame -> sr_frame.sign = ^next_frame -> sr_frame.sign; 6657 6658 next_frame -> sr_frame.delta = cur_frame -> sr_frame.delta; 6659 end; 6660 6661 /* make the new frame our current frame */ 6662 6663 cur_frame = next_frame; 6664 6665 end reduce; 6666 6667 search_for_equivalent: 6668 procedure (/* cur_frame, incrc */) returns (fixed binary (18)); 6669 6670 /* searches for new induction variable that would be equivalent to the one we 6671* would have to create for this sr_frame */ 6672 6673 dcl (srvp, p, o1, o2) pointer; 6674 dcl (i, ninst, which) fixed binary (18); 6675 dcl inequality_found bit (1) aligned; 6676 6677 ninst = cur_frame -> sr_frame.ninst; 6678 if ninst <= hbound (srvp -> sr_var.tuple, 1) 6679 then do srvp = incrc -> incr.var_chain repeat srvp -> sr_var.next while (srvp ^= null); 6680 if ninst = srvp -> sr_var.ninst 6681 then do; 6682 inequality_found = "0"b; 6683 p = cur_frame; 6684 do i = ninst to 1 by -1 while (^inequality_found); 6685 if p -> sr_frame.operator ^= srvp -> sr_var.operator (i) 6686 then do; 6687 inequality_found = "1"b; 6688 if p -> sr_frame.which = srvp -> sr_var.which (i) 6689 then do; 6690 which = p -> sr_frame.which; 6691 o1 = p -> sr_frame.operator; 6692 o2 = srvp -> sr_var.operator (i); 6693 if o1 -> operator.op_code = o2 -> operator.op_code 6694 then if o1 -> operand (3 - which) = o2 -> operand (3 - which) 6695 then inequality_found = "0"b; 6696 end; 6697 end; 6698 p = p -> sr_frame.prev; 6699 end; 6700 6701 if ^inequality_found 6702 then return (srvp -> sr_var.variable); 6703 end; 6704 end; 6705 6706 return (0); 6707 6708 end search_for_equivalent; 6709 6710 create_sr_frame: 6711 procedure (last_frame) returns (pointer); 6712 6713 /* creates strength_reduction frame used by reduce_strength to effect tree 6714* search for uses of reducible expression */ 6715 6716 dcl last_frame pointer; /* points to frame we are to connect to the new one */ 6717 6718 dcl new_frame pointer; 6719 6720 new_frame = get_opt_space (size (sr_frame)); 6721 6722 new_frame -> sr_frame.next = null; 6723 new_frame -> sr_frame.prev = last_frame; 6724 if last_frame ^= null 6725 then last_frame -> sr_frame.next = new_frame; 6726 6727 return (new_frame); 6728 6729 end create_sr_frame; 6730 6731 create_var: 6732 procedure (lp) returns (pointer); 6733 6734 /* creates automatic integer variable for use as a strength reduction induction variable */ 6735 6736 dcl lp pointer; 6737 6738 dcl (var, lp_num) fixed binary (18); 6739 dcl (p, last, srvp) pointer; 6740 6741 lp_num = lp -> loop.number; 6742 6743 /* See if there is already a suitable induction variable. It must already be used in this loop. */ 6744 6745 last = null; 6746 do srvp = free_var_list repeat srvp -> sr_var.next while (srvp ^= null); 6747 if ^substr (srvp -> sr_var.used_in -> lbits, lp_num, 1) 6748 then do; 6749 if last ^= null 6750 then last -> sr_var.next = srvp -> sr_var.next; 6751 else free_var_list = srvp -> sr_var.next; 6752 return (srvp); 6753 end; 6754 last = srvp; 6755 end; 6756 6757 /* we need a brand new variable */ 6758 6759 srvp = create_sr_var_node (); 6760 srvp -> sr_var.used_in = get_opt_space (size (lbits)); 6761 6762 /* create and initialize the symbol node */ 6763 6764 var = create_node (symbol_node, size (symbol)); 6765 srvp -> sr_var.variable = var; 6766 p = addr (rands (var)); 6767 6768 p -> symbol.data_type = int_mode; 6769 p -> symbol.element_size = data_type_size (int_mode); 6770 p -> symbol.operand_type = variable_type; 6771 p -> symbol.by_compiler = "1"b; 6772 p -> symbol.integer, p -> symbol.automatic = "1"b; 6773 p -> symbol.new_induction_var = "1"b; 6774 6775 p -> symbol.secondary = null; 6776 6777 /* connect the node to the symbol chain */ 6778 6779 addr (rands (cs -> subprogram.last_symbol)) -> symbol.next_symbol = var; 6780 cs -> subprogram.last_symbol = var; 6781 6782 /* assign a coordinate to the symbol */ 6783 6784 n_sym = n_sym + 1; 6785 if n_sym > max_sym 6786 then do; 6787 6788 /* FATAL ERROR because we have already moved code on the assumption of the success of create_var */ 6789 6790 call print_message (385); 6791 return (null); 6792 end; 6793 6794 p -> symbol.coordinate = n_sym; 6795 6796 substr (integer_scalar_mask, n_sym, 1) = "1"b; 6797 6798 return (srvp); 6799 6800 end create_var; 6801 6802 create_sr_var_node: 6803 procedure () returns (pointer); 6804 6805 dcl srvp pointer; 6806 6807 if freesrv = null 6808 then srvp = get_opt_space (size (sr_var)); 6809 else do; 6810 srvp = freesrv; 6811 freesrv = freesrv -> sr_var.next; 6812 end; 6813 6814 return (srvp); 6815 6816 end create_sr_var_node; 6817 6818 output_is_new_induction_var: 6819 procedure (o) returns (bit (1) aligned); 6820 6821 dcl o pointer; /* -> assign op whose output is being examined */ 6822 6823 dcl s pointer; 6824 6825 /* Since the RHS of o is a new induction variable, if the LHS is a 6826* simple integer set only once in the loop, then it too is an inductioon 6827* variable. */ 6828 6829 s = addr (rands (o -> operator.output)); 6830 6831 if s -> node.node_type = symbol_node 6832 then if s -> symbol.data_type = int_mode 6833 then if ^s -> symbol.aliasable & ^s -> symbol.new_induction_var 6834 then if ^substr (lp -> loop.set_multiple -> bits, s -> symbol.coordinate, 1) 6835 then return ("1"b); 6836 6837 return ("0"b); 6838 6839 end output_is_new_induction_var; 6840 6841 add_new_induction_var: 6842 procedure (p_o); 6843 6844 dcl (o, p_o) pointer; /* -> assignment producing new induction var */ 6845 6846 dcl (left, right, srvp) pointer; 6847 6848 found_new_induction_variable = "1"b; 6849 6850 o = p_o; 6851 6852 left = addr (rands (o -> operator.output)); 6853 right = addr (rands (o -> operator.operand (1))); 6854 6855 /* we need to mark used bits for right in all flow_units 6856* so that used_in_loop will look for us */ 6857 6858 call force_used_in_loop (lp, (right -> symbol.coordinate)); 6859 6860 /* chain incr nodes first for right, then for left */ 6861 6862 srvp = right -> symbol.secondary; 6863 call chain_incr ((srvp -> sr_var.updated_by), (incrc -> incr.statement), incr_chain); 6864 call chain_incr (o, stm, incr_chain); 6865 6866 /* turn on the induction_var bit in lp, so we know about this variable */ 6867 6868 substr (lp -> loop.induction_var -> bits, left -> symbol.coordinate, 1) = "1"b; 6869 6870 end add_new_induction_var; 6871 6872 find_new_induction_vars_on_ass_chain: 6873 procedure (p_lp); 6874 6875 dcl (lp, p_lp) pointer; /* -> loop node */ 6876 6877 dcl (c, next, prev) pointer; 6878 dcl (o, left, right) pointer; 6879 dcl changed bit (1) aligned; 6880 6881 /* ass_chain chains assignments of the form i = j, where both i and 6882* j are simple integers assigned only ince in lp. If j is an 6883* induction variable, then so is i. */ 6884 6885 lp = p_lp; 6886 6887 changed = "1"b; 6888 6889 do while (changed); 6890 changed = "0"b; 6891 prev = null; 6892 6893 do c = ass_chain repeat next while (c ^= null); 6894 next = c -> incr.next; 6895 o = c -> incr.value; 6896 left = addr (rands (o -> operator.output)); 6897 right = addr (rands (o -> operand (1))); 6898 6899 if substr (lp -> loop.induction_var -> bits, right -> symbol.coordinate, 1) 6900 then do; 6901 6902 /* left can now be made an induction variable. */ 6903 6904 changed = "1"b; 6905 substr (lp -> loop.induction_var -> bits, left -> symbol.coordinate, 1) = "1"b; 6906 6907 /* Rethread this operation onto incr_chain. */ 6908 6909 if prev ^= null 6910 then prev -> incr.next = c -> incr.next; 6911 else ass_chain = c -> incr.next; 6912 c -> incr.next = incr_chain; 6913 incr_chain = c; 6914 end; 6915 6916 else prev = c; 6917 end; 6918 end; 6919 6920 end find_new_induction_vars_on_ass_chain; 6921 6922 force_used_in_loop: 6923 procedure (lp, coord); 6924 6925 /* forces used bit on in all flow_units and all loops contained in lp */ 6926 6927 dcl lp pointer, 6928 coord fixed binary (18); 6929 6930 dcl (adam, p) pointer; 6931 dcl c fixed binary (18); 6932 6933 adam = lp; 6934 c = coord; 6935 6936 call force_loop (adam); 6937 6938 if adam -> loop.son = null 6939 then return; 6940 6941 /* simulate recursive walk */ 6942 6943 p = adam -> loop.son; 6944 6945 do while ("1"b); 6946 call force_loop (p); 6947 6948 if p -> loop.son ^= null 6949 then p = p -> loop.son; 6950 6951 else do; 6952 do while (p -> loop.brother = null); 6953 p = p -> loop.father; 6954 if p = adam 6955 then return; 6956 end; 6957 6958 p = p -> loop.brother; 6959 end; 6960 end; 6961 6962 force_loop: 6963 procedure (lp); 6964 6965 dcl (lp, fu) pointer; 6966 6967 substr (lp -> loop.used -> bits, c, 1) = "1"b; 6968 6969 do fu = lp -> loop.members repeat fu -> flow_unit.next_in_loop while (fu ^= null); 6970 substr (fu -> flow_unit.used -> bits, c, 1) = "1"b; 6971 end; 6972 6973 end force_loop; 6974 6975 end force_used_in_loop; 6976 6977 replace_tests: 6978 procedure (); 6979 6980 /* This program attempts to eliminate induction variables that are only used to increment themselves, 6981* or are only used to increment themselves and in one end_of_loop test */ 6982 6983 dcl (incrc, incrp, indp, o, fu) pointer; 6984 dcl (induction_var, n_uses, st_found, which, code) fixed binary (18); 6985 6986 do incrc = incr_chain repeat incrc -> incr.next while (incrc ^= null); 6987 incrp = incrc -> incr.value; 6988 induction_var = incrp -> operator.output; 6989 indp = addr (rands (induction_var)); 6990 6991 if incrc -> incr.var_chain ^= null 6992 & ^substr (lp -> loop.busy_on_exit -> bits, indp -> symbol.coordinate, 1) 6993 then do; 6994 n_uses = used_in_loop (induction_var, lp, o, st_found, fu); 6995 6996 if n_uses = 0 6997 then call eliminate_increment; 6998 6999 else if n_uses = 1 7000 then do; 7001 7002 /* We have a use other than the increment. It must be as the operand 7003* of a relational operator in the test ending an exit flow unit */ 7004 7005 if substr (lp -> loop.is_exit -> dbits, fu -> flow_unit.number, 1) 7006 & st_found = fu -> flow_unit.last_statement & o -> operator.op_code >= less_op 7007 & o -> operator.op_code <= greater_op 7008 then do; 7009 7010 /* see if other operand is a loop constant */ 7011 7012 if o -> operand (1) = induction_var 7013 then which = 1; 7014 else which = 2; 7015 7016 if is_invariant ((o -> operand (3 - which))) 7017 then do; 7018 call change_test (code); 7019 if code = 0 7020 then call eliminate_increment; 7021 end; 7022 end; 7023 end; 7024 end; 7025 end; 7026 7027 change_test: 7028 procedure (code); 7029 7030 dcl code fixed binary (18); /* (output) */ 7031 7032 dcl (srvp, p, invp, q) pointer; 7033 dcl (min_ninst, invariant_opnd, i, last_temp, input, j) fixed binary (18); 7034 dcl found_all_constant bit (1) aligned; 7035 dcl reverse_rel_op (8:13) fixed binary (18) internal static initial (13, 12, 10, 11, 9, 8); 7036 7037 /* first, we must find a good new induction variable to use */ 7038 7039 found_all_constant = "0"b; 7040 min_ninst = 1000; 7041 srvp = null; 7042 7043 do p = incrc -> incr.var_chain repeat p -> sr_var.next while (p ^= null); 7044 if ^p -> sr_var.sign_unknown 7045 & substr (lp -> loop.used -> bits, addr (rands (p -> sr_var.variable)) -> symbol.coordinate, 1) 7046 then if p -> sr_var.all_constant & ^found_all_constant 7047 then do; 7048 found_all_constant = "1"b; 7049 min_ninst = p -> sr_var.ninst; 7050 srvp = p; 7051 end; 7052 7053 else if p -> sr_var.ninst < min_ninst & p -> sr_var.all_constant = found_all_constant 7054 then do; 7055 min_ninst = p -> sr_var.ninst; 7056 srvp = p; 7057 end; 7058 end; 7059 7060 if min_ninst > hbound (srvp -> sr_var.tuple, 1) 7061 then do; 7062 7063 /* we can't change the test */ 7064 7065 code = 1; 7066 return; 7067 end; 7068 7069 else code = 0; 7070 7071 /* srvp now points at the sr_var node we will use. If the loop invariant 7072* is a temporary, disconnect it from this operator */ 7073 7074 invariant_opnd = o -> operand (3 - which); 7075 invp = addr (rands (invariant_opnd)); 7076 7077 if invp -> node.node_type = temporary_node 7078 then call disconnect_temporary (invp, o); 7079 7080 else if invp -> node.node_type = symbol_node 7081 then substr (bt -> flow_unit.used -> bits, invp -> symbol.coordinate, 1) = "1"b; 7082 7083 /* build up the new expression that will be tested against */ 7084 7085 do i = 1 to min_ninst; 7086 q = srvp -> sr_var.operator (i); 7087 j = srvp -> sr_var.which (i); 7088 7089 insert_delta = insert_operator_after ((q -> operator.op_code), 2, (insert_delta)); 7090 7091 if i = 1 7092 then input = invariant_opnd; 7093 else input = last_temp; 7094 7095 call connect_expression (input, insert_delta, j); 7096 call connect_expression ((q -> operand (3 - j)), insert_delta, 3 - j); 7097 7098 last_temp, addr (quad (insert_delta)) -> operator.output = create_integer_temporary (insert_delta); 7099 end; 7100 7101 call connect_expression (last_temp, fixed (rel (o), 18), 3 - which); 7102 o -> operand (which) = srvp -> sr_var.variable; 7103 7104 if srvp -> sr_var.sign_differs 7105 then o -> operator.op_code = reverse_rel_op (o -> operator.op_code); 7106 7107 call put_in_loop_end (addr (rands (last_temp)), lp); 7108 7109 substr (fu -> flow_unit.used -> bits, indp -> symbol.coordinate, 1) = "0"b; 7110 substr (fu -> flow_unit.used -> bits, addr (rands (srvp -> sr_var.variable)) -> symbol.coordinate, 1) = "1"b; 7111 7112 end change_test; 7113 7114 eliminate_increment: 7115 procedure (); 7116 7117 dcl p pointer; 7118 7119 /* if the value the induction variable was incremented by was a temporary, disconnect it */ 7120 7121 if incrp -> operator.number > 0 7122 then do; 7123 p = addr (rands (incrp -> operand (1))); 7124 if p -> node.node_type = temporary_node 7125 then call disconnect_temporary (p, incrp); 7126 end; 7127 7128 /* unthread the operator */ 7129 7130 call unthread (incrp); 7131 7132 /* update various usage bits */ 7133 7134 substr (lp -> loop.used -> bits, indp -> symbol.coordinate, 1) = "0"b; 7135 substr (lp -> loop.set -> bits, indp -> symbol.coordinate, 1) = "0"b; 7136 substr (bt -> flow_unit.busy_on_exit -> bits, indp -> symbol.coordinate, 1) = "0"b; 7137 7138 /* Can't propagate resetting of busy_on_exit any further since used bit has been turned on in 7139* back target by strength reduction. */ 7140 7141 end eliminate_increment; 7142 7143 end replace_tests; 7144 7145 end reduce_strength; 7146 7147 used_in_loop: 7148 procedure (p_induction_var, p_adam, p_o, p_st_found, p_fu) returns (fixed binary (18)); 7149 7150 /* counts non-incremental uses of induction variable in a loop; stops if more than one use found. */ 7151 7152 dcl (induction_var, p_induction_var) fixed binary (18), /* induction variable (input) */ 7153 (p_adam, adam) pointer, /* -> loop to be searched (input) */ 7154 p_o pointer, /* -> operator in which use found (output) */ 7155 p_st_found fixed binary (18), /* offset of stmt in which use found (output) */ 7156 p_fu pointer; /* -> flow_unit in which use found (output) */ 7157 /* returns: 7158* 0 -- no use found 7159* 1 -- one use found 7160* 2 -- many uses found */ 7161 dcl (coord, n_uses) fixed binary (18); 7162 dcl p pointer; 7163 dcl ind_used bit (1) aligned; 7164 7165 adam = p_adam; 7166 induction_var = p_induction_var; 7167 coord = addr (rands (induction_var)) -> symbol.coordinate; 7168 n_uses = 0; 7169 7170 call process_flow_units (adam); 7171 7172 if n_uses > 1 | adam -> loop.son = null 7173 then return (n_uses); 7174 7175 /* simulate recursive tree walk */ 7176 7177 p = adam -> loop.son; 7178 7179 do while ("1"b); 7180 ind_used = substr (p -> loop.used -> bits, coord, 1); 7181 7182 if ind_used 7183 then do; 7184 call process_flow_units (p); 7185 if n_uses > 1 7186 then return (n_uses); 7187 end; 7188 7189 if ind_used & p -> loop.son ^= null 7190 then p = p -> loop.son; 7191 7192 else do; 7193 do while (p -> loop.brother = null); 7194 p = p -> loop.father; 7195 if p = adam 7196 then return (n_uses); 7197 end; 7198 7199 p = p -> loop.brother; 7200 end; 7201 end; 7202 7203 process_flow_units: 7204 procedure (lp); 7205 7206 dcl lp pointer; /* -> loop to be scanned */ 7207 7208 dcl (o, stm, fu) pointer; 7209 dcl (next_statement, next_unit_statement, op, i) fixed binary (18); 7210 7211 do fu = lp -> loop.members repeat fu -> flow_unit.next_in_loop while (fu ^= null); 7212 if substr (fu -> flow_unit.used -> bits, coord, 1) 7213 then do; 7214 7215 /* turn off used bit util we are sure that the var is used */ 7216 7217 substr (fu -> flow_unit.used -> bits, coord, 1) = "0"b; 7218 7219 /* loop through the statements */ 7220 7221 if fu -> flow_unit.next ^= null 7222 then next_unit_statement = fu -> flow_unit.next -> flow_unit.first_statement; 7223 else next_unit_statement = 0; 7224 7225 do cur_statement = fu -> flow_unit.first_statement repeat next_statement 7226 while (cur_statement ^= next_unit_statement); 7227 7228 stm = addr (quad (cur_statement)); 7229 next_statement = fixed (stm -> opt_statement.next, 18); 7230 7231 do op = stm -> opt_statement.first_operator repeat o -> operator.next 7232 while (op ^= next_statement); 7233 7234 o = addr (quad (op)); 7235 7236 do i = 1 to o -> operator.number; 7237 if o -> operand (i) = induction_var 7238 then do; 7239 n_uses = n_uses + 1; 7240 substr (fu -> flow_unit.used -> bits, coord, 1) = "1"b; 7241 if n_uses > 1 7242 then return; 7243 p_o = o; 7244 p_st_found = cur_statement; 7245 p_fu = fu; 7246 end; 7247 end; 7248 7249 if o -> operator.op_code = write_namelist_op 7250 then if in_namelist (o, induction_var) 7251 then do; 7252 n_uses = 2; 7253 substr (fu -> flow_unit.used -> bits, coord, 1) = "1"b; 7254 return; 7255 end; 7256 end; 7257 end; 7258 end; 7259 end; 7260 7261 end process_flow_units; 7262 7263 end used_in_loop; 7264 7265 chain_dac: 7266 procedure (var, fu); 7267 7268 /* chains dead_assign_cand nodes for later processing */ 7269 7270 dcl var fixed binary (18), /* variable to be removed later */ 7271 fu pointer; /* -> flow_unit from which var shd be removed */ 7272 7273 dcl p pointer; 7274 7275 p = create_da_node (); 7276 p -> dead_assign_cand.next = da_chain; 7277 da_chain = p; 7278 p -> dead_assign_cand.variable = var; 7279 p -> dead_assign_cand.flow_unit = fu; 7280 7281 end chain_dac; 7282 7283 create_da_node: 7284 procedure () returns (pointer); 7285 7286 dcl p pointer; 7287 7288 if free (size (dead_assign_cand)) = null 7289 then p = get_opt_space (size (dead_assign_cand)); 7290 else do; 7291 p = free (size (dead_assign_cand)); 7292 free (size (dead_assign_cand)) = free (size (dead_assign_cand)) -> dead_assign_cand.next; 7293 end; 7294 7295 return (p); 7296 7297 end create_da_node; 7298 7299 remove_dead_assignments: 7300 procedure (); 7301 7302 /* This routine removes assignments made dead by the combination of strength reduction, test replacement, and 7303* constant propagation. */ 7304 7305 dcl (dac, fu, last, o, varp) pointer; 7306 dcl (back, c, first_statement, i, op, variable) fixed binary (18); 7307 dcl in_common bit (1) aligned; 7308 7309 /* This program assumes that an assignment will not be dead unless the right hand side is a constant, 7310* since unless this is so, the init code for new induction variables will reference the old 7311* induction variable. Although all vars added to da_chain were not busy_on_exit from their 7312* flow_units when added, they may be now, so that we must perform the check again inside 7313* the loop. */ 7314 7315 last = null; 7316 7317 do dac = da_chain repeat dac -> dead_assign_cand.next while (dac ^= null); 7318 variable = dac -> dead_assign_cand.variable; 7319 varp = addr (rands (variable)); 7320 c = varp -> symbol.coordinate; 7321 in_common = varp -> symbol.in_common; 7322 fu = dac -> dead_assign_cand.flow_unit; 7323 7324 if ^fu -> flow_unit.removed & substr (fu -> flow_unit.set -> bits, c, 1) 7325 & ^substr (fu -> flow_unit.busy_on_exit -> bits, c, 1) 7326 then do; 7327 7328 /* refresh insert_operator field since previous optimizations may have killed it */ 7329 7330 call derive_insert_for_bt (fu); 7331 7332 /* loop backwards through operators looking for uses and sets */ 7333 7334 first_statement = fu -> flow_unit.first_statement; 7335 7336 do op = fu -> flow_unit.insert_operator repeat back while (op ^= first_statement); 7337 o = addr (quad (op)); 7338 back = o -> operator.back; 7339 7340 /* special handling for namelist and common */ 7341 7342 if o -> operator.op_code = read_namelist_op | o -> operator.op_code = write_namelist_op 7343 then if in_namelist (o, variable) 7344 then go to step; 7345 else ; 7346 else if in_common 7347 then if o -> operator.op_code = func_ref_op | o -> operator.op_code = call_op 7348 then go to step; 7349 7350 /* look for uses */ 7351 7352 do i = 1 to o -> operator.number; 7353 if o -> operand (i) = variable 7354 then go to step; 7355 end; 7356 7357 /* look for set */ 7358 7359 if o -> operator.output = variable & o -> operator.op_code ^= stat_op 7360 then do; 7361 if op_class (o -> operator.op_code) >= function_class 7362 then go to step; 7363 7364 call unthread (o); 7365 7366 if ^substr (fu -> flow_unit.set_multiple -> bits, c, 1) 7367 then do; 7368 substr (fu -> flow_unit.set -> bits, c, 1) = "0"b; 7369 go to step; 7370 end; 7371 end; 7372 end; 7373 7374 substr (fu -> flow_unit.set -> bits, c, 1) = "0"b; 7375 substr (fu -> flow_unit.set_multiple -> bits, c, 1) = "0"b; 7376 substr (fu -> flow_unit.used -> bits, c, 1) = "0"b; 7377 end; 7378 7379 step: 7380 last = dac; 7381 end; 7382 7383 last -> dead_assign_cand.next = free (size (dead_assign_cand)); 7384 free (size (dead_assign_cand)) = da_chain; 7385 da_chain = null; 7386 7387 end remove_dead_assignments; 7388 7389 create_integer_temporary: 7390 procedure (op) returns (fixed binary (18)); 7391 7392 dcl op fixed binary (18); /* operator producing the temp */ 7393 7394 dcl t pointer; 7395 dcl temp fixed binary (18); 7396 7397 /* allocate the space */ 7398 7399 if next_free_temp = 0 7400 then do; 7401 temp = create_node (temporary_node, size (temporary)); 7402 t = addr (rands (temp)); 7403 end; 7404 7405 else do; 7406 temp = next_free_temp; 7407 t = addr (rands (temp)); 7408 next_free_temp = t -> temporary.next; 7409 unspec (t -> temporary) = "0"b; 7410 t -> temporary.node_type = temporary_node; 7411 end; 7412 7413 /* fill in the data */ 7414 7415 t -> temporary.data_type = int_mode; 7416 t -> temporary.operand_type = temp_type; 7417 t -> temporary.size = 1; 7418 t -> temporary.output_by = op; 7419 t -> temporary.not_in_storage = "1"b; 7420 7421 return (temp); 7422 7423 end create_integer_temporary; 7424 7425 remove_loop: 7426 procedure (lp); 7427 7428 /* removes "useless" loops */ 7429 7430 dcl lp pointer; /* -> loop to be removed */ 7431 7432 dcl (adam, p, bt, bd, bdl, exit_target, jop, jst) pointer; 7433 dcl finished bit (1) aligned; 7434 dcl (j_operator, j_statement) fixed binary (18); 7435 7436 adam = lp; 7437 7438 /* print warning since this could be unexpected if the user was trying 7439* to save data between invocations with automatic variables */ 7440 7441 cur_statement = adam -> loop.entry_unit -> flow_unit.first_statement; 7442 call print_message (387); 7443 7444 bt = adam -> loop.back_target; 7445 7446 /* propagate busy_on_exit from loop to back_target */ 7447 7448 bt -> flow_unit.busy_on_exit -> bits = adam -> loop.busy_on_exit -> bits; 7449 7450 /* Remove all operations from the loop. */ 7451 7452 call remove_units_from_loop (adam); 7453 7454 /* process all of adam's descendants */ 7455 7456 if adam -> loop.son ^= null 7457 then do; 7458 p = adam -> loop.son; 7459 finished = "0"b; 7460 7461 do while (^finished); 7462 call remove_units_from_loop (p); 7463 7464 if p -> loop.son ^= null 7465 then p = p -> loop.son; 7466 7467 else do; 7468 do while (p -> loop.brother = null & ^finished); 7469 p = p -> loop.father; 7470 if p = adam 7471 then finished = "1"b; 7472 end; 7473 7474 p = p -> loop.brother; 7475 end; 7476 end; 7477 end; 7478 7479 /* attach back target directly to the exit target of the loop */ 7480 7481 exit_target = adam -> loop.exits -> chain.value -> edge.to.value; 7482 7483 if bt -> flow_unit.falls_through 7484 then do; 7485 if bt -> flow_unit.next ^= exit_target 7486 then do; 7487 7488 /* need a jump to the exit_target */ 7489 7490 j_operator, bt -> flow_unit.insert_operator = 7491 insert_operator_after (jump_op, 1, (bt -> flow_unit.insert_operator)); 7492 addr (quad (j_operator)) -> operand (1) = get_flow_unit_label (exit_target); 7493 end; 7494 end; 7495 7496 else do; 7497 j_statement = bt -> flow_unit.last_statement; 7498 jst = addr (quad (j_statement)); 7499 j_operator = jst -> opt_statement.first_operator; 7500 jop = addr (quad (j_operator)); 7501 7502 if bt -> flow_unit.next ^= exit_target 7503 then jop -> operand (1) = get_flow_unit_label (exit_target); 7504 else call free_operator (jop); 7505 end; 7506 7507 call link (bt, exit_target); 7508 7509 /* if the exit_target's back dominator was in one of the removed 7510* loops, the adam loop's back target becomes the new back 7511* dominator */ 7512 7513 bd = exit_target -> flow_unit.dominator; 7514 bdl = bd -> flow_unit.loop; 7515 if substr (bdl -> loop.ancestors_and_me -> lbits, adam -> loop.number, 1) 7516 then exit_target -> flow_unit.dominator = bt; 7517 7518 return; 7519 7520 get_flow_unit_label: 7521 procedure (fu) returns (fixed binary (18)); 7522 7523 dcl fu pointer; /* -> flow_unit whose label is to be returned */ 7524 7525 dcl (f_label, f_statement) fixed binary (18); 7526 7527 f_statement = fu -> flow_unit.first_statement; 7528 f_label = addr (quad (f_statement)) -> opt_statement.label; 7529 if f_label = 0 7530 then f_label = create_label (f_statement); 7531 7532 return (f_label); 7533 7534 end get_flow_unit_label; 7535 7536 remove_units_from_loop: 7537 procedure (lp); 7538 7539 dcl lp pointer; /* -> loop whose flow_units are to be removed */ 7540 7541 dcl (fu, first_fu, o, stm) pointer; 7542 dcl (op, next_op, next_statement, next_unit_statement) fixed binary (18); 7543 7544 first_fu = lp -> loop.members; 7545 lp -> loop.members = null; 7546 7547 do fu = first_fu repeat fu -> flow_unit.next_in_loop while (fu ^= null); 7548 next_unit_statement = fu -> flow_unit.next -> flow_unit.first_statement; 7549 7550 do cur_statement = fu -> flow_unit.first_statement repeat next_statement 7551 while (cur_statement ^= next_unit_statement); 7552 stm = addr (quad (cur_statement)); 7553 next_statement = fixed (stm -> opt_statement.next, 18); 7554 7555 do op = stm -> opt_statement.first_operator repeat next_op while (op ^= next_statement); 7556 o = addr (quad (op)); 7557 next_op = o -> operator.next; 7558 call remove_operator (o); 7559 end; 7560 7561 stm -> opt_statement.label = 0; 7562 stm -> opt_statement.flow_unit = bt; 7563 if stm -> opt_statement.moved 7564 then call free_statement (stm); 7565 end; 7566 7567 fu -> flow_unit.used -> bits, fu -> flow_unit.busy_on_entry -> bits, fu -> flow_unit.busy_on_exit -> bits, 7568 fu -> flow_unit.always_completely_set -> bits, fu -> flow_unit.set -> bits, 7569 fu -> flow_unit.set_multiple -> bits = "0"b; 7570 7571 /* detach the flow_unit */ 7572 7573 call detach_flow_unit (fu); 7574 end; 7575 7576 lp -> loop.used -> bits, lp -> loop.set -> bits, lp -> loop.set_multiple -> bits = "0"b; 7577 7578 remove_operator: 7579 procedure (p_o); 7580 7581 dcl (o, p_o) pointer; /* -> operator to be removed from loop */ 7582 7583 dcl (p, outp) pointer; 7584 dcl (i, opnd) fixed binary (18); 7585 7586 o = p_o; 7587 7588 do i = 1 to o -> operator.number; 7589 opnd = o -> operand (i); 7590 if opnd > 0 7591 then do; 7592 p = addr (rands (opnd)); 7593 7594 if p -> node.node_type = array_ref_node 7595 then p -> array_ref.ref_count = p -> array_ref.ref_count - 1; 7596 7597 else if p -> node.node_type = temporary_node 7598 then p -> temporary.ref_count = p -> temporary.ref_count - 1; 7599 end; 7600 end; 7601 7602 if o -> operator.output > 0 7603 then do; 7604 outp = addr (rands (o -> operator.output)); 7605 7606 if outp -> node.node_type = temporary_node | o -> operator.op_code = opt_subscript_op 7607 then call replace_inputs (addr (polish (outp -> temporary.start_input_to)), 0); 7608 end; 7609 7610 call free_operator (o); 7611 7612 end remove_operator; 7613 7614 end remove_units_from_loop; 7615 7616 end remove_loop; 7617 7618 free_statement: 7619 procedure (stm); 7620 7621 dcl stm pointer; /* -> opt_statement to be unthreaded */ 7622 7623 dcl (next_statement, last_statement) fixed binary (18); 7624 dcl (nst, lst) pointer; 7625 7626 next_statement = fixed (stm -> opt_statement.next, 18); 7627 nst = addr (quad (next_statement)); 7628 last_statement = fixed (stm -> opt_statement.back, 18); 7629 lst = addr (quad (last_statement)); 7630 7631 lst -> opt_statement.next = stm -> opt_statement.next; 7632 nst -> opt_statement.back = stm -> opt_statement.back; 7633 7634 call unthread (stm); 7635 7636 end free_statement; 7637 7638 end optimize_subprogram; 7639 7640 create_integer_constant: 7641 procedure (value) returns (fixed binary (18)); 7642 7643 dcl value fixed binary (18); 7644 7645 if value = 1 7646 then return (one); 7647 else return (create_constant (int_mode, unspec (value))); 7648 7649 end create_integer_constant; 7650 7651 index_value_analysis: 7652 procedure (); 7653 7654 /* index_value_analysis: 7655* 7656* determines which induction variables may be kept in an index register throughout a loop. 7657* To be eligible , an induction variable must not be busy_on_exit from a loop, must 7658* not be compared with anything unless we can determine its range, must not be assigned to 7659* an ineligible variable, and must not be used except as an offset or length, and in assignment 7660* or comparison contexts. 7661* 7662* This roiutine also sets ref_count_copy for temporary and array_ref nodes and computes loop.computed, 7663* a bit string identifying operators that compute their values within a loop. 7664* */ 7665 7666 dcl i fixed binary; 7667 7668 7669 do i = 1 to n_loops; 7670 call analyze_loop_index_values ((loop_vector (i)), i ^= n_loops); 7671 end; 7672 7673 return; 7674 7675 analyze_loop_index_values: 7676 procedure (p_lp, p_do_analysis); 7677 7678 dcl (p_lp, lp) pointer, /* -> loop to be analyzed */ 7679 (p_do_analysis, do_analysis) bit (1) aligned; 7680 7681 dcl ( 7682 fu, 7683 o, 7684 opnd (2), 7685 outp, 7686 p, 7687 stm 7688 ) pointer; 7689 dcl (i, op_code) fixed binary; 7690 dcl (ipol, next_statement, op, next_unit_statement) fixed binary (18); 7691 dcl int_image fixed binary (35) aligned based; 7692 dcl (assignment_list, comparison_list, eligible_ind_var_op_var_list, busy_on_exit_list) pointer; 7693 7694 /* INITIALIZE */ 7695 7696 lp = p_lp; 7697 do_analysis = p_do_analysis; 7698 assignment_list, comparison_list, eligible_ind_var_op_var_list, busy_on_exit_list = null; 7699 7700 /* Initialize loop.may_keep_in_xr with information from inner loops. 7701* We gather information about induction vars AND invariants to propagate 7702* upwards. Invariants may be kept in xrs despite context 7703* as long as context info is propagated upwards to loops where the vars 7704* may not be invariant. */ 7705 7706 if do_analysis 7707 then do; 7708 lp -> loop.may_keep_in_xr -> bits = 7709 lp -> loop.induction_var -> bits | (integer_scalar_mask & ^lp -> loop.set -> bits); 7710 7711 do p = lp -> loop.son repeat p -> loop.brother while (p ^= null); 7712 lp -> loop.may_keep_in_xr -> bits = 7713 lp -> loop.may_keep_in_xr -> bits & p -> loop.may_keep_in_xr -> bits; 7714 p -> loop.may_keep_in_xr -> bits = 7715 p -> loop.may_keep_in_xr -> bits | (integer_scalar_mask & ^p -> loop.set -> bits); 7716 lp -> loop.computed -> obits = lp -> loop.computed -> obits | p -> loop.computed -> obits; 7717 end; 7718 end; 7719 7720 else do p = lp -> loop.son repeat p -> loop.brother while (p ^= null); 7721 p -> loop.may_keep_in_xr -> bits = 7722 p -> loop.may_keep_in_xr -> bits | (integer_scalar_mask & ^p -> loop.set -> bits); 7723 end; 7724 7725 /* Process all operators immediately contained in this loop. */ 7726 7727 do fu = lp -> loop.members repeat fu -> flow_unit.next_in_loop while (fu ^= null); 7728 if fu -> flow_unit.next ^= null 7729 then next_unit_statement = fu -> flow_unit.next -> flow_unit.first_statement; 7730 else next_unit_statement = 0; 7731 7732 if fu -> flow_unit.first_statement ^= 0 7733 then do cur_statement = fu -> flow_unit.first_statement repeat next_statement 7734 while (cur_statement ^= next_unit_statement); 7735 stm = addr (quad (cur_statement)); 7736 next_statement = fixed (stm -> opt_statement.next, 18); 7737 7738 do op = stm -> opt_statement.first_operator repeat o -> operator.next 7739 while (op ^= next_statement); 7740 o = addr (quad (op)); 7741 op_code = o -> operator.op_code; 7742 7743 if o -> operator.output > 0 7744 then do; 7745 outp = addr (rands (o -> operator.output)); 7746 7747 if outp -> node.node_type = temporary_node | op_code = opt_subscript_op 7748 then outp -> temporary.ref_count_copy = outp -> temporary.ref_count; 7749 end; 7750 7751 if do_analysis 7752 then do; 7753 if o -> operator.coordinate > 0 7754 then substr (lp -> loop.computed -> obits, o -> operator.coordinate, 1) = "1"b; 7755 7756 go to case (xop_class (op_code)); 7757 7758 case (1): /* opt_subscript */ 7759 if o -> operand (3) > 0 7760 then do; 7761 if outp -> array_ref.large_offset 7762 then call disqualify (addr (rands (o -> operand (3)))); 7763 end; 7764 7765 go to case_end; 7766 7767 case (2): /* incrementing */ 7768 if o -> operator.number > 0 7769 then do; 7770 p = addr (rands (o -> operand (1))); 7771 7772 if p -> node.node_type ^= constant_node 7773 then if ^invariant (p) 7774 then call disqualify (p); 7775 else if eligible (outp) 7776 then do; 7777 call chain_it (o, eligible_ind_var_op_var_list); 7778 call check_busy_on_exit (outp); 7779 outp -> symbol.secondary = null; 7780 end; 7781 else call disqualify (p); 7782 7783 else if eligible (outp) 7784 then do; 7785 if op_code = neg_storage_add_op 7786 then p = addr ( 7787 rands ( 7788 create_integer_constant (-addr (p -> constant.value) -> int_image)) 7789 ); 7790 outp -> symbol.secondary = p; 7791 call check_busy_on_exit (outp); 7792 end; 7793 end; 7794 7795 else if eligible (outp) 7796 then do; 7797 outp -> symbol.secondary = onep; 7798 call check_busy_on_exit (outp); 7799 end; 7800 7801 go to case_end; 7802 7803 case (3): /* relational */ 7804 opnd (1) = addr (rands (o -> operand (1))); 7805 opnd (2) = addr (rands (o -> operand (2))); 7806 7807 do i = 1 to 2; 7808 if ^invariant (opnd (i)) 7809 then do; 7810 call disqualify (opnd (3 - i)); 7811 7812 if eligible (opnd (i)) 7813 then if invariant (opnd (3 - i)) 7814 then call chain_it (o, comparison_list); 7815 end; 7816 end; 7817 7818 go to case_end; 7819 7820 case (4): /* jump_arithmetic */ 7821 p = addr (rands (o -> operand (1))); 7822 7823 if eligible (p) 7824 then if ^invariant (p) 7825 then call chain_it (o, comparison_list); 7826 else call disqualify (p); 7827 7828 go to case_end; 7829 7830 case (5): /* assign */ 7831 p = addr (rands (o -> operand (1))); 7832 7833 if ^eligible (outp) 7834 then call disqualify (p); 7835 else do; 7836 if eligible (p) 7837 then do; 7838 call chain_it (o, assignment_list); 7839 call check_busy_on_exit (outp); 7840 end; 7841 outp -> symbol.secondary = null; 7842 end; 7843 7844 go to case_end; 7845 7846 case (6): /* write_namelist */ 7847 ipol = addr (rands (o -> operand (1))) -> symbol.initial; 7848 do i = 1 to polish (ipol); 7849 call disqualify (addr (rands (polish (ipol + i)))); 7850 end; 7851 7852 go to case_end; 7853 7854 case (7): /* most_operators */ 7855 call disqualify_inputs; 7856 go to case_end; 7857 7858 case (8): /* cat */ 7859 case_end: 7860 end; 7861 end; 7862 end; 7863 end; 7864 7865 /* process comparison and assignment lists */ 7866 7867 call process_assignment_list ("0"b); 7868 7869 call process_comparison_list; 7870 7871 call process_busy_on_exit_list; 7872 7873 call process_assignment_list ("1"b); 7874 7875 lp -> loop.eligible_ind_var_op_var = eligible_ind_var_op_var_list; 7876 7877 return; 7878 7879 invariant: 7880 procedure (p) returns (bit (1) aligned); 7881 7882 dcl p pointer; /* -> operand */ 7883 7884 dcl o pointer; 7885 7886 if p -> node.node_type = constant_node 7887 then return ("1"b); 7888 7889 else if p -> node.node_type = symbol_node 7890 then return (^substr (lp -> loop.set -> bits, p -> symbol.coordinate, 1)); 7891 7892 else if p -> node.node_type = temporary_node 7893 then do; 7894 o = addr (quad (p -> temporary.output_by)); 7895 if o -> operator.coordinate > 0 7896 then return (^substr (lp -> loop.computed -> obits, o -> operator.coordinate, 1)); 7897 end; 7898 7899 return ("0"b); 7900 7901 end invariant; 7902 7903 check_busy_on_exit: 7904 procedure (p); 7905 7906 dcl p pointer; /* -> induction variable */ 7907 7908 /* If p is busy_on_exit from lp, we have to chain it for later 7909* checking to see if it is non-negative so that it may be easily 7910* updated from an xreg. */ 7911 7912 if substr (lp -> loop.busy_on_exit -> bits, p -> symbol.coordinate, 1) 7913 then call chain_it (p, busy_on_exit_list); 7914 7915 end check_busy_on_exit; 7916 7917 eligible: 7918 procedure (p) returns (bit (1) aligned); 7919 7920 /* determines if an operand is eligible to be kept in an index register */ 7921 7922 dcl p pointer; /* -> operand */ 7923 7924 if p -> node.node_type = symbol_node 7925 then if p -> symbol.coordinate > 0 7926 then return (substr (lp -> loop.may_keep_in_xr -> bits, p -> symbol.coordinate, 1)); 7927 7928 return ("0"b); 7929 7930 end eligible; 7931 7932 disqualify_inputs: 7933 procedure (); 7934 7935 dcl (i, opnd) fixed binary; 7936 7937 do i = 1 to o -> operator.number; 7938 opnd = o -> operand (i); 7939 if opnd > 0 7940 then call disqualify (addr (rands (opnd))); 7941 end; 7942 7943 end disqualify_inputs; 7944 7945 disqualify: 7946 procedure (p); 7947 7948 /* Makes an operand ineligible to be kept in an index register */ 7949 7950 dcl p pointer; /* -> operand */ 7951 7952 if p -> node.node_type = symbol_node 7953 then if p -> symbol.coordinate > 0 7954 then substr (lp -> loop.may_keep_in_xr -> bits, p -> symbol.coordinate, 1) = "0"b; 7955 7956 end disqualify; 7957 7958 chain_it: 7959 procedure (o, list_head); 7960 7961 dcl o pointer, /* -> item to be chained */ 7962 list_head pointer; /* head of chain */ 7963 7964 dcl c pointer; 7965 7966 c = create_chain (); 7967 c -> chain.value = o; 7968 c -> chain.next = list_head; 7969 list_head = c; 7970 7971 end chain_it; 7972 7973 process_comparison_list: 7974 procedure (); 7975 7976 /* Attempts to get range information for all comparisons on the list. */ 7977 7978 dcl (bt, c, exit_c, exit_fu, last_c, orig_o, p, prev_fu, r) pointer; 7979 dcl op_code fixed binary; 7980 dcl have_eligible_variable bit (1) aligned; 7981 dcl which fixed binary; 7982 7983 dcl 1 range_bits automatic like range.range_bits unaligned; 7984 7985 dcl max_integer fixed binary (35) internal static initial (011111111111111111111111111111111111b); 7986 7987 bt = lp -> loop.back_target; 7988 last_c = null; 7989 7990 do c = comparison_list repeat c -> chain.next while (c ^= null); 7991 last_c = c; 7992 orig_o = c -> chain.value; 7993 op_code = orig_o -> operator.op_code; 7994 7995 p = addr (rands (orig_o -> operand (1))); 7996 which = 1; 7997 have_eligible_variable = eligible (p); 7998 7999 if ^have_eligible_variable & orig_o -> operator.op_code ^= jump_arithmetic_op 8000 then do; 8001 p = addr (rands (orig_o -> operand (2))); 8002 which = 2; 8003 have_eligible_variable = eligible (p); 8004 end; 8005 8006 if have_eligible_variable 8007 then do; 8008 string (range_bits) = try_to_calculate_range (p); 8009 8010 if string (range_bits) 8011 then do; 8012 r = find_range (p, lp, "1"b); 8013 string (r -> range.bits) = string (r -> range.bits) & string (range_bits); 8014 8015 if string (r -> range.bits) = "0"b | (op_code = jump_arithmetic_op & ^r -> range.fb17) 8016 then call disqualify (p); 8017 else if op_code ^= jump_arithmetic_op 8018 then if addr (rands (orig_o -> operand (3 - which))) -> node.node_type ^= constant_node 8019 then call chain_it (orig_o, eligible_ind_var_op_var_list); 8020 end; 8021 8022 else call disqualify (p); 8023 end; 8024 end; 8025 8026 if last_c ^= null 8027 then do; 8028 last_c -> chain.next = free (size (chain)); 8029 free (size (chain)) = comparison_list; 8030 end; 8031 8032 return; 8033 8034 /* Attempts to get range info for those vars busy_on_exit from the loop. */ 8035 8036 process_busy_on_exit_list: 8037 entry; 8038 8039 bt = lp -> loop.back_target; 8040 last_c = null; 8041 op_code = 0; 8042 8043 do c = busy_on_exit_list repeat c -> chain.next while (c ^= null); 8044 last_c = c; 8045 p = c -> chain.value; 8046 8047 if eligible (p) 8048 then do; 8049 r = find_range (p, lp, "1"b); 8050 8051 prev_fu = null; 8052 8053 do exit_c = lp -> loop.exits repeat exit_c -> chain.next while (exit_c ^= null & r -> range.fb18_uns); 8054 exit_fu = exit_c -> chain.value -> edge.from.value; 8055 8056 if exit_fu ^= prev_fu 8057 then do; 8058 prev_fu = exit_fu; 8059 call derive_insert_for_bt (exit_fu); 8060 orig_o = addr (quad (exit_fu -> flow_unit.insert_operator)); 8061 8062 string (range_bits) = try_to_calculate_range (p); 8063 8064 string (r -> range.bits) = string (r -> range.bits) & string (range_bits); 8065 end; 8066 end; 8067 8068 if ^r -> range.fb18_uns 8069 then call disqualify (p); 8070 end; 8071 end; 8072 8073 if last_c ^= null 8074 then do; 8075 last_c -> chain.next = free (size (chain)); 8076 free (size (chain)) = busy_on_exit_list; 8077 end; 8078 8079 return; 8080 8081 try_to_calculate_range: 8082 procedure (pt) returns (bit (2) aligned); 8083 8084 dcl (p, pt) pointer; /* -> var whose range is being calculated */ 8085 8086 dcl ac pointer; 8087 dcl var fixed binary (18); 8088 8089 dcl 1 range_bits automatic like range.range_bits unaligned; 8090 8091 p = pt; 8092 8093 string (range_bits) = calculate_range_by_subscripts (p); 8094 8095 /* if we haven't found a range, use vars we assign to or from */ 8096 8097 var = fixed (rel (p), 18); 8098 8099 do ac = assignment_list repeat ac -> chain.next while (string (range_bits) = "0"b & ac ^= null); 8100 if ac -> chain.value -> operand (1) = var 8101 then string (range_bits) = 8102 calculate_range_by_subscripts (addr (rands (ac -> chain.value -> operator.output))); 8103 8104 else if ac -> chain.value -> operator.output = var 8105 then string (range_bits) = 8106 calculate_range_by_subscripts (addr (rands (ac -> chain.value -> operator.operand (1)))); 8107 end; 8108 8109 /* If we still haven't found a range, see if we are in 8110* lock step with another induction variable whose range 8111* is knowable. */ 8112 8113 if string (range_bits) = "00"b 8114 then string (range_bits) = calculate_range_for_counter (p); 8115 8116 return (string (range_bits)); 8117 8118 end try_to_calculate_range; 8119 8120 calculate_range_by_subscripts: 8121 procedure (pt) returns (bit (2) aligned); 8122 8123 dcl (p, pt) pointer; /* var whose range is being calculated */ 8124 8125 dcl 1 range_bits automatic like range.range_bits unaligned; 8126 dcl (fu, o, s) pointer; 8127 dcl (first_statement, op, n, var) fixed binary (18); 8128 dcl (upper_bound, lower_bound, increment) fixed binary (35); 8129 dcl constant_offset fixed binary (24); 8130 dcl max_size fixed binary (24); 8131 8132 /* This code attempts to calculate a variable's range by assuming 8133* that an array or string must not be referenced outside its 8134* generation of storage, i.e., subscriptrange, stringrange, and 8135* stringsize must not occur! */ 8136 8137 p = pt; 8138 o = orig_o; 8139 8140 upper_bound = max_integer; 8141 lower_bound = -upper_bound; 8142 8143 if p -> symbol.secondary ^= null 8144 then do; 8145 increment = addr (p -> symbol.secondary -> constant.value) -> int_image; 8146 var = fixed (rel (p), 18); 8147 8148 do fu = null repeat fu -> flow_unit.dominator while (fu ^= bt); 8149 if fu ^= null 8150 then do; 8151 first_statement = fu -> flow_unit.first_statement; 8152 op = fu -> flow_unit.next -> flow_unit.first_statement; 8153 o = addr (quad (op)); 8154 end; 8155 else first_statement = 0; 8156 8157 do op = o -> operator.back repeat o -> operator.back while (op ^= first_statement); 8158 o = addr (quad (op)); 8159 n = o -> operator.number; 8160 8161 if o -> operator.op_code = stat_op 8162 then if fu = null 8163 then do; 8164 fu = o -> opt_statement.flow_unit; 8165 first_statement = fu -> flow_unit.first_statement; 8166 if op = first_statement 8167 then o = addr (quad (o -> operator.next)); 8168 end; 8169 else ; 8170 8171 else if o -> operator.op_code = opt_subscript_op 8172 then do; 8173 s = addr (rands (o -> operand (1))); 8174 8175 if n >= 4 8176 then if o -> operand (4) = var 8177 then do; 8178 lower_bound = max (lower_bound, 1); 8179 if ^s -> symbol.variable_extents 8180 then max_size = s -> symbol.char_size + 1; 8181 else max_size = max_char_length; 8182 upper_bound = min (upper_bound, max_size); 8183 end; 8184 8185 if o -> operand (3) = var 8186 then do; 8187 constant_offset = 8188 addr (addr (rands (o -> operand (2))) -> constant.value) -> int_image; 8189 8190 lower_bound = max (lower_bound, min (increment, 0) - constant_offset); 8191 8192 max_size = get_max_size (s); 8193 8194 upper_bound = min (upper_bound, max_size - constant_offset + max (increment, 0) - 1); 8195 end; 8196 end; 8197 8198 else if o -> operator.op_code = cat_op 8199 then if o -> operand (n) = var 8200 then do; 8201 lower_bound = max (lower_bound, 1); 8202 upper_bound = min (upper_bound, max_char_length); 8203 end; 8204 end; 8205 end; 8206 end; 8207 8208 string (range_bits) = "0"b; 8209 if lower_bound >= -131072 & upper_bound < 131072 8210 then range_bits.fb17 = "1"b; 8211 if lower_bound >= 0 & upper_bound < 262144 8212 then range_bits.fb18_uns = "1"b; 8213 8214 return (string (range_bits)); 8215 8216 end calculate_range_by_subscripts; 8217 8218 get_max_size: 8219 procedure (s) returns (fixed binary (24)); 8220 8221 dcl s pointer; /* -> symbol node */ 8222 8223 dcl sys_info$max_seg_size fixed bin (18) ext; 8224 8225 dcl d pointer; 8226 dcl max_chars fixed bin (21); 8227 dcl max_words fixed bin (24); 8228 dcl max_size fixed binary (24); 8229 8230 /* returns maximum size of an array */ 8231 8232 max_chars = sys_info$max_seg_size * chars_per_word; 8233 if s -> symbol.VLA 8234 then max_words = max_fixed_bin_24; 8235 else max_words = sys_info$max_seg_size; 8236 8237 if s -> symbol.dimension > 0 8238 then do; 8239 d = addr (rands (s -> symbol.dimension)); 8240 8241 if s -> symbol.variable_extents | s -> symbol.star_extents 8242 | (s -> symbol.parameter & d -> dimension.element_count <= 1) 8243 then if s -> symbol.units = char_units 8244 then max_size = max_chars; 8245 else max_size = max_words; 8246 else max_size = d -> dimension.array_size; 8247 end; 8248 8249 else if s -> symbol.variable_extents 8250 then if s -> symbol.units = char_units 8251 then max_size = max_chars; 8252 else max_size = max_words; 8253 else max_size = s -> symbol.element_size; 8254 8255 return (max_size); 8256 8257 end get_max_size; 8258 8259 calculate_range_for_counter: 8260 procedure (pt) returns (bit (2) aligned); 8261 8262 dcl (p, pt) pointer; /* var whose range is being calculated */ 8263 8264 dcl 1 range_bits automatic like range.range_bits unaligned; 8265 8266 dcl (c, const_p, fu, last_c, o, s, u) pointer; 8267 dcl (first_statement, op, var) fixed binary (18); 8268 dcl (upper_bound, lower_bound, bound) fixed binary (35); 8269 dcl (starting_value, other_value) fixed binary (35); 8270 dcl found bit (1) aligned; 8271 dcl (opt_subscript_chain, update_chain) pointer; 8272 dcl (increment, other_increment) fixed binary (18); 8273 8274 /* This code hopes that our variable is in lock step with another 8275* variable that is referencing a string or array. If so, and if 8276* our starting value is known, we can deduce a maximum number 8277* of iterations for our variable and thus figure out the other 8278* bound. If our comparand is constant, and the op_code is proper, 8279* the job is even easier. */ 8280 8281 p = pt; 8282 string (range_bits) = "0"b; 8283 8284 if p -> symbol.secondary ^= null 8285 then do; 8286 increment = addr (p -> symbol.secondary -> constant.value) -> int_image; 8287 call get_starting_value (p, starting_value, found); 8288 8289 if found 8290 then do; 8291 if increment > 0 8292 then do; 8293 upper_bound = max_integer; 8294 lower_bound = starting_value; 8295 end; 8296 else do; 8297 upper_bound = starting_value; 8298 lower_bound = -max_integer; 8299 end; 8300 8301 /* If comparand is constant, we can deduce range quickly. 8302* We assume the bottom of a do-loop ends with a jump_false_op. */ 8303 8304 if op_code ^= 0 & op_code ^= jump_arithmetic_op 8305 then if addr (rands (orig_o -> operand (3 - which))) -> node.node_type = constant_node 8306 then if is_suitable_loop_exit (orig_o, p, lp) 8307 then do; 8308 other_value = 8309 addr (addr (rands (orig_o -> operand (3 - which))) -> constant.value) 8310 -> int_image; 8311 if increment > 0 & op_code = greater_op 8312 then upper_bound = max (other_value + increment, lower_bound); 8313 else if increment < 0 & op_code = less_op 8314 then lower_bound = min (other_value + increment, upper_bound); 8315 end; 8316 8317 if upper_bound = max_integer | lower_bound = -max_integer 8318 then do; 8319 8320 /* We have to do it the hard way. */ 8321 8322 opt_subscript_chain, update_chain = null; 8323 o = orig_o; 8324 8325 do fu = null repeat fu -> flow_unit.dominator while (fu ^= bt); 8326 if fu ^= null 8327 then do; 8328 first_statement = fu -> flow_unit.first_statement; 8329 op = fu -> flow_unit.next -> flow_unit.first_statement; 8330 o = addr (quad (op)); 8331 end; 8332 else first_statement = 0; 8333 8334 do op = o -> operator.back repeat o -> operator.back while (op ^= first_statement); 8335 o = addr (quad (op)); 8336 8337 if o -> operator.op_code = stat_op 8338 then if fu = null 8339 then do; 8340 fu = o -> opt_statement.flow_unit; 8341 first_statement = fu -> flow_unit.first_statement; 8342 if op = first_statement 8343 then o = addr (quad (o -> operator.next)); 8344 end; 8345 else ; 8346 8347 else if o -> operator.op_code = opt_subscript_op 8348 then if o -> operand (3) > 0 8349 then do; 8350 s = addr (rands (o -> operand (3))); 8351 if s -> node.node_type = symbol_node 8352 then if substr (lp -> loop.induction_var -> bits, s -> symbol.coordinate, 1) 8353 then call chain_it (o, opt_subscript_chain); 8354 end; 8355 else ; 8356 8357 else if o -> operator.output > 0 8358 then do; 8359 s = addr (rands (o -> operator.output)); 8360 if s -> node.node_type = symbol_node 8361 then if substr (lp -> loop.induction_var -> bits, s -> symbol.coordinate, 1) 8362 then call chain_it (o, update_chain); 8363 end; 8364 end; 8365 end; 8366 8367 /* Process opt_subscript_chain. */ 8368 8369 last_c = null; 8370 do c = opt_subscript_chain repeat c -> chain.next while (c ^= null); 8371 last_c = c; 8372 o = c -> chain.value; 8373 var = o -> operand (3); 8374 found = "0"b; 8375 8376 do u = update_chain repeat u -> chain.next while (^found & u ^= null); 8377 if u -> chain.value -> operator.output = var 8378 then found = "1"b; 8379 end; 8380 8381 if found 8382 then do; 8383 const_p = addr (rands (var)) -> symbol.secondary; 8384 if const_p ^= null 8385 then other_increment = abs (addr (const_p -> constant.value) -> int_image); 8386 else other_increment = 1; 8387 8388 bound = starting_value 8389 + increment 8390 * 8391 divide (get_max_size (addr (rands (o -> operand (1)))) + other_increment - 1, 8392 other_increment, 24, 0); 8393 8394 if increment > 0 8395 then upper_bound = min (upper_bound, bound); 8396 else lower_bound = max (lower_bound, bound); 8397 end; 8398 end; 8399 8400 if last_c ^= null 8401 then do; 8402 last_c -> chain.next = free (size (chain)); 8403 free (size (chain)) = opt_subscript_chain; 8404 end; 8405 8406 last_c = null; 8407 do c = update_chain repeat c -> chain.next while (c ^= null); 8408 last_c = c; 8409 end; 8410 8411 if last_c ^= null 8412 then do; 8413 last_c -> chain.next = free (size (chain)); 8414 free (size (chain)) = update_chain; 8415 end; 8416 end; 8417 8418 if lower_bound >= -131072 & upper_bound < 131072 8419 then range_bits.fb17 = "1"b; 8420 if lower_bound >= 0 & upper_bound < 262144 8421 then range_bits.fb18_uns = "1"b; 8422 end; 8423 end; 8424 8425 return (string (range_bits)); 8426 8427 end calculate_range_for_counter; 8428 8429 get_starting_value: 8430 procedure (pt, starting_value, found); 8431 8432 dcl (p, pt) pointer, /* var whose starting value is needed */ 8433 starting_value fixed binary (35), /* answer (output) */ 8434 found bit (1) aligned; /* "1"b - starting value is valid (output) */ 8435 8436 dcl (first_statement, i, op, var) fixed binary (18); 8437 dcl o pointer; 8438 dcl in_common bit (1) aligned; 8439 8440 /* Looks for starting value of an induction variable. We only search back target. */ 8441 8442 p = pt; 8443 found = "0"b; 8444 8445 if substr (bt -> flow_unit.set -> bits, p -> symbol.coordinate, 1) 8446 then do; 8447 var = fixed (rel (p), 18); 8448 in_common = p -> symbol.in_common; 8449 8450 /* refresh insert_operator field */ 8451 8452 call derive_insert_for_bt (bt); 8453 8454 /* Loop back through operators looking for an assignment to var. */ 8455 8456 first_statement = bt -> flow_unit.first_statement; 8457 8458 do op = bt -> flow_unit.insert_operator repeat o -> operator.back while (op ^= first_statement); 8459 o = addr (quad (op)); 8460 8461 if o -> operator.op_code = read_namelist_op 8462 then if in_namelist (o, var) 8463 then return; 8464 else ; 8465 8466 else if o -> operator.op_code = call_op | o -> operator.op_code = func_ref_op 8467 then do; 8468 if in_common | o -> operator.output = var 8469 then return; 8470 8471 do i = 1 to o -> operator.number; 8472 if o -> operand (i) = var 8473 then return; 8474 end; 8475 end; 8476 8477 else if o -> operator.output = var 8478 then do; 8479 if o -> operator.op_code = assign_op 8480 then if addr (rands (o -> operand (1))) -> node.node_type = constant_node 8481 then do; 8482 starting_value = addr (addr (rands (o -> operand (1))) -> constant.value) -> int_image; 8483 found = "1"b; 8484 end; 8485 return; 8486 end; 8487 end; 8488 end; 8489 8490 end get_starting_value; 8491 8492 is_suitable_loop_exit: 8493 procedure (p_o, var_p, p_lp) returns (bit (1) aligned); 8494 8495 dcl (orig_o, p_o) pointer, /* -> relational op that may be input to 8496* a jump_false_op whose fall_through 8497* exits the loop */ 8498 var_p pointer, /* induction variable */ 8499 (lp, p_lp) pointer; /* loop */ 8500 8501 dcl (fu, inp, jop, lab, o, outp, stm) pointer; 8502 dcl (first_statement, op, var) fixed binary (18); 8503 dcl found bit (1) aligned; 8504 8505 /* Sees if the relational op that we are looking at is an 8506* input to a jump_false_op whose fall_through exits the loop, 8507* whose target is within the loop, and which must be 8508* executed when the induction variable is updated. */ 8509 8510 orig_o = p_o; 8511 lp = p_lp; 8512 8513 /* The update of the induction variable must be in the same 8514* flow_unit as that of the test so that the test is not 8515* bypassed whenever the variable is updated. */ 8516 8517 var = fixed (rel (var_p), 18); 8518 fu = null; 8519 first_statement = 0; 8520 found = "0"b; 8521 8522 do op = orig_o -> operator.back repeat o -> operator.back while (^found & op ^= first_statement | fu = null); 8523 o = addr (quad (op)); 8524 8525 if o -> operator.op_code = stat_op 8526 then if fu = null 8527 then do; 8528 fu = o -> opt_statement.flow_unit; 8529 first_statement = fu -> flow_unit.first_statement; 8530 if op = first_statement 8531 then o = addr (quad (o -> operator.next)); 8532 end; 8533 else ; 8534 8535 else if o -> operator.output = var 8536 then found = "1"b; 8537 end; 8538 8539 if ^found 8540 then return ("0"b); 8541 8542 /* Examine all operators that orig_o is input to */ 8543 8544 outp = addr (rands (orig_o -> operator.output)); 8545 do inp = addr (polish (outp -> temporary.start_input_to)) repeat inp -> input_to.next while (inp ^= null); 8546 if inp -> input_to.which > 0 8547 then do; 8548 jop = inp -> input_to.operator; 8549 8550 /* op_code for bottom of a do_loop is jump_false_op */ 8551 if jop -> operator.op_code ^= jump_false_op 8552 then return ("0"b); 8553 8554 /* target must be within loop */ 8555 8556 lab = addr (rands (jop -> operand (2))); 8557 stm = addr (quad (lab -> label.statement)); 8558 if stm -> opt_statement.flow_unit -> flow_unit.loop ^= lp 8559 then return ("0"b); 8560 8561 /* fall_through must exit the loop */ 8562 8563 if fu -> flow_unit.next -> flow_unit.loop -> loop.depth >= lp -> loop.depth 8564 then return ("0"b); 8565 end; 8566 end; 8567 8568 return ("1"b); 8569 8570 end is_suitable_loop_exit; 8571 8572 end process_comparison_list; 8573 8574 find_range: 8575 procedure (pt, plp, create_it) returns (pointer); 8576 8577 /* Finds range data for a variable or, optionally, creates the data */ 8578 8579 dcl (p, pt) pointer, /* -> symbol whose range data is needed */ 8580 (lp, plp) pointer, /* -> loop whose list is searched */ 8581 create_it bit (1) aligned; 8582 8583 dcl r pointer; 8584 8585 p = pt; 8586 lp = plp; 8587 8588 do r = lp -> loop.range_list repeat r -> range.next while (r ^= null); 8589 if r -> range.variable = p 8590 then return (r); 8591 end; 8592 8593 if create_it 8594 then do; 8595 r = create_range (p, lp); 8596 string (r -> range.bits) = "11"b; 8597 end; 8598 8599 return (r); 8600 8601 end find_range; 8602 8603 create_range: 8604 procedure (p, lp) returns (pointer); 8605 8606 dcl p pointer, /* -> symbol for whom a range node is being created */ 8607 lp pointer; /* -> loop whose list is being added to */ 8608 8609 dcl r pointer; 8610 8611 r = get_opt_space (size (range)); 8612 r -> range.variable = p; 8613 r -> range.next = lp -> loop.range_list; 8614 lp -> loop.range_list = r; 8615 8616 return (r); 8617 8618 end create_range; 8619 8620 process_assignment_list: 8621 procedure (free_assignment_list); 8622 8623 /* eligible vars may only assign to eligible vars */ 8624 8625 dcl free_assignment_list bit (1) aligned; 8626 8627 dcl (c, inp, last_c, next_c, o, outp, rin, rout) pointer; 8628 dcl change_occurred bit (1) aligned; 8629 8630 change_occurred = "1"b; 8631 8632 do while (change_occurred); 8633 change_occurred = "0"b; 8634 last_c = null; 8635 8636 do c = assignment_list repeat next_c while (c ^= null); 8637 next_c = c -> chain.next; 8638 o = c -> chain.value; 8639 inp = addr (rands (o -> operand (1))); 8640 outp = addr (rands (o -> operator.output)); 8641 8642 if ^eligible (inp) 8643 then call remove (c, last_c); 8644 8645 else if ^eligible (outp) 8646 then do; 8647 call remove (c, last_c); 8648 substr (lp -> loop.may_keep_in_xr -> bits, inp -> symbol.coordinate, 1) = "0"b; 8649 change_occurred = "1"b; 8650 end; 8651 8652 else do; 8653 last_c = c; 8654 8655 /* propagate range information */ 8656 8657 rout = find_range (outp, lp, "0"b); 8658 if rout ^= null 8659 then do; 8660 rin = find_range (inp, lp, "0"b); 8661 if rin = null 8662 then do; 8663 change_occurred = "1"b; 8664 rin = create_range (inp, lp); 8665 string (rin -> range.bits) = string (rout -> range.bits); 8666 end; 8667 end; 8668 8669 /* propagate increment information */ 8670 8671 if outp -> symbol.secondary = null & inp -> symbol.secondary ^= null 8672 then do; 8673 outp -> symbol.secondary = inp -> symbol.secondary; 8674 change_occurred = "1"b; 8675 end; 8676 end; 8677 end; 8678 end; 8679 8680 if free_assignment_list & last_c ^= null 8681 then do; 8682 last_c -> chain.next = free (size (chain)); 8683 free (size (chain)) = assignment_list; 8684 end; 8685 8686 return; 8687 8688 remove: 8689 procedure (c, last_c); 8690 8691 dcl c pointer, /* assignment list item being removed */ 8692 last_c pointer; /* previous list item */ 8693 8694 if last_c ^= null 8695 then last_c -> chain.next = c -> chain.next; 8696 else assignment_list = c -> chain.next; 8697 8698 c -> chain.next = free (size (chain)); 8699 free (size (chain)) = c; 8700 8701 end remove; 8702 8703 end process_assignment_list; 8704 8705 end analyze_loop_index_values; 8706 8707 end index_value_analysis; 8708 7 1 /* BEGIN fort_opt_utilities.incl.pl1 */ 7 2 7 3 /* Created: December 18, 1979 by Richard A. Barnes for register optimizer. */ 7 4 7 5 get_opt_space: proc(nwords) returns(ptr); 7 6 7 7 dcl nwords fixed bin(18); /* size of allocation */ 7 8 7 9 dcl p ptr; 7 10 7 11 /* allocates all space for fort_optimizer */ 7 12 7 13 retry: 7 14 p = addr(opt(next_free_opt)); 7 15 7 16 next_free_opt = next_free_opt + nwords; 7 17 7 18 if next_free_opt < opt_max_len 7 19 then return(p); 7 20 7 21 else do; 7 22 opt_base = get_next_temp_segment(shared_globals.opt_base,next_free_opt); 7 23 go to retry; 7 24 end; 7 25 7 26 end /* get_opt_space */; 7 27 7 28 create_chain: proc() returns(ptr); 7 29 7 30 dcl p ptr; 7 31 7 32 /* allocates chain nodes */ 7 33 7 34 if free(size(chain)) = null 7 35 then return(get_opt_space(size(chain))); 7 36 else do; 7 37 p = free(size(chain)); 7 38 free(size(chain)) = free(size(chain)) -> chain.next; 7 39 return(p); 7 40 end; 7 41 7 42 end /* create_chain */; 7 43 7 44 get_quad_space: proc(amt) returns(fixed bin(18)); 7 45 7 46 dcl amt fixed bin(18); /* amount to allocate */ 7 47 7 48 dcl place fixed bin(18); 7 49 7 50 place = next_free_quad; 7 51 next_free_quad = next_free_quad + amt; 7 52 if next_free_quad >= quad_max_len 7 53 then do; 7 54 call print_message(414,"The quadruple region",ltrim(char(quad_max_len))); 7 55 return(0); 7 56 end; 7 57 7 58 return(place); 7 59 7 60 end /* get_quad_space */; 7 61 7 62 chain_input: proc(p,o,i); 7 63 7 64 /* adds o to p's input list */ 7 65 7 66 dcl p ptr, /* ptr to temporary or array_ref that is input */ 7 67 o ptr, /* ptr to operator that p is input to */ 7 68 i fixed bin(18); /* which operand */ 7 69 7 70 dcl qoff fixed bin(18); 7 71 dcl (q,last) ptr; 7 72 7 73 q = create_input_to(); 7 74 7 75 q -> input_to.next = null; 7 76 q -> input_to.operator = o; 7 77 q -> input_to.which = i; 7 78 qoff = fixed(rel(q),18); 7 79 if p -> temporary.end_input_to = 0 7 80 then p -> temporary.start_input_to = qoff; 7 81 else do; 7 82 last = addr(polish(p -> temporary.end_input_to)); 7 83 last -> input_to.next = q; 7 84 end; 7 85 p -> temporary.end_input_to = qoff; 7 86 7 87 end /* chain_input */; 7 88 7 89 7 90 create_input_to: proc() returns(ptr); 7 91 7 92 dcl q ptr; 7 93 7 94 if freei = null 7 95 then q = get_polish_space(size(input_to)); 7 96 else do; 7 97 q = freei; 7 98 freei = freei -> input_to.next; 7 99 end; 7 100 7 101 return(q); 7 102 7 103 end /* create_input_to */; 7 104 7 105 7 106 get_polish_space: proc(nwords) returns(ptr); 7 107 7 108 dcl nwords fixed bin(18); /* size of allocation */ 7 109 7 110 dcl p ptr; 7 111 7 112 /* allocates polish space for input_to nodes */ 7 113 7 114 p = addr(polish(next_free_polish)); 7 115 7 116 next_free_polish = next_free_polish + nwords; 7 117 7 118 if next_free_polish < polish_max_len 7 119 then return(p); 7 120 7 121 else do; 7 122 call print_message(414,"The polish region",ltrim(char(polish_max_len))); 7 123 return(null); 7 124 end; 7 125 7 126 end /* get_polish_space */; 7 127 7 128 /* derives insert_* fields in back target */ 7 129 7 130 derive_insert_for_bt: proc(bt); 7 131 7 132 dcl bt ptr; /* -> back target */ 7 133 7 134 dcl (bt_statement, next_statement) fixed bin(18); 7 135 dcl (o, btst) ptr; 7 136 7 137 bt_statement = bt -> flow_unit.last_statement; 7 138 btst = addr(quad(bt_statement)); 7 139 o = addr(quad(btst -> opt_statement.first_operator)); 7 140 7 141 if o -> operator.op_code = jump_op 7 142 then do; 7 143 bt -> flow_unit.insert_statement = fixed(btst -> opt_statement.back, 18); 7 144 bt -> flow_unit.insert_operator = btst -> opt_statement.prev_operator; 7 145 end; 7 146 else do; 7 147 bt -> flow_unit.insert_statement = bt_statement; 7 148 next_statement = fixed(btst -> opt_statement.next, 18); 7 149 bt -> flow_unit.insert_operator = addr(quad(next_statement)) -> opt_statement.prev_operator; 7 150 end; 7 151 7 152 end /* derive_insert_for_bt */; 7 153 7 154 /* unthreads operator nodes. The operator to be unthreaded must not be the first or last operator in a chain. */ 7 155 7 156 unthread: proc(o); 7 157 7 158 dcl (o,nextp,backp) ptr; 7 159 7 160 dcl nullx fixed bin(18) int static options(constant) init(262142); 7 161 7 162 if o -> operator.next = nullx /* if already unthreaded, don't bother. */ 7 163 then return; 7 164 7 165 nextp = addr(quad(o -> operator.next)); 7 166 backp = addr(quad(o -> operator.back)); 7 167 nextp -> operator.back = o -> operator.back; 7 168 backp -> operator.next = o -> operator.next; 7 169 7 170 /* Make sure nobody uses the threading words again. An invalid use will cause a fault. */ 7 171 7 172 o -> operator.next, 7 173 o -> operator.back = nullx; 7 174 7 175 end /* unthread */ ; 7 176 7 177 put_in_loop_end: proc(pt,lp); 7 178 7 179 dcl (p, pt) ptr, /* -> temp to be put in loop end chain */ 7 180 lp ptr; /* -> loop in whose chain temp is to be inserted */ 7 181 7 182 dcl fu_to_put ptr; /* -> flow_unit in whose chain temp is to be inserted */ 7 183 7 184 dcl c ptr; 7 185 7 186 p = pt; 7 187 fu_to_put = lp -> loop.last_unit; 7 188 7 189 /* add to loop end chain */ 7 190 7 191 c = create_chain(); 7 192 c -> lchain.next = fu_to_put -> flow_unit.loop_end_chain; 7 193 c -> lchain.value = fixed(rel(p),18); 7 194 fu_to_put -> flow_unit.loop_end_chain = c; 7 195 fu_to_put -> flow_unit.n_in_loop_end = fu_to_put -> flow_unit.n_in_loop_end + 1; 7 196 7 197 /* increment the reference count */ 7 198 7 199 p -> temporary.ref_count = p -> temporary.ref_count + 1; 7 200 7 201 /* add an input item for this operand */ 7 202 7 203 call chain_input(p,c,-1); 7 204 7 205 p -> temporary.loop_end_fu_pos = fu_to_put -> flow_unit.position; 7 206 7 207 end /* put_in_loop_end */; 7 208 7 209 connect_expression: proc(opnd,op,p_which); 7 210 7 211 dcl opnd fixed bin(18), /* operand to be connectged to op */ 7 212 op fixed bin(18), /* operator to which opnd becomes an operand */ 7 213 (p_which,which) fixed bin(18); /* operand number that opnd becomes */ 7 214 7 215 7 216 dcl (o, p) ptr; 7 217 7 218 which = p_which; 7 219 7 220 o = addr(quad(op)); 7 221 o -> operator.operand(which) = opnd; 7 222 p = addr(rands(opnd)); 7 223 7 224 if p -> node.node_type = array_ref_node 7 225 | p -> node.node_type = temporary_node 7 226 then do; 7 227 p -> temporary.ref_count = p -> temporary.ref_count + 1; 7 228 p -> temporary.ref_count_copy = p -> temporary.ref_count_copy + 1; 7 229 call chain_input(p,o,which); 7 230 end; 7 231 7 232 end /* connect_expression */; 7 233 7 234 7 235 7 236 disconnect_temporary: proc(pt,p_o); 7 237 7 238 dcl (p,pt) ptr, /* ptr to temp being disconnected */ 7 239 (o,p_o) ptr; /* ptr to operator from which p is disconnected */ 7 240 7 241 dcl (inp,last) ptr; 7 242 dcl found bit(1) aligned; 7 243 7 244 p = pt; 7 245 o = p_o; 7 246 7 247 last = null; 7 248 found = "0"b; 7 249 inp = addr(polish(p -> temporary.start_input_to)); 7 250 7 251 do while(^ found & inp ^= null); 7 252 if inp -> input_to.operator = o 7 253 then found = "1"b; 7 254 else do; 7 255 last = inp; 7 256 inp = inp -> input_to.next; 7 257 end; 7 258 end; 7 259 7 260 if ^ found 7 261 then do; 7 262 call print_message(386); 7 263 return; 7 264 end; 7 265 7 266 if last ^= null 7 267 then do; 7 268 last -> input_to.next = inp -> input_to.next; 7 269 if inp -> input_to.next = null 7 270 then p -> temporary.end_input_to = fixed(rel(last),18); 7 271 end; 7 272 7 273 else if inp -> input_to.next = null 7 274 then p -> temporary.start_input_to, p -> temporary.end_input_to = 0; 7 275 else p -> temporary.start_input_to = fixed(rel(inp -> input_to.next),18); 7 276 7 277 p -> temporary.ref_count = p -> temporary.ref_count - 1; 7 278 p -> temporary.ref_count_copy = p -> temporary.ref_count_copy - 1; 7 279 7 280 end /* disconnect_temporary */; 7 281 7 282 in_namelist: proc(o,variable) returns(bit(1) aligned); 7 283 7 284 dcl o ptr, /* -> to {read|write}_namelist operator */ 7 285 variable fixed bin(18); /* variable being searched for */ 7 286 7 287 dcl (var,i,ipol) fixed bin(18); 7 288 7 289 var = variable; 7 290 ipol = addr(rands(o -> operator.operand(1))) -> symbol.initial; 7 291 7 292 do i = 1 to polish(ipol); 7 293 if polish(ipol+i) = variable 7 294 then return("1"b); 7 295 end; 7 296 7 297 return("0"b); 7 298 7 299 end /* in_namelist */; 7 300 7 301 /* END fort_opt_utilities.incl.pl1 */ 8709 8710 8 1 /* BEGIN fort_utilities.incl.pl1 */ 8 2 8 3 /* Created: October 1977, Richard Barnes 8 4* 8 5* Modified: 8 6* 22 May 1978, DSL - add create_constant. 8 7* 09 Oct 1978, PES - make create_(constant node) return fixed bin(18) unsigned. 8 8* 13 Dec 1978, PES - Get create_node from include file, rather than copy. 8 9**/ 8 10 9 1 /* BEGIN fort_create_node.incl.pl1 */ 9 2 9 3 /* Created: October 1977, Richard Barnes 9 4* 9 5* Modified: 9 6* 22 May 1978, DSL - add create_constant. 9 7* 09 Oct 1978, PES - make create_(constant node) return fixed bin(18) unsigned. 9 8* 13 Dec 1978, PES - changes for large common and arrays. 9 9**/ 9 10 create_node: proc(type,length) returns(fixed bin (18)); 9 11 9 12 dcl length fixed bin; 9 13 dcl offset fixed bin(18); 9 14 dcl type fixed bin(4); 9 15 dcl storage(length) fixed bin aligned based; 9 16 dcl x(0:operand_max_len-1) fixed bin(35) aligned based(operand_base); 9 17 dcl (addr,char,ltrim,unspec) builtin; 9 18 9 19 9 20 if (length + next_free_operand) < operand_max_len 9 21 then do; 9 22 offset = next_free_operand; 9 23 next_free_operand = next_free_operand + length; 9 24 unspec(addr(x(offset)) -> storage) = "0"b; 9 25 addr(x(offset)) -> node.node_type = type; 9 26 return(offset); 9 27 end; 9 28 else do; 9 29 call print_message(407, "operand region", ltrim(char(operand_max_len))); /* FATAL */ 9 30 end; 9 31 9 32 end create_node; 9 33 9 34 /* END fort_create_node.incl.pl1 */ 8 11 8 12 8 13 create_constant: proc(data_type,value) returns(fixed bin (18)); 8 14 8 15 dcl (data_type,a_data_type) fixed bin(4); /* data type of constant */ 8 16 dcl (value,a_value) bit(72) aligned; /* value of constant */ 8 17 8 18 dcl addr builtin; 8 19 dcl binary builtin; 8 20 dcl bool builtin; 8 21 dcl char builtin; 8 22 dcl data_size fixed bin(17); 8 23 dcl decimal builtin; 8 24 dcl hash_index fixed bin; 8 25 dcl hash_table(0:hash_table_size-1) fixed bin(35) aligned based(operand_base); 8 26 dcl hash_table_size fixed bin int static options(constant) init(211); 8 27 dcl hbound builtin; 8 28 dcl ltrim builtin; 8 29 dcl mod builtin; 8 30 dcl mod_2_sum bit(36) aligned; 8 31 dcl node_offset fixed bin; 8 32 dcl node_ptr pointer; 8 33 dcl size builtin; 8 34 dcl v_array(2) bit(36) aligned based(addr(a_value)); 8 35 dcl x(0:operand_max_len-1) fixed bin(35) aligned based(operand_base); 8 36 10 1 /* BEGIN INCLUDE FILE relocation_bits.incl.pl1 */ 10 2 10 3 /* This include file defines the relocation bits as bit (6) entities. See 10 4* also relbts.incl.pl1 and reloc_lower.incl.pl1. */ 10 5 10 6 dcl ( rc_a initial("000000"b), /* absolute */ 10 7 rc_t initial("010000"b), /* text */ 10 8 rc_nt initial("010001"b), /* negative text */ 10 9 rc_lp18 initial("010010"b), /* linkage, 18 bit */ 10 10 rc_nlp18 initial("010011"b), /* negative link, 18 bit */ 10 11 rc_lp15 initial("010100"b), /* linkage, 15 bit */ 10 12 rc_dp initial("010101"b), /* def section */ 10 13 rc_s initial("010110"b), /* symbol segment */ 10 14 rc_ns initial("010111"b), /* negative symbol */ 10 15 rc_is18 initial("011000"b), /* internal static 18 */ 10 16 rc_is15 initial("011001"b), /* internal static 15 */ 10 17 rc_lb initial("011000"b), /* link block */ 10 18 rc_nlb initial("011001"b), /* negative link block */ 10 19 rc_sr initial("011010"b), /* self relative */ 10 20 rc_e initial("011111"b)) /* escape */ 10 21 bit(6) int static options(constant); 10 22 10 23 /* END INCLUDE FILE relocation_bits.incl.pl1 */ 8 37 8 38 8 39 8 40 a_data_type = data_type; 8 41 a_value = value; 8 42 8 43 if a_data_type = char_mode | a_data_type <= 0 | a_data_type > hbound(data_type_size,1) 8 44 then do; 8 45 call print_message(452, ltrim(char(decimal(a_data_type,12)))); /* cannot create the node */ 8 46 end; 8 47 else data_size = data_type_size(a_data_type); 8 48 8 49 if data_size = 1 8 50 then do; 8 51 mod_2_sum = v_array(1); 8 52 v_array(2) = "0"b; 8 53 end; 8 54 else mod_2_sum = bool(v_array(1),v_array(2),"0110"b); 8 55 8 56 8 57 hash_index = mod(binary(mod_2_sum,35),hash_table_size); 8 58 8 59 /* Search the hash table for the constant. */ 8 60 8 61 node_offset = hash_table(hash_index); 8 62 do while(node_offset > 0); /* search the entire bucket */ 8 63 node_ptr = addr(x(node_offset)); 8 64 8 65 if node_ptr -> constant.value = a_value /* must be same value */ 8 66 then if node_ptr -> node.data_type = a_data_type /* and same data type */ 8 67 then return(node_offset); 8 68 8 69 node_offset = node_ptr -> node.hash_chain; /* NB - pointer remains pointing at last item in bucket */ 8 70 end; 8 71 8 72 /* a new constant node must be created */ 8 73 8 74 node_offset = create_node(constant_node, size(constant)); 8 75 8 76 if hash_table(hash_index) = 0 /* Is this the first item in the bucket? */ 8 77 then hash_table(hash_index) = node_offset; /* yes */ 8 78 else node_ptr -> node.hash_chain = node_offset; /* no, add it to the end */ 8 79 8 80 node_ptr = addr(x(node_offset)); 8 81 node_ptr -> constant.data_type = a_data_type; 8 82 node_ptr -> constant.operand_type = constant_type; 8 83 node_ptr -> constant.is_addressable = "1"b; 8 84 node_ptr -> constant.reloc = rc_t; 8 85 node_ptr -> constant.value = a_value; 8 86 8 87 constant_info(data_size).constant_count = constant_info(data_size).constant_count + 1; 8 88 8 89 if constant_info(data_size).first_constant = 0 /* Is this the first item of this size? */ 8 90 then constant_info(data_size).first_constant = node_offset; /* yes */ 8 91 else addr(x(constant_info(data_size).last_constant)) -> constant.next_constant = node_offset; /* no, add it */ 8 92 8 93 constant_info(data_size).last_constant = node_offset; 8 94 8 95 return(node_offset); 8 96 8 97 end create_constant; 8 98 8 99 /* END fort_utilities.incl.pl1 */ 8711 8712 8713 print_hash_bucket_meters: 8714 procedure (); 8715 8716 dcl i fixed binary; 8717 dcl p pointer; 8718 8719 do i = 0 to hbound (p_list, 1); 8720 hash_counter (i) = 0; 8721 do p = p_list (i) repeat p -> primary.next while (p ^= null); 8722 hash_counter (i) = hash_counter (i) + 1; 8723 end; 8724 end; 8725 8726 call ioa_ ("p_list: ^(^4d^3x^)", hash_counter); 8727 8728 do i = 0 to hbound (bt_list, 1); 8729 hash_counter (i) = 0; 8730 do p = bt_list (i) repeat p -> primary.next while (p ^= null); 8731 hash_counter (i) = hash_counter (i) + 1; 8732 end; 8733 end; 8734 8735 call ioa_ ("bt_list: ^(^4d^3x^)", hash_counter); 8736 8737 end print_hash_bucket_meters; 8738 8739 end fort_optimizer; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/10/88 1336.7 fort_optimizer.pl1 >spec>install>MR12.2-1209>fort_optimizer.pl1 473 1 03/27/82 0424.8 fort_opt_nodes.incl.pl1 >ldd>include>fort_opt_nodes.incl.pl1 474 2 11/10/88 1314.2 fort_nodes.incl.pl1 >spec>install>MR12.2-1209>fort_nodes.incl.pl1 475 3 08/04/86 2015.0 fort_system_constants.incl.pl1 >ldd>include>fort_system_constants.incl.pl1 478 4 08/04/86 2015.0 fort_shared_vars.incl.pl1 >ldd>include>fort_shared_vars.incl.pl1 479 5 08/06/87 1153.7 fort_options.incl.pl1 >ldd>include>fort_options.incl.pl1 5843 6 10/26/88 1255.5 std_descriptor_types.incl.pl1 >ldd>include>std_descriptor_types.incl.pl1 8709 7 03/27/82 0437.1 fort_opt_utilities.incl.pl1 >ldd>include>fort_opt_utilities.incl.pl1 8711 8 03/27/82 0437.1 fort_utilities.incl.pl1 >ldd>include>fort_utilities.incl.pl1 8-11 9 03/27/82 0437.8 fort_create_node.incl.pl1 >ldd>include>fort_create_node.incl.pl1 8-37 10 10/30/80 1648.7 relocation_bits.incl.pl1 >ldd>include>relocation_bits.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. Packed constant fixed bin(1,0) initial dcl 5834 ref 5859 5878 Unpacked constant fixed bin(1,0) initial dcl 5834 ref 5859 5878 VLA 4 based bit(1) level 3 packed packed unaligned dcl 2-844 ref 8233 a 002116 automatic pointer dcl 3884 set ref 3887* 3894 3897 3900 3903 3904 3908 3910 a_data_type 000100 automatic fixed bin(4,0) dcl 8-15 set ref 8-40* 8-43 8-43 8-43 8-45 8-45 8-47 8-65 8-81 a_value 000102 automatic bit(72) dcl 8-16 set ref 8-41* 8-51 8-52 8-54 8-54 8-65 8-85 abs builtin function dcl 470 ref 4538 8384 ac 004646 automatic pointer dcl 8086 set ref 8099* 8099* 8100 8100 8100 8104 8104 8104* 8107 adam 004042 automatic pointer dcl 6930 in procedure "force_used_in_loop" set ref 6933* 6936* 6938 6943 6954 adam 004154 automatic pointer dcl 7152 in procedure "used_in_loop" set ref 7165* 7170* 7172 7177 7195 adam 004314 automatic pointer dcl 7432 in procedure "remove_loop" set ref 7436* 7441 7444 7448 7452* 7456 7458 7470 7481 7515 adam_loop 000100 automatic pointer dcl 215 set ref 512* 799* 1018 1019 1020 1905 1907 1908 1909 2679 2983 3013 add_op constant fixed bin(18,0) initial dcl 3-197 ref 3779 4033 4160 4176 6512 addr builtin function dcl 470 in procedure "fort_optimizer" ref 527 534 653 656 668 676 704 722 754 808 811 811 824 858 909 922 937 946 948 948 1052 1059 1075 1076 1099 1106 1109 1109 1182 1191 1215 1220 1228 1314 1323 1496 1497 1499 1501 1525 1525 1559 1559 1562 1592 1593 1594 1595 1673 1674 1830 2065 2096 2097 2098 2183 2231 2286 2291 2293 2295 2297 2524 2526 2530 2567 2579 2581 2588 2624 2650 2651 2824 2834 2857 2957 3148 3239 3251 3268 3268 3320 3374 3459 3538 3542 3547 3567 3583 3646 3712 3810 3810 3848 3851 3851 3910 3911 3945 3946 3984 3988 3996 4037 4038 4045 4070 4079 4128 4157 4173 4238 4269 4273 4319 4319 4342 4434 4607 4609 4672 4687 4689 4723 4723 4731 4892 5099 5125 5181 5189 5190 5201 5204 5224 5235 5264 5277 5287 5329 5373 5383 5395 5424 5495 5503 5657 5667 5675 5676 5690 5694 5778 5778 5859 5859 5859 5859 5878 5878 5878 5878 5918 5919 6078 6081 6153 6154 6182 6196 6242 6245 6245 6268 6279 6354 6355 6365 6382 6448 6449 6526 6565 6587 6587 6591 6614 6623 6633 6643 6766 6779 6829 6852 6853 6896 6897 6989 7044 7075 7098 7107 7107 7110 7123 7167 7228 7234 7319 7337 7402 7407 7492 7498 7500 7528 7552 7556 7592 7604 7606 7606 7627 7629 7735 7740 7745 7761 7761 7770 7785 7785 7803 7805 7820 7830 7846 7849 7849 7894 7939 7939 7995 8001 8017 8060 8100 8100 8104 8104 8145 8153 8158 8166 8173 8187 8187 8239 8286 8304 8308 8308 8330 8335 8342 8350 8359 8383 8384 8388 8388 8459 8479 8482 8482 8523 8530 8544 8545 8556 8557 8639 8640 7-13 7-82 7-114 7-138 7-139 7-149 7-165 7-166 7-220 7-222 7-249 7-290 addr builtin function dcl 8-18 in procedure "create_constant" ref 8-51 8-52 8-54 8-54 8-63 8-80 8-91 addr builtin function dcl 9-17 in procedure "create_node" ref 9-24 9-25 addressing_bits 0(14) based structure level 2 in structure "constant" packed packed unaligned dcl 2-256 in procedure "fort_optimizer" addressing_bits 0(14) based structure level 2 in structure "temporary" packed packed unaligned dcl 2-1005 in procedure "fort_optimizer" alias_mask 044106 constant bit(7) initial dcl 216 ref 696 742 747 749 756 1261 1351 aliasable 2(03) based bit(1) level 2 packed packed unaligned dcl 2-844 set ref 711* 714 1249 1336 3768 4094 4141 4147 4225 4233 4439 4538 6831 aliasable_mask based bit array dcl 217 set ref 696 746 746 747* 750* 768* 769* 1255 1256 1342 1345 1404 1405 1408 1410 2395 aliasable_mask_p 000102 automatic pointer dcl 218 set ref 696 746* 746 746 747 750 768 769 1255 1256 1342 1345 1404 1405 1408 1410 2395 all_constant 2 based bit(1) level 2 in structure "sr_var" dcl 404 in procedure "fort_optimizer" set ref 6296* 7044 7053 all_constant 10 based bit(1) level 3 in structure "sr_frame" dcl 6014 in procedure "reduce_strength" set ref 6104* 6296 6592* 6592 all_constant 002056 automatic bit(1) dcl 3449 in procedure "optimize_flow_unit" set ref 3558* 3584* 3610* 3629* 3653 3695 4289* 4294* allocate 0(25) based bit(1) level 4 in structure "node" packed packed unaligned dcl 2-63 in procedure "fort_optimizer" set ref 1191* allocate 0(25) based bit(1) level 5 in structure "symbol" packed packed unaligned dcl 2-844 in procedure "fort_optimizer" set ref 708 2858* allocate_symbol_name 000517 automatic fixed bin(17,0) dcl 2-525 set ref 520* 6764 6764 always_completely_set 25 based pointer level 2 packed packed unaligned dcl 1-46 set ref 1043 1246 1256 1381 1405 2422 2685* 7567 always_completely_sets 000735 automatic bit(1) dcl 1307 set ref 1312* 1320* 1347* 1360* 1381 always_safe_to_move_class 000104 automatic fixed bin(18,0) dcl 220 set ref 538* 540* 3701 always_sets parameter bit(1) dcl 1300 ref 1295 1312 amt parameter fixed bin(18,0) dcl 7-46 ref 7-44 7-51 ancestors_and_me 24 based pointer level 2 packed packed unaligned dcl 1-100 set ref 1908* 1909 1920* 1921 1921 1922 2736* 5428 6450 7515 array_ref based structure level 1 dcl 2-155 array_ref_node constant fixed bin(4,0) initial dcl 3-87 ref 1076 1209 1316 3577 3639 3646 3709 3994 4042 4081 4174 4198 4222 4230 4343 4434 4689 5204 5233 5337 5374 5391 6528 7594 7-224 array_size 3 based fixed bin(24,0) level 2 dcl 2-383 ref 668 8246 articulation_blocks 17 based pointer level 2 packed packed unaligned dcl 1-100 set ref 1020* 2010 2016 2016 2716* 2726* 3518 ass_chain 001572 automatic pointer dcl 2772 set ref 2789* 3096* 3225 3361* 4147* 6489 6496 6499* 6893 6911* assign_ 000016 constant entry external dcl 5829 ref 5859 5878 assign_op constant fixed bin(18,0) initial dcl 3-197 set ref 3653 3782 3803 4071 6110 6175* 6225 6277 6342 8479 assignment 003616 automatic fixed bin(18,0) dcl 6005 set ref 6175* 6179 6182 assignment_class constant fixed bin(18,0) initial dcl 219 ref 3695 assignment_list 004504 automatic pointer dcl 7692 set ref 7698* 7838* 8099 8636 8683 8696* assigns_constant_to_symbol 0(09) based bit(1) level 2 packed packed unaligned dcl 1-144 set ref 2630* 3347 3741* 3767* 4672 5099 assp 002250 automatic pointer dcl 4261 in procedure "process_frozen_for_do" set ref 4269* 4273 4306 4308* 4310 4312 4319 4320* assp 003556 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6182* 6183 6184 6187* attributes 10 based structure level 2 dcl 2-844 automatic 11 based bit(1) level 4 packed packed unaligned dcl 2-844 set ref 714 720* 760 6772* b 002120 automatic pointer dcl 3884 set ref 3888* 3894 3897 3900 3904 3908 3911 3914 back 2 based pointer level 3 in structure "edge" packed packed unaligned dcl 1-33 in procedure "fort_optimizer" set ref 1648* 1656* 2206 2208 2209* 2209 2214* 2216* 2358 2358 2361* 2361 back 5 based pointer level 3 in structure "edge" packed packed unaligned dcl 1-33 in procedure "fort_optimizer" set ref 1649* 1661* 2364 2364 2367* 2367 back 2(18) based bit(18) level 2 in structure "opt_statement" packed packed unaligned dcl 1-176 in procedure "fort_optimizer" set ref 2294 2307* 2307 2593* 2595* 7628 7632* 7632 7-143 back 1 based pointer level 2 in structure "flow_unit" packed packed unaligned dcl 1-46 in procedure "fort_optimizer" set ref 1047 1437* 1931 1933 2004 2162 2170* 2170 2172* 2173 2179 2542 2543* 2543 2898 2903 2905 2956 2977 3024 3029 3031 back 004256 automatic fixed bin(18,0) dcl 7306 in procedure "remove_dead_assignments" set ref 7338* 7372 back 1 based pointer level 2 in structure "lp_frame" packed packed unaligned dcl 434 in procedure "fort_optimizer" set ref 3304 3420* 4775 4782 back 1(18) based fixed bin(18,0) level 2 in structure "operator" packed packed unsigned unaligned dcl 1-144 in procedure "fort_optimizer" set ref 2598* 2653* 2655* 5191* 5195* 6329 6408 7338 8157 8204 8334 8364 8487 8522 8537 7-166 7-167* 7-167 7-172* back_target 11 based pointer level 2 packed packed unaligned dcl 1-100 set ref 1859* 1874 1973* 2736* 2882 3094 3298 3366 3519 6030 7444 7987 8039 backp 000102 automatic pointer dcl 7-158 set ref 7-166* 7-168 bd 000114 automatic pointer dcl 1730 in begin block on line 1724 set ref 1735* 1778* 1781 1782 bd 004322 automatic pointer dcl 7432 in procedure "remove_loop" set ref 7513* 7514 bd 001372 automatic pointer dcl 2391 in procedure "compute_busy_on_exit" set ref 2403* 2429 bd_level_number 002040 automatic fixed bin(18,0) dcl 3447 set ref 3481* 3488 bdl 004324 automatic pointer dcl 7432 set ref 7514* 7515 bias constant fixed bin(19,0) initial dcl 3-56 ref 880 971 971 981 1125 1125 1135 2120 2301 2301 3833 4627 binary builtin function dcl 8-19 ref 8-57 binop_round 1620 based entry variable array level 2 dcl 477 ref 5634 bit builtin function dcl 470 ref 2592 2593 2594 2595 bit_value parameter bit(72) dcl 5826 set ref 5808 5849 5849 5851 5851 5859 5859 5870 5878 5878 bits 25 based structure level 2 in structure "loop" packed packed unaligned dcl 1-100 in procedure "fort_optimizer" bits 0(25) based structure level 2 in structure "temporary" packed packed unaligned dcl 2-1005 in procedure "fort_optimizer" bits 0(25) based structure level 2 in structure "node" packed packed unaligned dcl 2-63 in procedure "fort_optimizer" bits 4 based structure level 2 in structure "opt_statement" packed packed unaligned dcl 1-176 in procedure "fort_optimizer" bits based bit dcl 379 in procedure "fort_optimizer" set ref 1036* 1036* 1036* 1036* 1043* 1043* 1043* 1043* 1043* 1043* 1245* 1246 1246* 1255* 1255 1256* 1256 1256 1266* 1267* 1286* 1287* 1332 1332* 1334* 1342* 1342 1342 1345* 1345 1351 1351* 1354* 1374 1374* 1377* 1381* 1404* 1404 1405* 1405 1405 1408* 1408 1408 1410* 1410 2395* 2419* 2419 2419 2422 2422 2422 2426 2428* 2447 2447 2451 2453* 2473* 2473 2473 2473 2473 2476* 2476 2476 2477* 2477 2477 2482* 2482 2482 2482 2482 2485* 2485 2485 2486* 2486 2486 2505* 2505 2505 2680 2680 2681 2681 2682 2682 2683 2683 2684 2684 2685 2685 2717 2717 2718 2718 2741 2741 2742 2742 2743 2743 2744 2744 2891* 2891 2891 3114* 3114 3114 3162 3162 3284* 3284 3284 3528* 3528 3528 3586 3615 3719 3719 4004* 4004 4004 4004 4092 4094 4141 4141 4144* 4147 4147 4225 4233 4248* 4281 4281 4569 5211 5211* 5213* 5214* 5215* 5216* 5216 5216 5230* 5237* 5404* 5405* 6078 6081 6198* 6200* 6202* 6203* 6204* 6207* 6208 6208* 6211* 6450 6450 6537 6644* 6831 6868* 6899 6905* 6967* 6970* 6991 7044 7080* 7109* 7110* 7134* 7135* 7136* 7180 7212 7217* 7240* 7253* 7324 7324 7366 7368* 7374* 7375* 7376* 7448* 7448 7567* 7567* 7567* 7567* 7567* 7567* 7576* 7576* 7576* 7708* 7708 7708 7712* 7712 7712 7714* 7714 7714 7721* 7721 7721 7889 7912 7924 7952* 8351 8360 8445 8648* bits 2 based structure level 2 in structure "range" packed packed unaligned dcl 1-243 in procedure "fort_optimizer" set ref 8013* 8013 8015 8064* 8064 8596* 8665* 8665 bits 0(25) based structure level 2 in structure "symbol" packed packed unaligned dcl 2-844 in procedure "fort_optimizer" bits 0(25) based structure level 2 in structure "array_ref" packed packed unaligned dcl 2-155 in procedure "fort_optimizer" bits 0(25) based structure level 2 in structure "label" packed packed unaligned dcl 2-530 in procedure "fort_optimizer" bool builtin function dcl 8-20 ref 8-54 bound 004755 automatic fixed bin(35,0) dcl 8268 set ref 8388* 8394 8396 brother 3 based pointer level 2 packed packed unaligned dcl 1-100 set ref 1952 2488 2710* 2736* 3115 6952 6958 7193 7199 7468 7474 7717 7723 bt 003364 automatic pointer dcl 5168 in procedure "move" set ref 5179* 5181 5181* 5189 5191 5196 5211 5211 5213 5216 5230 5237 bt parameter pointer dcl 5255 in procedure "insert_stm_in_back_target" ref 5252 5263 5273 5273 5275 5275 5277 5278 5279 5296 5297 bt 003554 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6030* 6081 6090 6090 6090 6090* 6093 6094 6171 6179 6198 6200 6329 6329 6408 6408 6450 6564* 6589 6644 7080 7136 bt 004320 automatic pointer dcl 7432 in procedure "remove_loop" set ref 7444* 7448 7483 7485 7490 7490 7497 7502 7507* 7515 7562 bt parameter pointer dcl 2238 in procedure "splice_in_another_fu" set ref 2235 2248 2252 2254 2266* bt 001560 automatic pointer dcl 2771 in procedure "optimize_subprogram" set ref 2882* 2885* 3094* 3095 3262* 3264* 3268* 3268 3268 3270 3366* 3367 bt 002022 automatic pointer dcl 3446 in procedure "optimize_flow_unit" set ref 3519* 3526 3719 3730* 3736 4132 4217 4281 4281 4298 4311 bt parameter pointer dcl 7-132 in procedure "derive_insert_for_bt" ref 7-130 7-137 7-143 7-144 7-147 7-149 bt 004610 automatic pointer dcl 7978 in procedure "process_comparison_list" set ref 7987* 8039* 8148 8325 8445 8452* 8456 8458 bt_list 000417 automatic pointer array level 2 packed packed unaligned dcl 282 set ref 506* 3142 3144 3211 3212 3247 3248 3248 3250* 3251 3251 3682 4761 4762 8728 8730 bt_list_st 000417 automatic structure array level 1 dcl 282 set ref 3119* 3344* 3734* 4309* bt_statement 005226 automatic fixed bin(18,0) dcl 7-134 set ref 7-137* 7-138 7-147 btlabel parameter fixed bin(18,0) dcl 2238 ref 2235 2260 btst 005232 automatic pointer dcl 7-135 set ref 7-138* 7-139 7-143 7-144 7-148 builtin 10(32) based bit(1) level 4 packed packed unaligned dcl 2-844 ref 708 busy_on_entry 20 based pointer level 2 packed packed unaligned dcl 1-46 set ref 1043 1246 1256 1256 1267 1287 1405 1405 2395 2419 2422 2426 2428 2447 2447 2451 2453 2505 2682* 7567 busy_on_exit 22 based pointer level 2 in structure "flow_unit" packed packed unaligned dcl 1-46 in procedure "fort_optimizer" set ref 1043 2419 2419 2422 2684* 3719 4004 4004 4004 5216 5216 6081 6200 7136 7324 7448 7567 busy_on_exit 22 based pointer level 2 in structure "loop" packed packed unaligned dcl 1-100 in procedure "fort_optimizer" set ref 1036 2505 2505 2744* 3162 6078 6991 7448 7912 busy_on_exit_list 004512 automatic pointer dcl 7692 set ref 7698* 7912* 8043 8076 by_compiler 0(35) based bit(1) level 3 packed packed unaligned dcl 2-844 set ref 6771* c 005104 automatic pointer dcl 8627 in procedure "process_assignment_list" set ref 8636* 8636* 8637 8638 8642* 8647* 8653* c 004600 automatic pointer dcl 7964 in procedure "chain_it" set ref 7966* 7967 7968 7969 c 003134 automatic pointer dcl 4720 in procedure "process_jump_label" set ref 4778* 4779 4780 4781 c 004257 automatic fixed bin(18,0) dcl 7306 in procedure "remove_dead_assignments" set ref 7320* 7324 7324 7366 7368 7374 7375 7376 c 004016 automatic pointer dcl 6877 in procedure "find_new_induction_vars_on_ass_chain" set ref 6893* 6893* 6894 6895 6909 6911 6912 6913 6916* c 001432 automatic pointer dcl 2499 in procedure "summarize_loop_busy_on_exit" set ref 2504* 2504* 2505* 2508 c 003366 automatic fixed bin(18,0) dcl 5173 in procedure "move" set ref 5210* 5211 5211 5213 5214 5215 5216 5216 5216 5229* 5230 5236* 5237 c 001620 automatic pointer dcl 2780 in procedure "optimize_subprogram" set ref 2829* 2829* 2836 2837* 2840 c 001050 automatic pointer dcl 1557 in procedure "add_to_jump_assigned_target_list" set ref 1566* 1568 1569 1570 1573* 1575 1576 1577 c 002444 automatic pointer dcl 4581 in procedure "free_them" set ref 4588* 4588* 4589 4635* 4636 c 003110 automatic pointer dcl 4683 in procedure "record" set ref 4704* 4705 4706 4707 c 001770 automatic pointer dcl 3295 in procedure "pop_loop" set ref 3396* 3396* 3397 3398* 3399 c 001134 automatic pointer dcl 1683 in procedure "flow_analysis" set ref 1835* 1836 1837 1838 1850* 1850* 1851 1886* 1887 1997* 1998 1999 2000 2012* 2012* 2013* 2017 c 005246 automatic pointer dcl 7-184 in procedure "put_in_loop_end" set ref 7-191* 7-192 7-193 7-194 7-203* c 001034 automatic pointer dcl 1544 in procedure "add_to_jump_assigned_list" set ref 1546* 1548 1549 1550 c 000720 automatic fixed bin(18,0) dcl 1239 in procedure "use_symbol" set ref 1243* 1245 1246 1246 1261 c 003441 automatic fixed bin(18,0) dcl 5364 in procedure "process_moved_descendants" set ref 5401* 5402 5404 5405 c 001674 automatic pointer dcl 3105 in procedure "finish_loop" set ref 3177* 3177* 3178* 3180 c 003272 automatic pointer dcl 4991 in procedure "detach_secondaries" set ref 5001* 5001* 5002* 5003 c 004046 automatic fixed bin(18,0) dcl 6931 in procedure "force_used_in_loop" set ref 6934* 6967 6970 c 002326 automatic pointer dcl 4388 in procedure "chain_incr" set ref 4390* 4393* 4397 4398 4399 4400 4401 c 004612 automatic pointer dcl 7978 in procedure "process_comparison_list" set ref 7990* 7990* 7991 7992* 8024 8043* 8043* 8044 8045* 8071 c 004732 automatic pointer dcl 8266 in procedure "calculate_range_for_counter" set ref 8370* 8370* 8371 8372* 8398 8407* 8407* 8408* 8409 c parameter pointer dcl 8691 in procedure "remove" ref 8688 8694 8696 8698 8699 c2 001124 automatic fixed bin(18,0) dcl 1670 set ref 1673* 1675 c3 001125 automatic fixed bin(18,0) dcl 1670 set ref 1674* 1675 c_source 001062 automatic pointer dcl 1584 set ref 1588* 1588* 1590 1601* 1602 c_target 001064 automatic pointer dcl 1584 set ref 1597* 1597* 1598* 1599 1613* 1613* 1615 1616* 1624 call_op constant fixed bin(18,0) initial dcl 3-197 ref 3596 7346 8466 cannot_fault_class constant fixed bin(18,0) initial dcl 222 ref 540 cat_op constant fixed bin(18,0) initial dcl 3-197 ref 8198 chain based structure level 1 dcl 1-27 set ref 1606 1607 1621 1622 1628 1629 1894 1895 2842 2843 3401 3402 4640 4641 5007 5008 8028 8029 8075 8076 8402 8403 8413 8414 8682 8683 8698 8699 7-34 7-34 7-34 7-37 7-38 7-38 chaining_input 000617 automatic bit(1) dcl 786 set ref 792* 1030* 1206 1211 1321 change_occurred 005124 automatic bit(1) dcl 8628 set ref 8630* 8632 8633* 8649* 8663* 8674* changed 004032 automatic bit(1) dcl 6879 set ref 6887* 6889 6890* 6904* char builtin function dcl 9-17 in procedure "create_node" ref 9-29 9-29 char builtin function dcl 470 in procedure "fort_optimizer" ref 5871 5960 5960 7-54 7-54 7-122 7-122 char builtin function dcl 8-21 in procedure "create_constant" ref 8-45 8-45 char4_target 003520 automatic char(4) packed unaligned dcl 5911 set ref 5943* 5947 char8_target 003522 automatic char(8) packed unaligned dcl 5912 set ref 5950* 5953 char_constant based structure level 1 dcl 2-316 char_dtype constant fixed bin(17,0) initial dcl 6-25 ref 5859 5878 char_mode constant fixed bin(4,0) initial dcl 3-106 ref 8-43 char_size 10 based fixed bin(20,0) level 4 packed packed unsigned unaligned dcl 2-844 ref 5960 5960 8179 char_units constant fixed bin(3,0) initial dcl 3-136 ref 8241 8249 chars_per_word constant fixed bin(9,0) initial dcl 3-68 ref 8232 cmpx_mode constant fixed bin(4,0) initial dcl 3-106 set ref 1276 1279 1366 1369 4492* 4495 5846 code 004104 automatic fixed bin(18,0) dcl 6984 in procedure "replace_tests" set ref 7018* 7019 code parameter fixed bin(18,0) dcl 7030 in procedure "change_test" set ref 7027 7065* 7069* code 003064 automatic fixed bin(18,0) dcl 4649 in procedure "record_secondaries" set ref 4660* 4662 4668 common_chain 2 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-753 ref 652 common_only constant fixed bin(18,0) initial dcl 290 ref 2985 comp_parm 2260 based entry variable array level 2 dcl 477 ref 5641 comparison_list 004506 automatic pointer dcl 7692 set ref 7698* 7812* 7823* 7990 8029 complete_fu constant fixed bin(18,0) initial dcl 295 set ref 2913* 2988* 3036* 3528 computed 30 based pointer level 2 packed packed unaligned dcl 1-100 set ref 2719* 2726* 7716 7716 7716 7753 7895 consolidate 11(27) based bit(1) level 4 packed packed unaligned dcl 2-753 ref 536 consolidating 000110 automatic bit(1) dcl 224 set ref 503* 2952* 2996* const_p 004734 automatic pointer dcl 8266 set ref 8383* 8384 8384 constant based structure level 1 dcl 2-256 in procedure "fort_optimizer" set ref 8-74 8-74 constant 11(05) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 2-844 in procedure "fort_optimizer" ref 708 constant_assignment 002064 automatic bit(1) dcl 3449 set ref 3557* 3653* 3739 3765 constant_count 77 based fixed bin(17,0) array level 3 dcl 477 set ref 8-87* 8-87 constant_info 77 based structure array level 2 dcl 477 constant_node 000527 constant fixed bin(4,0) initial dcl 3-87 set ref 3569 4084 4275 5505 6531 6592 6607 6625 6625 7772 7886 8017 8304 8479 8-74* constant_offset 004701 automatic fixed bin(24,0) dcl 8129 set ref 8187* 8190 8194 constant_type constant fixed bin(4,0) initial dcl 3-120 ref 8-82 conv_round 2500 based entry variable array level 2 dcl 477 ref 5630 5632 5650 5928 convert_to_cmpx_op constant fixed bin(18,0) initial dcl 3-197 ref 5767 convert_to_dp_op constant fixed bin(18,0) initial dcl 3-197 ref 5760 convert_to_int_op constant fixed bin(18,0) initial dcl 3-197 ref 5746 convert_to_real_op constant fixed bin(18,0) initial dcl 3-197 ref 5753 coord 004156 automatic fixed bin(18,0) dcl 7161 in procedure "used_in_loop" set ref 7167* 7180 7212 7217 7240 7253 coord 002041 automatic fixed bin(18,0) dcl 3447 in procedure "optimize_flow_unit" set ref 3585* 3586 3586 3614* 3615 3615 3718* 3719 3719 coord 003606 automatic fixed bin(18,0) dcl 6005 in procedure "reduce_strength" set ref 6197* 6198 6200 6202 6203 6204 6207 6208 6208 6211 coord parameter fixed bin(18,0) dcl 6927 in procedure "force_used_in_loop" ref 6922 6934 coordinate 14(25) based fixed bin(17,0) level 2 in structure "symbol" packed packed unaligned dcl 2-844 in procedure "fort_optimizer" set ref 728* 730* 756 758 1241 1243 1329 3585 3614 3718 4003 4092 4094 4141 4141 4144 4147 4147 4225 4233 4248 4281 4281 4569 4692 5210 5226 5229 5236 5401 6078 6081 6197 6449 6537 6644 6794* 6831 6858 6868 6899 6905 6991 7044 7080 7109 7110 7134 7135 7136 7167 7320 7889 7912 7924 7924 7952 7952 8351 8360 8445 8648 coordinate 0(18) based fixed bin(18,0) level 2 in structure "operator" packed packed unsigned unaligned dcl 1-144 in procedure "fort_optimizer" set ref 834* 2640* 4753 4765 4828 4852 4907 4918 4920 7753 7753 7895 7895 cpu_time_and_paging_ 000012 constant entry external dcl 604 ref 611 617 create_char_constant 1524 based entry variable level 2 dcl 477 ref 5960 create_it parameter bit(1) dcl 8579 ref 8574 8593 cs 000106 automatic pointer dcl 223 set ref 534* 536 538 542 568 643 652 703 737 753 807 1014 1051 1901 1902 2530 2531 5856 5875 6779 6780 cur_frame 003544 automatic pointer dcl 6003 set ref 6100* 6102* 6104 6105 6107 6108 6110 6113 6117 6119 6129 6131 6132 6133 6144 6153 6171 6175 6184 6217 6229 6255 6296 6297 6299 6309 6314 6328 6339 6356 6362 6417* 6417 6580 6580 6582* 6588 6592 6597 6598 6600 6619 6623 6637 6658 6663* 6677 6683 cur_o 003546 automatic pointer dcl 6003 set ref 6328* 6329 6329 6332* 6333* 6362* 6363 6365 6375* 6394 6395 6397 6408 6408 6411* 6412* cur_statement 67 based fixed bin(18,0) level 2 dcl 477 set ref 807* 807* 808 988* 1051* 1051* 1052* 1434 2162* 2285* 2286 3536* 3536* 3538* 7225* 7225* 7228 7244* 7441* 7550* 7550* 7552* 7732* 7732* 7735* cur_subprogram 71 based fixed bin(18,0) level 2 dcl 477 set ref 533* 533* 534* cur_unit 000610 automatic pointer dcl 783 set ref 800* 844* 850 901* 913 934 943 955 963 987 988 1042* 1042* 1043 1043 1043 1043 1043 1043* 1047 1054* 1245 1246 1246 1255 1255 1256 1256 1256 1266 1267 1286 1287 1332 1332 1334 1342 1342 1342 1345 1345 1351 1351 1354 1374 1374 1377 1381 1404 1404 1405 1405 1405 1408 1408 1408 1410 1410 1416 1433 1436 1437 1441 1442* 1446* 1447 1472* 1474 1548 cvalue1 003676 automatic fixed bin(18,0) dcl 6553 set ref 6627* 6629 cvalue2 003677 automatic fixed bin(18,0) dcl 6553 set ref 6610* 6611 6613 6628* 6629 d 004712 automatic pointer dcl 8225 set ref 8239* 8241 8246 da_chain 001574 automatic pointer dcl 2772 set ref 2785* 2809 7276 7277* 7317 7384 7385* dac 004244 automatic pointer dcl 7305 set ref 7317* 7317* 7318 7322 7379* 7381 dad parameter pointer dcl 2696 ref 2693 2702 2707 2708 2709 2712 2713 data 2 based structure level 2 in structure "sr_frame" dcl 6014 in procedure "reduce_strength" data 2 based structure level 2 in structure "lp_frame" dcl 434 in procedure "fort_optimizer" data 2 based structure level 2 in structure "primary" dcl 1-234 in procedure "fort_optimizer" set ref 3203* 3203 3214* 3214 3326* 3326 3345* 3345 4752* 4752 4764* 4764 4864* 4864 4906* 4906 4922* 4922 data_size 000104 automatic fixed bin(17,0) dcl 8-22 set ref 8-47* 8-49 8-87 8-87 8-89 8-89 8-91 8-93 data_type parameter fixed bin(4,0) packed unsigned unaligned dcl 5826 in procedure "literal_value" ref 5808 5846 5854 5868 5873 data_type 0(05) based fixed bin(4,0) level 2 in structure "constant" packed packed unsigned unaligned dcl 2-256 in procedure "fort_optimizer" set ref 5507 5714* 5725* 5737* 5749* 5756* 5763* 5770* 8-81* data_type 000122 automatic fixed bin(4,0) array dcl 5464 in procedure "constant_expression" set ref 5507* 5624 5624 5630 5630 5632 5632 5637 5641 5641 5650 data_type 0(05) based fixed bin(4,0) level 2 in structure "temporary" packed packed unsigned unaligned dcl 2-1005 in procedure "fort_optimizer" set ref 5687 7415* data_type parameter fixed bin(4,0) dcl 8-15 in procedure "create_constant" ref 8-13 8-40 data_type 0(05) based fixed bin(4,0) level 2 in structure "node" packed packed unsigned unaligned dcl 2-63 in procedure "fort_optimizer" ref 3779 3803 5921 5922 8-65 data_type 0(05) based fixed bin(4,0) level 2 in structure "symbol" packed packed unsigned unaligned dcl 2-844 in procedure "fort_optimizer" set ref 730 763 768 1251 1338 4452 4457 4470 4475 4485 4533 4538 6768* 6831 data_type_size 000377 constant fixed bin(17,0) initial array dcl 3-115 ref 6769 8-43 8-47 dbits based bit dcl 380 set ref 1009 1009 1018 1018 1019 1019 1020 1020 1756 1781* 1781 1782* 1823 1874 1983* 2001* 2010* 2010 2014 2016* 2016 2051* 2051 2057 2057* 2078 2250* 2250 2251* 2686 2686 2714 2714 2715 2715 2716 2716 3518 7005 dead_assign_cand based structure level 1 dcl 424 set ref 7288 7288 7288 7291 7292 7292 7383 7384 decimal builtin function dcl 8-23 ref 8-45 8-45 delta 4 based fixed bin(18,0) level 3 in structure "sr_frame" dcl 6014 in procedure "reduce_strength" set ref 6110* 6113* 6119* 6217 6600 6600* 6619 6619* 6623 6629* 6634* 6637 6658* 6658 delta 003612 automatic fixed bin(18,0) dcl 6005 in procedure "reduce_strength" set ref 6217* 6219 6226* 6238* 6242* 6257 6273* 6279 delta 002400 automatic fixed bin(1,0) dcl 4526 in procedure "set_equivalences" set ref 4533* 4538 deltap 003664 automatic pointer dcl 6550 in procedure "reduce" set ref 6633* 6634 6643 deltap 003562 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6279* 6280 6280 6280* depth 1 based fixed bin(18,0) level 2 dcl 1-100 set ref 1989 1995 1995 2713* 2713 2729* 2881 2925 2986 3058 3093 3365 3952 4759 4947 4952 8563 8563 descriptor_type 000100 automatic fixed bin(17,0) dcl 5837 set ref 5856* 5858* 5859 5875* 5877* 5878 detach_constant_assignments 003264 automatic bit(1) dcl 4989 set ref 4993* 4998 dim builtin function dcl 470 ref 5161 dimension based structure level 1 dcl 2-383 in procedure "fort_optimizer" dimension 12(25) based fixed bin(18,0) level 2 in structure "symbol" packed packed unsigned unaligned dcl 2-844 in procedure "fort_optimizer" ref 668 8237 8239 dimensioned 10(35) based bit(1) level 4 packed packed unaligned dcl 2-844 ref 658 714 763 4094 4538 4538 divide builtin function dcl 470 ref 737 1006 1014 8388 do_analysis 004456 automatic bit(1) dcl 7678 set ref 7697* 7706 7751 do_timings 000111 automatic bit(1) dcl 225 set ref 542* 572 606 doing_full_optimization 002060 automatic bit(1) dcl 3449 set ref 3453* 3526 3768 3779 3803 3955 doing_loop 001601 automatic bit(1) dcl 2775 set ref 2883* 3073 3095* 3367* dominated_by 23 based pointer level 2 packed packed unaligned dcl 1-46 set ref 1009* 1756 1781 1781 1782 1823 1874 2014 2051 2051 2057 2057 2078 2250 2250 2251 2686* dominator 4 based pointer level 2 packed packed unaligned dcl 1-46 set ref 1708* 1735 1735 1770 1778* 1859 1967 2050* 2050 2052* 2249* 2403 3478 3479 7513 7515* 8205 8365 dp_mode constant fixed bin(4,0) initial dcl 3-106 ref 5854 dp_picture 000101 automatic picture(26) packed unaligned dcl 5837 set ref 5859 5859 5859 5859 5861 5862 5864 5865 5866 dt 000733 automatic fixed bin(18,0) dcl 1306 in procedure "set" set ref 1338* 1342 1345 1351 1351 1354 1366 1369 dt 000721 automatic fixed bin(18,0) dcl 1239 in procedure "use_symbol" set ref 1251* 1255 1256 1266 1267 1276 1279 dt 002370 automatic fixed bin(4,0) dcl 4521 in procedure "set_equivalences" set ref 4529* 4533 4538 dt 002344 automatic fixed bin(4,0) dcl 4431 in procedure "set" set ref 4452* 4457 4470* 4475 4485* 4487* 4492 4495 dummy 000542 automatic fixed bin(18,0) dcl 603 set ref 611* 617* e 001374 automatic pointer dcl 2391 in procedure "compute_busy_on_exit" set ref 2417* 2417* 2418* 2438 e parameter pointer dcl 2198 in procedure "redirect_edge" ref 2195 2203 2204 2206 2208 2209 2212 2213 2214 2215 2216 e 001174 automatic pointer dcl 2036 in procedure "create_new_back_target" set ref 2074* 2074* 2075 2076 2090* 2264* e 000106 automatic pointer dcl 1730 in begin block on line 1724 set ref 1747* 1747* 1748* 1754 1773* 1773* 1774* 1775 e 001110 automatic pointer dcl 1644 in procedure "link" set ref 1646* 1648 1649 1651 1652 1654 1655 1656 1659 1660 1661 e parameter pointer dcl 2351 in procedure "unlink" ref 2346 2355 2356 2358 2358 2358 2360 2361 2361 2361 2364 2364 2364 2366 2367 2367 2367 e 001136 automatic pointer dcl 1683 in procedure "flow_analysis" set ref 1701* 1701* 1702* 1712 1821* 1821* 1822* 1825 1871* 1871* 1872* 1883 1989* 1989* 1991 1998* 2003 e1 001246 automatic pointer dcl 2201 set ref 2213* 2216 2216 ea 000556 automatic pointer dcl 634 set ref 660* 662 663 664 667 668 678* 678* 681 681* 684 edge based structure level 1 dcl 1-33 set ref 1646 1646 element_count 2 based fixed bin(24,0) level 2 dcl 2-383 ref 8241 element_size 15(07) based fixed bin(17,0) level 2 packed packed unaligned dcl 2-844 set ref 6769* 8253 eligible_ind_var_op_var 37 based pointer level 2 packed packed unaligned dcl 1-100 set ref 2736* 7875* eligible_ind_var_op_var_list 004510 automatic pointer dcl 7692 set ref 7698* 7777* 7875 8017* end_input_to 10(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-1005 set ref 3988 3989* 3989 4045 4046* 4046 5694 6162* 7-79 7-82 7-85* 7-269* 7-273* entry 4 000460 automatic structure array level 2 dcl 455 entry_pt 15(04) based bit(1) level 3 packed packed unaligned dcl 1-46 set ref 850* 3379 3380* 3384* entry_unit 000112 automatic pointer dcl 226 in procedure "fort_optimizer" set ref 512* 800* 801 802 802 844* 1008 1537* 1693 1694 1937 2280 2447 2956 2981 entry_unit 7 based pointer level 2 in structure "loop" packed packed unaligned dcl 1-100 in procedure "fort_optimizer" set ref 1858* 1966 2736* 3119 7441 equiv_array based structure level 1 dcl 429 equiv_array_chain 000560 automatic pointer dcl 634 set ref 644* 662 663* 673 678 688 689* equiv_array_tail 000562 automatic pointer dcl 634 set ref 644* 664 664* 687 689* error 000176 stack reference condition dcl 5479 ref 5517 error_condition 000134 automatic char(16) packed unaligned dcl 5473 set ref 5781* 5784* 5788* 5792* 5796* 5800* 5804* executable 0(31) based bit(1) level 4 packed packed unaligned dcl 2-530 ref 811 exit 001140 automatic pointer dcl 1683 set ref 1995* 1995* 1999 2000 2001* 2002 exit_c 004614 automatic pointer dcl 7978 set ref 8053* 8053* 8054* 8066 exit_fu 004616 automatic pointer dcl 7978 set ref 8054* 8056 8058 8059* 8060 exit_target 004326 automatic pointer dcl 7432 in procedure "remove_loop" set ref 7481* 7485 7492* 7502 7502* 7507* 7513 7515 exit_target 001707 automatic pointer packed unaligned dcl 3107 in procedure "finish_loop" set ref 3174* 3178 exit_unit 000114 automatic pointer dcl 227 set ref 512* 803* 901* 929 1002 1042 1931 1980 2280 2395 2447 2451 2453 2956 2981 exits 12 based pointer level 2 packed packed unaligned dcl 1-100 set ref 1999 2000* 2012 2504 2736* 3168 3174 3177 7481 8053 expression 2 based pointer level 3 packed packed unaligned dcl 1-234 set ref 3147 3238 3316 3339 3599 3671 3684 3735* 3753* 4310* 4590 4592 4753 4765 4828 4845 4852 4857 4907 4918 4920 5097 5102* ext_attributes 4 based structure level 2 packed packed unaligned dcl 2-844 f_label 004346 automatic fixed bin(18,0) dcl 7525 set ref 7528* 7529 7529* 7532 f_statement 004347 automatic fixed bin(18,0) dcl 7525 set ref 7527* 7528 7529* factor 003675 automatic fixed bin(18,0) dcl 6552 set ref 6605* 6613* 6614 6619 6638* falls_through 15(02) based bit(1) level 3 packed packed unaligned dcl 1-46 set ref 1441* 1474* 2067* 2069 2132* 2903 2920 3029 3053 5273 6090 7483 father 2 based pointer level 2 packed packed unaligned dcl 1-100 set ref 2002 2053 2707* 2726* 3303 4777 4784 5435 6206 6212 6953 7194 7469 fb17 2 based bit(1) level 4 in structure "range" packed packed unaligned dcl 1-243 in procedure "fort_optimizer" set ref 8015 fb17 004730 automatic bit(1) level 2 in structure "range_bits" packed packed unaligned dcl 8264 in procedure "calculate_range_for_counter" set ref 8418* fb17 004662 automatic bit(1) level 2 in structure "range_bits" packed packed unaligned dcl 8125 in procedure "calculate_range_by_subscripts" set ref 8209* fb18_uns 0(01) 004730 automatic bit(1) level 2 in structure "range_bits" packed packed unaligned dcl 8264 in procedure "calculate_range_for_counter" set ref 8420* fb18_uns 0(01) 004662 automatic bit(1) level 2 in structure "range_bits" packed packed unaligned dcl 8125 in procedure "calculate_range_by_subscripts" set ref 8211* fb18_uns 2(01) based bit(1) level 4 in structure "range" packed packed unaligned dcl 1-243 in procedure "fort_optimizer" set ref 8053 8068 finished 004334 automatic bit(1) dcl 7433 set ref 7459* 7461 7468 7470* first_constant 100 based fixed bin(18,0) array level 3 dcl 477 set ref 8-89 8-89* first_element 3(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-436 ref 655 675 first_fu 004360 automatic pointer dcl 7541 set ref 7544* 7547 first_jump_target 14 based pointer level 3 packed packed unaligned dcl 434 set ref 3391 3396 3402 3403* 3423* 4780 4781* first_operator 1 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 1-176 set ref 823 1058 1499 2596* 3541 7231 7499 7555 7738 7-139 first_quad 10 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-753 ref 807 1051 first_statement 005000 automatic fixed bin(18,0) dcl 8436 in procedure "get_starting_value" set ref 8456* 8458 first_statement 004750 automatic fixed bin(18,0) dcl 8267 in procedure "calculate_range_for_counter" set ref 8328* 8332* 8334 8341* 8342 first_statement 004260 automatic fixed bin(18,0) dcl 7306 in procedure "remove_dead_assignments" set ref 7334* 7336 first_statement 13 based fixed bin(18,0) level 2 in structure "flow_unit" packed packed unsigned unaligned dcl 1-46 in procedure "fort_optimizer" set ref 1434* 1830 2065 2180* 2285 2928 2957 3061 3372 3373* 3374 3387* 3456 3459 3520 3536 4892 5275 5277 5278* 6090 7221 7225 7334 7441 7527 7548 7550 7728 7732 7732 8151 8152 8165 8328 8329 8341 8456 8529 first_statement 005046 automatic fixed bin(18,0) dcl 8502 in procedure "is_suitable_loop_exit" set ref 8519* 8522 8529* 8530 first_statement 004672 automatic fixed bin(18,0) dcl 8127 in procedure "calculate_range_by_subscripts" set ref 8151* 8155* 8157 8165* 8166 first_stm 003426 automatic pointer dcl 5259 set ref 5277* 5280 5281 5282 5283 5284 5286 5287 5288 5289 5290 5291 5292 first_subprogram 72 based fixed bin(18,0) level 2 dcl 477 ref 533 first_symbol 3 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-753 ref 703 753 first_unit 13 based pointer level 2 packed packed unaligned dcl 1-100 set ref 1932* 1947 1947 1947* 1947 1969 1969 2736* fixed builtin function dcl 470 ref 809 1053 1593 2097 2292 2294 2301 2301 2580 3539 4533 5193 6216 6329 6408 7101 7101 7229 7553 7626 7628 7736 8097 8146 8447 8517 7-78 7-143 7-148 7-193 7-269 7-275 fixedoverflow 000204 stack reference condition dcl 5479 ref 5518 float builtin function dcl 470 ref 574 580 flow_unit 6 based pointer level 2 in structure "opt_statement" packed packed unaligned dcl 1-176 in procedure "fort_optimizer" set ref 929* 987* 1054 1429 1429 1447* 1463 1466* 1468 1527 1527 1531* 1560 2184* 2604* 2604 4733 4820 5279* 6053 6472 7562* 8164 8340 8528 8558 flow_unit 3 based pointer level 3 in structure "primary" packed packed unaligned dcl 1-234 in procedure "fort_optimizer" set ref 3488 3736* 3754* 3950 3971* 4238 4311* 4952 5424 flow_unit 2 based pointer level 2 in structure "dead_assign_cand" packed packed unaligned dcl 424 in procedure "fort_optimizer" set ref 7279* 7322 flow_unit based structure level 1 dcl 1-46 in procedure "fort_optimizer" set ref 2670 2670 2677* flow_unit_vector based pointer array level 2 packed packed unaligned dcl 368 set ref 1693* 1698 1707* 1733 1815 2055 2056 2056* 2061* 2254 2255* 2255 2258* 2402 2820 flow_unit_vector_p 000116 automatic pointer dcl 228 set ref 1692* 1692 1692 1693 1698 1707 1733 1815 2055 2056 2056 2061 2254 2255 2255 2258 2402 2820 flow_unit_vector_st based structure level 1 dcl 368 set ref 1692 1692 fort_node_templates_$flow_unit_template 000014 external static structure level 1 dcl 2665 ref 2677 fortran_declared based structure level 1 dcl 5-91 fortran_options based structure level 1 dcl 5-40 found 000110 automatic bit(1) dcl 7-242 in procedure "disconnect_temporary" set ref 7-248* 7-251 7-252* 7-260 found 004760 automatic bit(1) dcl 8270 in procedure "calculate_range_for_counter" set ref 8287* 8289 8374* 8376 8377* 8381 found 001156 automatic bit(1) dcl 1685 in procedure "flow_analysis" set ref 1817* 1821 1823* 1827 found parameter bit(1) dcl 8432 in procedure "get_starting_value" set ref 8429 8443* 8483* found 005051 automatic bit(1) dcl 8503 in procedure "is_suitable_loop_exit" set ref 8520* 8522 8535* 8539 found_all_constant 004132 automatic bit(1) dcl 7034 set ref 7039* 7044 7048* 7053 found_new_induction_variable 003625 automatic bit(1) dcl 6010 set ref 6034* 6429 6848* free 24 based pointer array level 2 in structure "shared_globals" dcl 477 in procedure "fort_optimizer" set ref 590* free 000120 automatic pointer array dcl 229 in procedure "fort_optimizer" set ref 510* 590 1606 1607* 1621 1622* 1628 1629* 1894 1895* 2842 2843* 3401 3402* 4361 4364 4365* 4365 4390 4393 4394* 4394 4640 4641* 5007 5008* 5020 5021* 5050 5051* 5063 5066 5067* 5067 5118 5121 5122* 5122 6478 6479* 6484 6485* 6495 6496* 7288 7291 7292* 7292 7383 7384* 8028 8029* 8075 8076* 8402 8403* 8413 8414* 8682 8683* 8698 8699* 7-34 7-37 7-38* 7-38 free_assignment_list parameter bit(1) dcl 8625 ref 8620 8680 free_var_list 001576 automatic pointer dcl 2773 set ref 2785* 2854 2865* 6454 6455* 6746 6751* freed 0(10) based bit(1) level 2 packed packed unaligned dcl 1-144 set ref 2631* 3318 3341 4860 5344* 6050 6138 6363 6384 6397* freefu 000126 automatic pointer dcl 230 set ref 512* 2545 2546* 2670 2673 2674* 2674 freei 32 based pointer level 2 in structure "shared_globals" dcl 477 in procedure "fort_optimizer" set ref 591* freei 000130 automatic pointer dcl 231 in procedure "fort_optimizer" set ref 512* 591 687 688* 5694 5696* 7-94 7-97 7-98* 7-98 freep 000132 automatic pointer dcl 232 set ref 512* 5021 5022* 5094 5103 5104* freep_tail 000134 automatic pointer dcl 233 set ref 512* 5018 5020 5022* 5094* freesrv 000136 automatic pointer dcl 234 set ref 512* 2861 2862* 6807 6810 6811* 6811 from based structure level 2 dcl 1-33 from_unit 001346 automatic pointer dcl 2353 in procedure "unlink" set ref 2355* 2366 from_unit parameter pointer dcl 1642 in procedure "link" ref 1637 1651 1659 1660 frozen_for_do 0(34) based bit(1) level 3 packed packed unaligned dcl 2-1005 set ref 3625 3646 4294* fu 001376 automatic pointer dcl 2391 in procedure "compute_busy_on_exit" set ref 2414* 2415 2417 2419 fu 002016 automatic pointer dcl 3440 in procedure "optimize_flow_unit" set ref 3452* 3456 3459 3463 3474 3478 3508 3517 3518 3520 3520 3528 3528 3536 3730* 3754 3768* 3785* 3793* 3877 3952 3971 4001 4004 4004 fu parameter pointer dcl 5362 in procedure "process_moved_descendants" ref 5352 5405 fu 003566 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6053* 6472* 6474* 6564* fu 004056 automatic pointer dcl 6965 in procedure "force_loop" set ref 6969* 6969* 6970* 6971 fu parameter pointer dcl 7270 in procedure "chain_dac" ref 7265 7279 fu 001554 automatic pointer dcl 2771 in procedure "optimize_subprogram" set ref 2820* 2821 2823 2826 2829 2843 2845 2847 2848 2897* 2897* 2898 2903 2905 2910 2913* 2915 2915 2920 2923 2928 2934* 2935 2956* 2956* 2957 2972 2976* 2977 2981* 2981* 2982 2988* 2989 3021* 3022 3024 3029 3031 3036* 3038 3048 3048 3053 3056 3061 3067 3229 3262 3298* 3372 3373 3374 3377 3378 3379 3380 3382* 3384 3385 3387 4736 fu parameter pointer dcl 7523 in procedure "get_flow_unit_label" ref 7520 7527 fu 004356 automatic pointer dcl 7541 in procedure "remove_units_from_loop" set ref 7547* 7547* 7548 7550 7567 7567 7567 7567 7567 7567 7573* 7574 fu parameter pointer dcl 1788 in procedure "process" ref 1785 1790 1792 1794 1795 1799 1801 fu 004664 automatic pointer dcl 8126 in procedure "calculate_range_by_subscripts" set ref 8148* 8148* 8149 8151 8152 8161 8164* 8165* 8205 fu parameter pointer dcl 2224 in procedure "make_jump_to" ref 2221 2229 2229 fu 004076 automatic pointer dcl 6983 in procedure "replace_tests" set ref 6994* 7005 7005 7109 7110 fu 001200 automatic pointer dcl 2036 in procedure "create_new_back_target" set ref 2056* 2057 2057 fu 003362 automatic pointer dcl 5168 in procedure "move" set ref 5178* 5215 5216 5216 fu 001230 automatic pointer dcl 2153 in procedure "insert_flow_unit_before" set ref 2175* 2175* 2176 2176* 2177 fu 004246 automatic pointer dcl 7305 in procedure "remove_dead_assignments" set ref 7322* 7324 7324 7324 7330* 7334 7336 7366 7368 7374 7375 7376 fu 004736 automatic pointer dcl 8266 in procedure "calculate_range_for_counter" set ref 8325* 8325* 8326 8328 8329 8337 8340* 8341* 8365 fu parameter pointer dcl 4885 in procedure "union" ref 4879 4892 4896 4896 4898 fu parameter pointer dcl 2540 in procedure "unthread_flow_unit" ref 2537 2542 2542 2543 2543 2545 2546 2548 fu 004460 automatic pointer dcl 7681 in procedure "analyze_loop_index_values" set ref 7727* 7727* 7728 7728 7732 7732* 7863 fu 004176 automatic pointer dcl 7208 in procedure "process_flow_units" set ref 7211* 7211* 7212 7217 7221 7221 7225 7240 7245 7253* 7259 fu 005030 automatic pointer dcl 8501 in procedure "is_suitable_loop_exit" set ref 8518* 8522 8525 8528* 8529 8563 fu_to_put 005244 automatic pointer dcl 7-182 set ref 7-187* 7-192 7-194 7-195 7-195 7-205 full_optimization constant fixed bin(18,0) initial dcl 290 set ref 2913* 2983 3036* 3382* 3453 full_strength_reduction 000140 automatic bit(1) dcl 235 set ref 529* 4132 6040 6342 func_ref_op constant fixed bin(18,0) initial dcl 3-197 ref 3596 7346 8466 function_class constant fixed bin(18,0) initial dcl 237 ref 7361 get_next_temp_segment 1534 based entry variable level 2 dcl 477 ref 7-22 global_pr_items 34 based pointer level 2 packed packed unaligned dcl 1-100 set ref 2736* global_xr_items 33 based pointer level 2 packed packed unaligned dcl 1-100 set ref 2736* greater_op constant fixed bin(18,0) initial dcl 3-197 ref 7005 8311 h 000554 automatic pointer dcl 634 set ref 653* 655 675 691 has_constant_value 2(04) based bit(1) level 2 packed packed unaligned dcl 2-844 set ref 3590* 3596 4672* 4998 5047* 5099* has_label 15(03) based bit(1) level 3 packed packed unaligned dcl 1-46 set ref 1470* 1534* 2187* 3377 3378* 3385* 3463 has_multiple_exits 001710 automatic bit(1) dcl 3108 set ref 3175* 3177 3178* 3182 has_operator_list 4(05) based bit(1) level 3 packed packed unaligned dcl 1-176 set ref 2958 2973* 3375 3376* 3386* 3463 4736 4789* 4815 4930* 5280* 5280 5281* has_parameters 0(15) based bit(1) level 2 in structure "subprogram" packed packed unaligned dcl 2-753 in procedure "fort_optimizer" ref 643 has_parameters 000567 automatic bit(1) dcl 636 in procedure "assign_symbol_coordinates" set ref 643* 711 has_side_effects 15(07) based bit(1) level 3 in structure "flow_unit" packed packed unaligned dcl 1-46 in procedure "fort_optimizer" set ref 913* 934* 943* 955* 963* 1416* 2478 has_side_effects 25 based bit(1) level 3 in structure "loop" packed packed unaligned dcl 1-100 in procedure "fort_optimizer" set ref 2478* 2478 2487* 2487 2487 2734* 3162 hash_chain 3(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-63 set ref 8-69 8-78* hash_counter 000445 automatic fixed bin(17,0) array dcl 288 set ref 8720* 8722* 8722 8726* 8729* 8731* 8731 8735* hash_index 002254 automatic fixed bin(18,0) dcl 4262 in procedure "process_frozen_for_do" set ref 4308* 4309 hash_index 002051 automatic fixed bin(18,0) dcl 3447 in procedure "optimize_flow_unit" set ref 3666* 3670 3682 3734 3752 hash_index 000105 automatic fixed bin(17,0) dcl 8-24 in procedure "create_constant" set ref 8-57* 8-61 8-76 8-76 hash_index 001776 automatic fixed bin(18,0) dcl 3296 in procedure "pop_loop" set ref 3324* 3325 3343* 3344 hash_mask 000141 automatic bit(4297) dcl 238 set ref 508* 4977* 5156 5158 5159* hash_mask_index 003340 automatic fixed bin(18,0) dcl 5147 set ref 5156* 5158 5159 hash_table based fixed bin(35,0) array dcl 8-25 set ref 8-61 8-76 8-76* hash_table_size 044105 constant fixed bin(17,0) initial dcl 8-26 ref 8-57 have_eligible_variable 004633 automatic bit(1) dcl 7980 set ref 7997* 7999 8003* 8006 have_opt_subscript 003066 automatic bit(1) dcl 4656 set ref 4659* 4664 4668 have_sr_candidate 002057 automatic bit(1) dcl 3449 set ref 3557* 3779* 3785 have_test_replacement_candidate 003624 automatic bit(1) dcl 6009 set ref 6032* 6312* 6433 hbound builtin function dcl 470 in procedure "fort_optimizer" ref 481 481 579 696 3142 3200 3211 3234 3485 4603 4623 4627 4749 4761 4824 4903 4916 4970 5492 5722 6310 6678 7060 8719 8728 hbound builtin function dcl 8-27 in procedure "create_constant" ref 8-43 hdr 000565 automatic fixed bin(18,0) dcl 635 set ref 652* 652* 653* head 002376 automatic fixed bin(18,0) dcl 4525 set ref 4530* 4538 header based structure level 1 dcl 2-436 hfp 12(04) based bit(1) level 3 packed packed unaligned dcl 2-753 ref 5856 5875 highest 2 based fixed bin(18,0) level 2 dcl 429 set ref 668* 681 highest_reducible_class constant fixed bin(18,0) initial dcl 240 ref 2636 3656 hold_ass_chain 12 based pointer level 3 packed packed unaligned dcl 434 set ref 3225* 3361 hold_bt_list 6 based pointer level 3 packed packed unaligned dcl 434 set ref 3218* 3334 3335* hold_entry_pt 001750 automatic bit(1) dcl 3294 set ref 3379* 3384 hold_first_statement 001777 automatic fixed bin(18,0) dcl 3296 set ref 3372* 3387 hold_has_label 001746 automatic bit(1) dcl 3294 set ref 3377* 3385 hold_has_operator_list 001747 automatic bit(1) dcl 3294 set ref 3375* 3386 hold_incr_chain 7 based pointer level 3 packed packed unaligned dcl 434 set ref 3222* 3358 hold_list 001730 automatic pointer dcl 3194 in procedure "push_loop" set ref 3198* 3202* 3207 3209* 3213* 3218 hold_list 001756 automatic pointer dcl 3295 in procedure "pop_loop" set ref 3311* 3314 3331* 3334* 3337 3351* hold_p_list 5 based pointer level 3 packed packed unaligned dcl 434 set ref 3207* 3311 3312* hold_sr_chain 10 based pointer level 3 packed packed unaligned dcl 434 set ref 3223* 3359 hold_sr_tail 11 based pointer level 3 packed packed unaligned dcl 434 set ref 3224* 3360 how_much parameter fixed bin(18,0) dcl 3442 ref 3429 3528 i 001412 automatic fixed bin(17,0) dcl 2466 in procedure "summarize_loop_usage" set ref 2469* 2470* i 000702 automatic fixed bin(18,0) dcl 1172 in procedure "use_one_input" set ref 1177* 1178 1191 1193 1198 1202 1206* 1211* i 000331 automatic fixed bin(18,0) dcl 241 in procedure "fort_optimizer" set ref 579* 580 581 581* i 001602 automatic fixed bin(18,0) dcl 2779 in procedure "optimize_subprogram" set ref 2791* 2792* 2819* 2820* i 001430 automatic fixed bin(17,0) dcl 2498 in procedure "summarize_loop_busy_on_exit" set ref 2501* 2502* i 001706 automatic fixed bin(18,0) dcl 3106 in procedure "finish_loop" set ref 3142* 3144* i 004261 automatic fixed bin(18,0) dcl 7306 in procedure "remove_dead_assignments" set ref 7352* 7353* i 005304 automatic fixed bin(17,0) dcl 8716 in procedure "print_hash_bucket_meters" set ref 8719* 8720 8721 8722 8722* 8728* 8729 8730 8731 8731* i 002233 automatic fixed bin(18,0) dcl 4124 in procedure "check_increment" set ref 4165* 4165* 4168 4173 4184 4188 4189 i 002042 automatic fixed bin(18,0) dcl 3447 in procedure "optimize_flow_unit" set ref 3485* 3486* 3562* 3563 3571 3573* 3596 3599 3603 3605* 3612* 3808* 3810 3810* 3826* 3828* 3833* 3835* 3850* 3851 3851* i 003337 automatic fixed bin(18,0) dcl 5147 in procedure "hash" set ref 5152* 5153* i 001011 automatic fixed bin(17,0) dcl 1489 in procedure "get_final_target" set ref 1492* 1503 1513* 1513 i 005273 automatic fixed bin(18,0) dcl 7-287 in procedure "in_namelist" set ref 7-292* 7-293* i 003254 automatic fixed bin(18,0) dcl 4968 in procedure "clear" set ref 4970* 4971* i parameter fixed bin(18,0) dcl 5034 in procedure "release_node" ref 5027 5044 i 005001 automatic fixed bin(18,0) dcl 8436 in procedure "get_starting_value" set ref 8471* 8472* i 003674 automatic fixed bin(18,0) dcl 6551 in procedure "reduce" set ref 6642* 6643* i 000664 automatic fixed bin(18,0) dcl 1159 in procedure "use_inputs" set ref 1161* 1162* i parameter fixed bin(18,0) dcl 5061 in procedure "create_o_node" ref 5057 i 003065 automatic fixed bin(18,0) dcl 4655 in procedure "record_secondaries" set ref 4662* 4664 4664* 4671* 4672 4675* i 002272 automatic fixed bin(18,0) dcl 4333 in procedure "decrement_input_ref_counts" set ref 4338* 4339* i 003222 automatic fixed bin(18,0) dcl 4890 in procedure "union" set ref 4903* 4904* 4916* 4917* i 004552 automatic fixed bin(17,0) dcl 7935 in procedure "disqualify_inputs" set ref 7937* 7938* i 000117 automatic fixed bin(18,0) dcl 5462 in procedure "constant_expression" set ref 5499* 5500 5503 5505 5507 5507 5508 5508* 5675* 5676 5776 5776 i 002212 automatic fixed bin(18,0) dcl 4065 in procedure "check_str_reducibility" set ref 4078* 4079 4084 4087 4092* 4105* 4107* 4111* i 003146 automatic fixed bin(18,0) dcl 4721 in procedure "process_jump_label" set ref 4749* 4750* 4761* 4762* i 004476 automatic fixed bin(17,0) dcl 7689 in procedure "analyze_loop_index_values" set ref 7807* 7808 7810 7812 7812* 7848* 7849 7849* i 003604 automatic fixed bin(18,0) dcl 6005 in procedure "reduce_strength" set ref 6315* 6316 6317* 6449* 6450 6450 i 000100 automatic fixed bin(18,0) dcl 1729 in begin block on line 1724 set ref 1732* 1733* i parameter fixed bin(18,0) dcl 4355 in procedure "chain_sr_cand" ref 4350 4369 i 000564 automatic fixed bin(18,0) dcl 635 in procedure "assign_symbol_coordinates" set ref 749* 750 750* 758* 760 763 768 769 i 003174 automatic fixed bin(18,0) dcl 4803 in procedure "intersection" set ref 4807* 4809 4822 4850 4874 i 002162 automatic fixed bin(18,0) dcl 3936 in procedure "common" set ref 4003* 4004 4004 4004 4004 i parameter fixed bin(18,0) dcl 4027 in procedure "have_identity" ref 4019 4033 4033 4033 4036 i 003440 automatic fixed bin(18,0) dcl 5364 in procedure "process_moved_descendants" set ref 5379* 5380 5398* i 004203 automatic fixed bin(18,0) dcl 7209 in procedure "process_flow_units" set ref 7236* 7237* i 004126 automatic fixed bin(18,0) dcl 7033 in procedure "change_test" set ref 7085* 7086 7087 7091* i 003367 automatic fixed bin(18,0) dcl 5173 in procedure "move" set ref 5220* 5221 5226* i 000732 automatic fixed bin(18,0) dcl 1306 in procedure "set" set ref 1329* 1330 1332 1332 1334 1351 1381 i 002126 automatic fixed bin(18,0) dcl 3885 in procedure "compare_expression" set ref 3903* 3904 3904* i 000746 automatic fixed bin(18,0) dcl 1392 in procedure "process_call" set ref 1398* 1399 1399* i parameter fixed bin(18,0) dcl 600 in procedure "timer" ref 595 625 i 004410 automatic fixed bin(18,0) dcl 7584 in procedure "remove_operator" set ref 7588* 7589* i parameter fixed bin(18,0) dcl 7-66 in procedure "chain_input" ref 7-62 7-77 i 001366 automatic fixed bin(17,0) dcl 2390 in procedure "compute_busy_on_exit" set ref 2400* 2402* i 001152 automatic fixed bin(18,0) dcl 1684 in procedure "flow_analysis" set ref 1697* 1697* 1698* 1814* 1815* 1870* 1870* 1871 1874* 1911* 1912* 1943* 1944* 1964* 1965* 2008* 2009* i 004444 automatic fixed bin(17,0) dcl 7666 in procedure "index_value_analysis" set ref 7669* 7670 7670* i 000616 automatic fixed bin(18,0) dcl 785 in procedure "build_flow_units" set ref 871* 872* 880* 881* 938* 939* 947* 948 948* 966* 967* 970* 971 971 971* 976 976* 1034* 1035* 1101* 1102* 1108* 1109 1109* 1119* 1121* 1124* 1125 1125 1125* 1130 1130* i 003716 automatic fixed bin(18,0) dcl 6674 in procedure "search_for_equivalent" set ref 6684* 6685 6688 6692* i 001720 automatic fixed bin(18,0) dcl 3193 in procedure "push_loop" set ref 3200* 3201* 3211* 3212* 3234* 3237 3247 3248 3248 3250 3250 3251 3251 3252* idx_of_e 000110 automatic fixed bin(17,0) dcl 5837 set ref 5861* 5862 5864 5865 5866 5880* 5881 5883 5884 5885 ignore_articulation_blocks 11(26) based bit(1) level 4 packed packed unaligned dcl 2-753 ref 538 in_common 005006 automatic bit(1) dcl 8438 in procedure "get_starting_value" set ref 8448* 8468 in_common 004264 automatic bit(1) dcl 7307 in procedure "remove_dead_assignments" set ref 7321* 7346 in_common 11(02) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 2-844 in procedure "fort_optimizer" ref 711 766 4457 4511 4538 7321 8448 in_dt 003514 automatic fixed bin(4,0) dcl 5907 set ref 5921* 5926 5928 in_equiv_stmnt 11(08) based bit(1) level 3 packed packed unaligned dcl 2-844 set ref 658 678 681* 711 725 4465 4538 in_queue 15(05) based bit(1) level 3 packed packed unaligned dcl 1-46 set ref 2415* 2429 2435* inc_found 003621 automatic bit(1) dcl 6007 set ref 6059* 6062 6064* 6069 inc_found_before 003622 automatic bit(1) dcl 6007 set ref 6032* 6085 6095* incr based structure level 1 dcl 418 set ref 4390 4390 4390 4393 4394 4394 6484 6485 6495 6496 incr_chain parameter pointer dcl 4386 in procedure "chain_incr" set ref 4381 4400 4401* incr_chain 001570 automatic pointer dcl 2772 in procedure "optimize_subprogram" set ref 2789* 3096* 3222 3358* 4145* 4250* 6060 6443 6482 6485 6499* 6863* 6864* 6912 6913* 6986 incrc 003542 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6060* 6062 6063 6066* 6066 6245 6291 6292 6443* 6443* 6447 6458 6459* 6460 6489* 6489* 6490* 6491 6678 6863 incrc 004066 automatic pointer dcl 6983 in procedure "replace_tests" set ref 6986* 6986* 6987 6991* 7025 7043 increment 004766 automatic fixed bin(18,0) dcl 8272 in procedure "calculate_range_for_counter" set ref 8286* 8291 8311 8311 8313 8313 8388 8394 increment 004700 automatic fixed bin(35,0) dcl 8128 in procedure "calculate_range_by_subscripts" set ref 8145* 8190 8194 incrp 004070 automatic pointer dcl 6983 in procedure "replace_tests" set ref 6987* 6988 7121 7123 7124* 7130* incrp 003536 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6063* 6064 6110 6113 6117 6119 6216 6226 incrp 002230 automatic pointer dcl 4123 in procedure "check_increment" set ref 4173* 4174 4174 4176 4206 4206 4212* 4230 4233 4233 4233 4238 4238 4238 ind_used 004162 automatic bit(1) dcl 7163 set ref 7180* 7182 7189 indp 004072 automatic pointer dcl 6983 set ref 6989* 6991 7109 7134 7135 7136 induction_boe_from_bt 003626 automatic bit(1) dcl 6011 set ref 6081* 6165 6198 6200 6208 6367 6558 induction_busy_on_exit 003623 automatic bit(1) dcl 6008 set ref 6078* 6312 induction_var 004152 automatic fixed bin(18,0) dcl 7152 in procedure "used_in_loop" set ref 7166* 7167 7237 7249* induction_var 003605 automatic fixed bin(18,0) dcl 6005 in procedure "reduce_strength" set ref 6055* 6064 6078 6081 induction_var 26 based pointer level 2 in structure "loop" packed packed unaligned dcl 1-100 in procedure "fort_optimizer" set ref 2717* 2726* 4141 4144 4248 6204 6868 6899 6905 7708 8351 8360 induction_var 004100 automatic fixed bin(18,0) dcl 6984 in procedure "replace_tests" set ref 6988* 6989 6994* 7012 inequality_found 003721 automatic bit(1) dcl 6675 set ref 6682* 6684 6687* 6693* 6701 info 15 based structure level 2 packed packed unaligned dcl 1-46 init 5 based fixed bin(18,0) level 3 dcl 6014 set ref 6171 6175 6589* init_frame 000332 automatic pointer dcl 242 set ref 512* 6100 6100 6102* 6129 6227 6229 6245 6297 init_lp_frame 000334 automatic pointer dcl 243 set ref 512* 3009 3009* 3011 initial based structure level 1 dcl 638 in procedure "assign_symbol_coordinates" initial 13(07) based fixed bin(18,0) level 2 in structure "symbol" packed packed unsigned unaligned dcl 2-844 in procedure "fort_optimizer" set ref 714 722* 722 937 946 1099 1106 1191 1193 3848 7846 7-290 inp 005106 automatic pointer dcl 8627 in procedure "process_assignment_list" set ref 8639* 8642* 8648 8660* 8664* 8671 8673 inp 3 based pointer level 3 in structure "sr_frame" packed packed unaligned dcl 6014 in procedure "reduce_strength" set ref 6131 6132 6133* 6587* inp 002446 automatic pointer dcl 4581 in procedure "free_them" set ref 4609* 4609* 4613 4615* 4632 inp 002226 automatic pointer dcl 4123 in procedure "check_increment" set ref 4128* 4130 4132 4141 4147 4147 4147 4157 4196 4205* inp 003550 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6132* 6133 6135 6136 6154* 6337* 6355* 6356* 6382* 6382* 6384 6384 6389* 6390 inp 005032 automatic pointer dcl 8501 in procedure "is_suitable_loop_exit" set ref 8545* 8545* 8546 8548* 8566 inp 000102 automatic pointer dcl 4411 in procedure "replace_inputs" set ref 4415* 4415* 4416 4416 4416 4418 4418 4420* 4421 inp 003510 automatic pointer dcl 5906 in procedure "constant_assign" set ref 5918* 5921 5928 5943 5950 5960 5960 inp 002176 automatic pointer dcl 4031 in procedure "have_identity" set ref 4038* 4040* 4045 inp 000104 automatic pointer dcl 7-241 in procedure "disconnect_temporary" set ref 7-249* 7-251 7-252 7-255 7-256* 7-256 7-268 7-269 7-273 7-275 inp 000106 automatic pointer dcl 5455 in procedure "constant_expression" set ref 5669* 5669* 5670 5671 5673 5680* 5683 input 004130 automatic fixed bin(18,0) dcl 7033 in procedure "change_test" set ref 7091* 7093* 7095* input 002235 automatic fixed bin(18,0) dcl 4124 in procedure "check_increment" set ref 4127* 4128 input_to based structure level 1 dcl 1-87 set ref 7-94 7-94 ins 001172 automatic pointer dcl 2034 in procedure "create_new_back_target" set ref 2044* 2047* 2067 ins 001226 automatic pointer dcl 2149 in procedure "insert_flow_unit_before" set ref 2156* 2162 2169 2170 2171 2172 2175 insert_delta 003614 automatic fixed bin(18,0) dcl 6005 set ref 6093* 6094* 6632* 6632 6633 6634* 6637* 6638* 7089* 7089 7095* 7096* 7098* 7098 insert_new 003620 automatic fixed bin(18,0) dcl 6005 set ref 6216* 6234* 6234 6238* 6239* 6242* 6242 6245 6245 6265* insert_operator 14(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 1-46 set ref 5189 5191 5196* 5297* 6093 6094* 6171 6179* 6329 6329* 6408 6408* 6589 7336 7490 7490* 8060 8458 7-144* 7-149* insert_statement 14 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 1-46 set ref 3268 3268 3270 5181 5263 5296* 7-143* 7-147* int_image based fixed bin(35,0) dcl 7691 ref 7785 8145 8187 8286 8308 8384 8482 int_mode 001124 constant fixed bin(4,0) initial dcl 3-106 set ref 523* 526* 763 3779 3803 5776 5778 5868 6768 6769 6831 7415 7647* int_source based fixed bin(18,0) array level 2 dcl 5469 set ref 5657* 5676 5778 5778 int_value 000111 automatic fixed bin(35,0) dcl 5837 set ref 5870* 5871 integer 10(20) based bit(1) level 5 packed packed unaligned dcl 2-844 set ref 6772* integer_scalar_mask based bit dcl 244 set ref 744 744 763* 6796* 7708 7714 7721 integer_scalar_mask_p 000336 automatic pointer dcl 245 set ref 744* 744 744 763 6796 7708 7714 7721 invariant 0(31) based bit(1) level 3 in structure "array_ref" packed packed unaligned dcl 2-155 in procedure "fort_optimizer" ref 3582 3711 invariant 0(31) based bit(1) level 3 in structure "temporary" packed packed unaligned dcl 2-1005 in procedure "fort_optimizer" set ref 3240* 3321* 3633 3661* 3955* 4087 4238 4300* 5246* 6534 6566* invariant 002052 automatic bit(1) dcl 3449 in procedure "optimize_flow_unit" set ref 3560* 3582* 3582 3586* 3615* 3633* 3633 3646* 3682 3701 3711* 3711 3712 3719* 3725 invariant_opnd 004125 automatic fixed bin(18,0) dcl 7033 set ref 7074* 7075 7091 invp 004120 automatic pointer dcl 7032 set ref 7075* 7077 7077* 7080 7080 ioa_ 000010 constant entry external dcl 468 ref 577 581 584 585 8726 8735 iop parameter fixed bin(18,0) dcl 1300 in procedure "set" ref 1295 1321 iop parameter fixed bin(18,0) dcl 1172 in procedure "use_one_input" ref 1167 1177 ipol 000615 automatic fixed bin(17,0) dcl 784 in procedure "build_flow_units" set ref 937* 938 939 946* 947 948 948 1099* 1101 1102 1106* 1108 1109 1109 ipol 005274 automatic fixed bin(18,0) dcl 7-287 in procedure "in_namelist" set ref 7-290* 7-292 7-293 ipol 004500 automatic fixed bin(18,0) dcl 7690 in procedure "analyze_loop_index_values" set ref 7846* 7848 7849 7849 ipol 002021 automatic fixed bin(18,0) dcl 3445 in procedure "optimize_flow_unit" set ref 3848* 3850 3851 3851 irreducible 0(32) based bit(1) level 3 in structure "temporary" packed packed unaligned dcl 2-1005 in procedure "fort_optimizer" set ref 3631 3855* 4294* irreducible 0(32) based bit(1) level 3 in structure "array_ref" packed packed unaligned dcl 2-155 in procedure "fort_optimizer" ref 3580 3641 is_active_operator 24 based pointer level 2 packed packed unaligned dcl 1-46 set ref 2972 4743 4743* 4745 4820 4896 4896* 4898 is_addressable 0(14) based bit(1) level 3 packed packed unaligned dcl 2-256 set ref 8-83* is_articulation_block 002053 automatic bit(1) dcl 3449 set ref 3518* 3701 is_back_target 15(06) based bit(1) level 3 packed packed unaligned dcl 1-46 set ref 1974* 3038 is_exit 16 based pointer level 2 packed packed unaligned dcl 1-100 set ref 1019* 2001 2715* 2726* 7005 is_loop_invariant 002214 automatic bit(1) array dcl 4066 set ref 4076* 4076* 4084* 4087* 4092* 4102 4102 4105 is_member 15 based pointer level 2 packed packed unaligned dcl 1-100 set ref 1018* 1983 2010 2714* 2726* is_temp_or_array_ref 002236 automatic bit(1) dcl 4125 set ref 4174* 4206 4212 j 001274 automatic fixed bin(18,0) dcl 2243 in procedure "splice_in_another_fu" set ref 2254* 2254* 2255 2255* 2258 j 003617 automatic fixed bin(18,0) dcl 6005 in procedure "reduce_strength" set ref 6232* 6238* 6239 6239 6245* j 003175 automatic fixed bin(18,0) dcl 4803 in procedure "intersection" set ref 4824* 4825* 4862* 4863 j 001212 automatic fixed bin(18,0) dcl 2037 in procedure "create_new_back_target" set ref 2055* 2055* 2056 2056* 2061 2112* 2114 2114* 2120* 2121 2121* j 001367 automatic fixed bin(17,0) dcl 2390 in procedure "compute_busy_on_exit" set ref 2406* 2409 2410* 2410 2411 2411* 2414 j 000101 automatic fixed bin(18,0) dcl 1729 in begin block on line 1724 set ref 1767* 1767* 1768* j 002452 automatic fixed bin(18,0) dcl 4582 in procedure "free_them" set ref 4595* 4601 4602* 4602 4603 4603* 4606 4625 j 001603 automatic fixed bin(18,0) dcl 2779 in procedure "optimize_subprogram" set ref 2826* 2832 2839* 2839 j 004131 automatic fixed bin(18,0) dcl 7033 in procedure "change_test" set ref 7087* 7095* 7096 7096 j_operator 004335 automatic fixed bin(18,0) dcl 7434 in procedure "remove_loop" set ref 7490* 7492 7499* 7500 j_operator 001262 automatic fixed bin(18,0) dcl 2227 in procedure "make_jump_to" set ref 2230* 2231 j_statement 004336 automatic fixed bin(18,0) dcl 7434 in procedure "remove_loop" set ref 7497* 7498 j_statement 001263 automatic fixed bin(18,0) dcl 2227 in procedure "make_jump_to" set ref 2229* 2230* jop 004330 automatic pointer dcl 7432 in procedure "remove_loop" set ref 7500* 7502 7504* jop 005034 automatic pointer dcl 8501 in procedure "is_suitable_loop_exit" set ref 8548* 8551 8556 jst 004332 automatic pointer dcl 7432 set ref 7498* 7499 jump_arithmetic_op constant fixed bin(18,0) initial dcl 3-197 ref 2112 7999 8015 8017 8304 jump_assigned_list 000620 automatic pointer dcl 788 set ref 795* 997 1549 1550* 1588 1607 1608* jump_assigned_target_list 000622 automatic pointer dcl 788 set ref 795* 997 1569 1570* 1613 1629 1630* jump_computed_op constant fixed bin(18,0) initial dcl 3-197 ref 2118 jump_false_op constant fixed bin(18,0) initial dcl 3-197 ref 2103 8551 jump_op constant fixed bin(18,0) initial dcl 3-197 set ref 1503 2100 2230* 7490* 7-141 jump_true_op constant fixed bin(18,0) initial dcl 3-197 ref 2103 k 001604 automatic fixed bin(18,0) dcl 2779 set ref 2827* 2830 2832* 2833* 2837 2838* 2838 lab parameter fixed bin(18,0) dcl 4718 in procedure "process_jump_label" ref 4715 4723 lab parameter fixed bin(18,0) dcl 1484 in procedure "get_final_target" set ref 1479 1496 1505* lab parameter fixed bin(18,0) dcl 1456 in procedure "link_to_target" set ref 1451 1461* lab 005036 automatic pointer dcl 8501 in procedure "is_suitable_loop_exit" set ref 8556* 8557 label 0(18) based fixed bin(18,0) level 2 in structure "opt_statement" packed packed unsigned unaligned dcl 1-176 in procedure "fort_optimizer" set ref 811 811 811 2065 2526* 5284 5286* 5286 5287 5288* 7528 7561* label based structure level 1 dcl 2-530 in procedure "fort_optimizer" set ref 2523 2523 label_node 001105 constant fixed bin(4,0) initial dcl 3-87 set ref 922 2523* large_offset 0(34) based bit(1) level 3 packed packed unaligned dcl 2-155 ref 7761 last 003744 automatic pointer dcl 6739 in procedure "create_var" set ref 6745* 6749 6749 6754* last 001076 automatic pointer dcl 1584 in procedure "connect_jump_assigneds" set ref 1586* 1601* 1604 1606 1618* 1618* 1619 1621 last 000541 automatic fixed bin(18,0) dcl 603 in procedure "timer" set ref 618* 619 619 620 620 last 003136 automatic pointer dcl 4720 in procedure "process_jump_label" set ref 4774* 4777 4783* last 005176 automatic pointer dcl 7-71 in procedure "chain_input" set ref 7-82* 7-83 last 004250 automatic pointer dcl 7305 in procedure "remove_dead_assignments" set ref 7315* 7379* 7383 last 003574 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6227* 6229 6245 6249* 6442* 6459* 6484 6488* 6490* 6493 6495 last 1 based pointer level 2 in structure "primary" packed packed unaligned dcl 1-234 in procedure "fort_optimizer" set ref 3248* 3251* 5038* 5038 5040 5042 5053* 5070* 5072* 5090* 5090 5092 5106* 5125* 5127* last 000106 automatic pointer dcl 7-241 in procedure "disconnect_temporary" set ref 7-247* 7-255* 7-266 7-268 7-269 last_assigned_mode constant fixed bin(4,0) initial dcl 3-106 ref 696 696 702 last_assigned_op constant fixed bin(18,0) initial dcl 3-197 ref 481 481 last_c 004740 automatic pointer dcl 8266 in procedure "calculate_range_for_counter" set ref 8369* 8371* 8400 8402 8406* 8408* 8411 8413 last_c parameter pointer dcl 8691 in procedure "remove" ref 8688 8694 8694 last_c 004620 automatic pointer dcl 7978 in procedure "process_comparison_list" set ref 7988* 7991* 8026 8028 8040* 8044* 8073 8075 last_c 005110 automatic pointer dcl 8627 in procedure "process_assignment_list" set ref 8634* 8642* 8647* 8653* 8680 8682 last_c 001772 automatic pointer dcl 3295 in procedure "pop_loop" set ref 3395* 3398* 3401 last_c 001100 automatic pointer dcl 1584 in procedure "connect_jump_assigneds" set ref 1611* 1615* 1626 1628 last_constant 101 based fixed bin(18,0) array level 3 dcl 477 set ref 8-91 8-93* last_frame parameter pointer dcl 6716 ref 6710 6723 6724 6724 last_fu 3 based pointer level 3 in structure "lp_frame" packed packed unaligned dcl 434 in procedure "fort_optimizer" set ref 3024 3067* 3098* last_fu 001640 automatic pointer dcl 2874 in procedure "optimize_loop" set ref 2895* 2898 2934* last_label 4(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-753 set ref 2530 2531* last_o 001516 automatic pointer dcl 2617 in procedure "insert_operator_after" set ref 2650* 2651 2652 2654 last_o 001320 automatic pointer dcl 2277 in procedure "detach_flow_units" set ref 2297* 2306 last_operator 001471 automatic fixed bin(18,0) dcl 2561 in procedure "insert_statement_after" set ref 2587* 2588 2597 last_operator 001327 automatic fixed bin(18,0) dcl 2278 in procedure "detach_flow_units" set ref 2296* 2297 2308 last_operator parameter fixed bin(18,0) dcl 2613 in procedure "insert_operator_after" ref 2610 2650 2653 last_p parameter pointer dcl 3413 in procedure "create_lp_frame" ref 3408 3420 3421 3421 last_p 001736 automatic pointer dcl 3194 in procedure "push_loop" set ref 3235* 3242* 3245 3247 3248 last_pf 2 000460 automatic fixed bin(18,0) level 2 dcl 455 set ref 611* 620 622* last_section 3 000460 automatic fixed bin(18,0) level 2 dcl 455 set ref 517* 609 618 625* last_son 6 based pointer level 2 packed packed unaligned dcl 1-100 set ref 1914 2708 2709* 2736* last_statement 001325 automatic fixed bin(18,0) dcl 2278 in procedure "detach_flow_units" set ref 2294* 2295 last_statement parameter fixed bin(18,0) dcl 2558 in procedure "insert_statement_after" ref 2552 2579 2593 last_statement 004431 automatic fixed bin(18,0) dcl 7623 in procedure "free_statement" set ref 7628* 7629 last_statement 13(18) based fixed bin(18,0) level 2 in structure "flow_unit" packed packed unsigned unaligned dcl 1-46 in procedure "fort_optimizer" set ref 988* 1592 2096 2133* 2133 2162 2179 2181* 2229 2229* 2290 2823 2845* 5273* 5275 6090 7005 7497 7-137 last_symbol 3(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-753 set ref 6779 6780* last_temp 004127 automatic fixed bin(18,0) dcl 7033 set ref 7093 7098* 7101* 7107 7107 last_unit 14 based pointer level 2 packed packed unaligned dcl 1-100 set ref 1938* 1950 1950 1950* 1950 2736* 3149 5430 5432 7-187 last_vcpu 000460 automatic fixed bin(71,0) level 2 dcl 455 set ref 611* 619 621* lastc 002450 automatic pointer dcl 4581 in procedure "free_them" set ref 4585* 4635* 4638 4640 lastc 001142 automatic pointer dcl 1683 in procedure "flow_analysis" set ref 1848* 1886* 1894 lastc 001622 automatic pointer dcl 2780 in procedure "optimize_subprogram" set ref 2836* 2842 lastc 003274 automatic pointer dcl 4991 in procedure "detach_secondaries" set ref 5000* 5002* 5005 5007 lastop 001502 automatic pointer dcl 2562 set ref 2588* 2599 lastp 001472 automatic pointer dcl 2562 set ref 2579* 2580 2594 2603 2604 lbits based bit dcl 381 set ref 1908 1908 1909* 1920 1920 1921* 1921 1922* 2855 5428 6450* 6450 6450 6747 6760 6760 7515 lchain based structure level 1 dcl 1-94 left 004026 automatic pointer dcl 6878 in procedure "find_new_induction_vars_on_ass_chain" set ref 6896* 6905 left 004000 automatic pointer dcl 6846 in procedure "add_new_induction_var" set ref 6852* 6868 left_shift_chain 40 based pointer level 2 packed packed unaligned dcl 1-100 set ref 2736* length 4 based fixed bin(18,0) level 2 in structure "char_constant" packed packed unsigned unaligned dcl 2-316 in procedure "fort_optimizer" ref 5943 5950 5960 5960 length parameter fixed bin(17,0) dcl 9-12 in procedure "create_node" ref 9-10 9-20 9-23 9-24 length builtin function dcl 470 in procedure "fort_optimizer" ref 499 696 749 756 1261 1351 5156 5859 5859 5878 5878 less_op constant fixed bin(18,0) initial dcl 3-197 ref 7005 8313 level_number 12 based fixed bin(17,0) level 2 dcl 1-46 set ref 1694* 1699 1703 1705* 1743 1749 1751 1770 1792 1794 2049* 2049 2248* 2248 2283 3481 3488 line 3(08) based bit(14) level 3 packed packed unaligned dcl 1-176 set ref 2301 2301 list_head parameter pointer dcl 5033 in procedure "release_node" set ref 5027 5040* list_head parameter pointer dcl 5060 in procedure "create_o_node" set ref 5057 5071 5072 5072 5074* list_head parameter pointer dcl 7961 in procedure "chain_it" set ref 7958 7968 7969* list_head parameter pointer level 2 in structure "list_head_st" packed packed unaligned dcl 5113 in procedure "create_primary" set ref 5125 5126 5127 5127 5129* list_head_st parameter structure level 1 dcl 5113 set ref 5110 literal_expression 000140 automatic varying char(70) dcl 5473 set ref 5717* 5718* 5718 5719* 5719 5721* 5722* 5722 5724* 5724 5728* 5728 5729* 5729 5730* 5730 5732* 5732 5736* 5740* 5740 5741* 5741 5742* 5742 5744* 5744 5748* 5749* 5749 5751* 5751 5755* 5756* 5756 5758* 5758 5762* 5763* 5763 5765* 5765 5769* 5770* 5770 5772* 5772 5776* 5777* 5777 5778* 5780* 5781 literal_operand 000163 automatic varying char(33) dcl 5473 set ref 5714* 5715 5718 5721 5725* 5726 5729 5732 5737* 5738 5741 5744 literal_operator 000345 constant varying char(4) initial array dcl 5473 ref 5722 5722 5722 location 5 based bit(18) level 2 packed packed unaligned dcl 1-176 set ref 2573* loop 5 based pointer level 2 in structure "flow_unit" packed packed unaligned dcl 1-46 in procedure "fort_optimizer" set ref 1856 1857* 1881* 1932 1938 1982 1991 2053* 2053 2252* 2252 2679* 2905 2923 2982 3031 3056 3229 3474 3517 3952 3952 3952 4238 4759 4773 4952 5424 7514 8558 8563 loop based structure level 1 dcl 1-100 in procedure "fort_optimizer" set ref 2700 2700 loop_end_chain 7 based pointer level 2 packed packed unaligned dcl 1-46 set ref 2829 2843 2848* 7-192 7-194* loop_end_fu_pos 3(18) based fixed bin(17,0) level 2 packed packed unaligned dcl 2-1005 set ref 3149 3149 5439 6280 7-205* loop_end_op 000375 constant fixed bin(18,0) initial dcl 3-197 set ref 2833* loop_entry 15(01) based bit(1) level 3 packed packed unaligned dcl 1-46 set ref 1839* 2910 3508 loop_entry_list 000340 automatic pointer dcl 246 set ref 512* 1810* 1836 1837* 1850 1889 1895 1896* loop_vector based pointer array level 2 packed packed unaligned dcl 372 set ref 1035 1905* 1912 1917* 1944 1965 2009 2470 2502 2792 7670 loop_vector_p 55 based pointer level 2 in structure "subprogram" packed packed unaligned dcl 2-753 in procedure "fort_optimizer" set ref 1902* loop_vector_p 000342 automatic pointer dcl 247 in procedure "fort_optimizer" set ref 1035 1902 1902 1902* 1905 1912 1917 1944 1965 2009 2470 2502 2792 7670 loop_vector_st based structure level 1 dcl 372 set ref 1902 1902 lower_bound 004677 automatic fixed bin(35,0) dcl 8128 in procedure "calculate_range_by_subscripts" set ref 8141* 8178* 8178 8190* 8190 8201* 8201 8209 8211 lower_bound 004754 automatic fixed bin(35,0) dcl 8268 in procedure "calculate_range_for_counter" set ref 8294* 8298* 8311 8313* 8317 8396* 8396 8418 8420 lowest 1 based fixed bin(18,0) level 2 dcl 429 set ref 667* 681 lowest_fu 000116 automatic pointer dcl 1730 set ref 1745* 1752* 1756 1757 1763* 1778 1795* lowest_level 000103 automatic fixed bin(18,0) dcl 1729 set ref 1744* 1749 1751* 1762* 1792 1794* lp 001414 automatic pointer dcl 2467 in procedure "summarize_loop_usage" set ref 2470* 2472 2473 2473 2473 2476 2476 2477 2477 2478 2478 2481 2482 2482 2482 2485 2485 2486 2486 2487 2487 lp parameter pointer dcl 8606 in procedure "create_range" ref 8603 8613 8614 lp parameter pointer dcl 7206 in procedure "process_flow_units" ref 7203 7211 lp 000600 automatic pointer dcl 783 in procedure "build_flow_units" set ref 1035* 1036 1036 1036 1036 lp parameter pointer dcl 6927 in procedure "force_used_in_loop" ref 6922 6933 lp 001636 automatic pointer dcl 2872 in procedure "optimize_loop" set ref 2878* 2881 2882 2891 2891 2891 2897 lp parameter pointer dcl 7430 in procedure "remove_loop" ref 7425 7436 lp 001556 automatic pointer dcl 2771 in procedure "optimize_subprogram" set ref 2792* 2793* 2982* 2983 2986 3013* 3018 3093 3094 3097 3113 3114 3114 3119 3126* 3149 3149* 3162 3162 3162 3168 3174 3177 3182* 3274* 3284 3284 3284 3298 3302 3303* 3303 3306 3365 3366 4777 4947 5214 5404 5428 lp 001144 automatic pointer dcl 1683 in procedure "flow_analysis" set ref 1856* 1857 1858 1859 1874 1881 1912* 1914 1921 1944* 1946 1947 1947 1950 1950 1965* 1966 1969 1969 1973 1982* 1983 1984 1985 1989 1995 1995 2009* 2010 2010 2012 2016 2016 lp 002420 automatic pointer dcl 4563 in procedure "set_loop_variants" set ref 4565* 4569 lp 004014 automatic pointer dcl 6875 in procedure "find_new_induction_vars_on_ass_chain" set ref 6885* 6899 6905 lp parameter pointer dcl 7-179 in procedure "put_in_loop_end" ref 7-177 7-187 lp 002036 automatic pointer dcl 3446 in procedure "optimize_flow_unit" set ref 3517* 3518 3519 3528 3586 3615 3719 4092 4094 4141 4141 4144 4147 4147 4225 4233 4238 4248 4281 lp 003532 automatic pointer dcl 6001 in procedure "reduce_strength" set ref 6029* 6030 6040* 6078 6158* 6202 6203 6204 6206 6280* 6450 6450 6537 6831 6858* 6868 6991 6994* 7005 7044 7107* 7134 7135 lp parameter pointer dcl 6965 in procedure "force_loop" ref 6962 6967 6969 lp 005062 automatic pointer dcl 8579 in procedure "find_range" set ref 8586* 8588 8595* lp parameter pointer dcl 7539 in procedure "remove_units_from_loop" ref 7536 7544 7545 7576 7576 7576 lp 004454 automatic pointer dcl 7678 in procedure "analyze_loop_index_values" set ref 7696* 7708 7708 7708 7711 7712 7712 7716 7716 7720 7727 7753 7875 7889 7895 7912 7924 7952 7987 8012* 8039 8049* 8053 8304* 8351 8360 8648 8657* 8660* 8664* lp parameter pointer dcl 6736 in procedure "create_var" ref 6731 6741 lp 001434 automatic pointer dcl 2499 in procedure "summarize_loop_busy_on_exit" set ref 2502* 2504 2505 2505 lp 005026 automatic pointer dcl 8495 in procedure "is_suitable_loop_exit" set ref 8511* 8558 8563 lp_evaluated 003470 automatic pointer dcl 5415 set ref 5424* 5428 lp_frame based structure level 1 dcl 434 set ref 3417 3417 lp_num 003741 automatic fixed bin(18,0) dcl 6738 set ref 6741* 6747 lp_to_put 003472 automatic pointer dcl 5415 set ref 5433* 5439* lpf 001562 automatic pointer dcl 2771 set ref 3009* 3011* 3020 3021 3022 3024 3031 3056 3058 3058 3067 3097 3098 3098 3207 3218 3222 3223 3224 3225 3270 3276 3276* 3276* 3278* 3278 3304* 3304 3311 3312 3334 3335 3358 3359 3360 3361 3373 3391 3396 3402 3403 4775 lst 004434 automatic pointer dcl 7624 in procedure "free_statement" set ref 7629* 7631 lst 001306 automatic pointer dcl 2277 in procedure "detach_flow_units" set ref 2295* 2305 ltrim builtin function dcl 9-17 in procedure "create_node" ref 9-29 9-29 ltrim builtin function dcl 470 in procedure "fort_optimizer" ref 5862 5865 5871 5881 5884 7-54 7-54 7-122 7-122 ltrim builtin function dcl 8-28 in procedure "create_constant" ref 8-45 8-45 lvec 002453 automatic fixed bin(18,0) dcl 4582 in procedure "free_them" set ref 4596* 4601 4622* 4622 4623 4623* 4625 4625 lvec 000102 automatic fixed bin(18,0) dcl 1729 in begin block on line 1724 set ref 1765* 1767 1800* 1800 1801 lvec 001370 automatic fixed bin(17,0) dcl 2390 in procedure "compute_busy_on_exit" set ref 2407* 2409 2431* 2431 2432 2432* 2434 lvec 001153 automatic fixed bin(18,0) dcl 1684 in procedure "flow_analysis" set ref 1695* 1697 1706* 1706 1707 1715 1718 1866* 1870 1878* 1878 1879 1903* 1905 1907 1909 1915* 1915 1917 1919 1922 max builtin function dcl 470 ref 564 565 566 737 5624 8178 8190 8194 8201 8311 8396 max_char_length constant fixed bin(10,0) initial dcl 3-77 ref 8181 8202 max_chars 004714 automatic fixed bin(21,0) dcl 8226 set ref 8232* 8241 8249 max_data_type 000124 automatic fixed bin(4,0) dcl 5465 set ref 5624* 5630 5630 5632 5632 5634 5634 max_fixed_bin_24 000406 constant fixed bin(24,0) initial dcl 3-59 ref 8233 max_flow_units 000344 automatic fixed bin(18,0) dcl 248 set ref 793* 1006* 1009 1009 1009 1009 1018 1018 1018 1018 1019 1019 1019 1019 1020 1020 1020 1020 1692 1692 1756 1781 1781 1782 1823 1846 1846 1847 1847 1847 1847 1865 1867 1874 1874 1880 1983 2001 2010 2010 2014 2014 2015 2016 2016 2016 2051 2051 2057 2057 2078 2160 2250 2250 2251 2686 2686 2686 2686 2686 2714 2714 2714 2714 2715 2715 2715 2715 2716 2716 2716 2716 3518 7005 max_fu_pos 003476 automatic fixed bin(18,0) dcl 5416 set ref 5426* 5430 5432* 5439 max_integer 000336 constant fixed bin(35,0) initial dcl 7985 ref 8140 8293 8298 8317 8317 max_n_flow_units 000515 automatic fixed bin(18,0) dcl 466 set ref 518* 566* 566 585* max_n_loops 000514 automatic fixed bin(18,0) dcl 466 set ref 518* 565* 565 585* max_n_sym 000513 automatic fixed bin(18,0) dcl 466 set ref 518* 564* 564 585* max_operands 000345 automatic fixed bin(17,0) dcl 249 set ref 499* 2832 max_operators 000346 automatic fixed bin(18,0) dcl 250 in procedure "fort_optimizer" set ref 1014* 2640 2719 2719 2719 2719 2972 4743 4743 4743 4743 4753 4765 4828 4852 4896 4896 4896 4896 4907 4918 4920 7716 7716 7716 7753 7895 max_operators 56(18) based fixed bin(18,0) level 2 in structure "subprogram" packed packed unsigned unaligned dcl 2-753 in procedure "fort_optimizer" set ref 1014* max_size 004716 automatic fixed bin(24,0) dcl 8228 in procedure "get_max_size" set ref 8241* 8245* 8246* 8249* 8252* 8253* 8255 max_size 004702 automatic fixed bin(24,0) dcl 8130 in procedure "calculate_range_by_subscripts" set ref 8179* 8181* 8182 8192* 8194 max_sym 60 based fixed bin(18,0) level 2 in structure "subprogram" dcl 2-753 in procedure "fort_optimizer" set ref 737* max_sym 000347 automatic fixed bin(18,0) dcl 251 in procedure "fort_optimizer" set ref 696 737* 741 741 741 741 742 744 744 744 744 746 746 746 746 747 750 750 760 763 768 768 769 1036 1036 1036 1036 1043 1043 1043 1043 1043 1043 1245 1246 1246 1255 1255 1255 1255 1256 1256 1256 1256 1256 1266 1267 1286 1287 1332 1332 1334 1342 1342 1342 1342 1342 1345 1345 1345 1345 1351 1351 1354 1374 1374 1377 1381 1404 1404 1404 1405 1405 1405 1405 1408 1408 1408 1408 1410 1410 1410 2022 2022 2022 2022 2395 2395 2419 2419 2419 2422 2422 2422 2422 2426 2426 2428 2428 2447 2447 2447 2447 2451 2451 2453 2453 2473 2473 2473 2473 2473 2476 2476 2476 2477 2477 2477 2482 2482 2482 2482 2482 2485 2485 2485 2486 2486 2486 2505 2505 2505 2680 2680 2680 2680 2681 2681 2681 2681 2682 2682 2682 2682 2683 2683 2683 2683 2684 2684 2684 2684 2685 2685 2685 2685 2717 2717 2717 2717 2718 2718 2718 2718 2741 2741 2741 2741 2742 2742 2742 2742 2743 2743 2743 2743 2744 2744 2744 2744 2891 2891 2891 3114 3114 3114 3162 3162 3284 3284 3284 3528 3528 3528 3586 3615 3719 3719 4004 4004 4004 4004 4092 4094 4141 4141 4144 4147 4147 4225 4233 4248 4281 4281 4569 5211 5211 5213 5214 5215 5216 5216 5216 5230 5237 5404 5405 6078 6081 6198 6200 6202 6203 6204 6207 6208 6208 6211 6450 6450 6537 6644 6785 6796 6831 6868 6899 6905 6967 6970 6991 7044 7080 7109 7110 7134 7135 7136 7180 7212 7217 7240 7253 7324 7324 7366 7368 7374 7375 7376 7448 7448 7567 7567 7567 7567 7567 7567 7576 7576 7576 7708 7708 7708 7708 7712 7712 7712 7714 7714 7714 7714 7721 7721 7721 7721 7889 7912 7924 7952 8351 8360 8445 8648 max_words 004715 automatic fixed bin(24,0) dcl 8227 set ref 8233* 8235* 8245 8252 may_keep_in_xr 27 based pointer level 2 packed packed unaligned dcl 1-100 set ref 2718* 2726* 7708 7712 7712 7712 7714 7714 7721 7721 7924 7952 8648 members 10 based pointer level 2 packed packed unaligned dcl 1-100 set ref 1984 1985* 2472 2736* 2897 3097 6969 7211 7544 7545* 7727 meter_hash_buckets 000350 automatic bit(1) dcl 252 set ref 501* 2991 3132 min builtin function dcl 470 ref 2832 8182 8190 8194 8202 8313 8394 min_ninst 004124 automatic fixed bin(18,0) dcl 7033 set ref 7040* 7049* 7053 7055* 7060 7085 misc_attributes 10(28) based structure level 3 packed packed unaligned dcl 2-844 mod builtin function dcl 470 in procedure "fort_optimizer" ref 5156 5161 mod builtin function dcl 8-29 in procedure "create_constant" ref 8-57 mod_2_sum 000106 automatic bit(36) dcl 8-30 in procedure "create_constant" set ref 8-51* 8-54* 8-57 mod_2_sum 003336 automatic fixed bin(34,0) dcl 5146 in procedure "hash" set ref 5151* 5153* 5153 5156 5161 mode parameter fixed bin(18,0) dcl 3441 in procedure "optimize_flow_unit" ref 3429 3453 mode 10(20) based structure level 4 in structure "symbol" packed packed unaligned dcl 2-844 in procedure "fort_optimizer" mode_bits 10 based structure level 3 packed packed unaligned dcl 2-844 moved 4(06) based bit(1) level 3 packed packed unaligned dcl 1-176 set ref 5268* 5271* 5271 7563 msp 36 based pointer level 2 packed packed unaligned dcl 1-100 set ref 2736* mult_op constant fixed bin(18,0) initial dcl 3-197 set ref 3779 4033 4068 6512 6603 6632* n 004674 automatic fixed bin(18,0) dcl 8127 set ref 8159* 8175 8198 n_flow_units 000351 automatic fixed bin(18,0) dcl 253 set ref 566 1002* 1006 1715 1718* 1726 1727 1732 1744 1762 1814 2055 2057 2160 2167* 2167 2168 2254 2400 2411 2432 2819 n_in_loop_end 11(18) based fixed bin(17,0) level 2 packed packed unaligned dcl 1-46 set ref 2821 2826 2847* 7-195* 7-195 n_loops 56 based fixed bin(18,0) level 2 in structure "subprogram" packed packed unsigned unaligned dcl 2-753 in procedure "fort_optimizer" set ref 1901* n_loops 000352 automatic fixed bin(18,0) dcl 254 in procedure "fort_optimizer" set ref 515* 565 793* 1034 1901 1902 1902 1903 1908 1908 1908 1908 1909 1911 1920 1920 1920 1920 1921 1921 1922 1943 1964 2008 2469 2501 2746* 2746 2791 2855 5428 6450 6450 6450 6747 6760 6760 6760 6760 7515 7669 7670 n_operands 000516 automatic fixed bin(17,0) dcl 1-171 set ref 2622* 2623 2623 2629 n_operators 000353 automatic fixed bin(18,0) dcl 255 set ref 793* 828* 828 834 1014 1014 2638* 2638 2640 2640 n_sym 000354 automatic fixed bin(18,0) dcl 256 set ref 564 702* 727* 727 728 737 6784* 6784 6785 6794 6796 n_uses 004101 automatic fixed bin(18,0) dcl 6984 in procedure "replace_tests" set ref 6994* 6996 6999 n_uses 004157 automatic fixed bin(18,0) dcl 7161 in procedure "used_in_loop" set ref 7168* 7172 7172 7185 7185 7195 7239* 7239 7241 7252* named_constant 11(06) based bit(1) level 4 packed packed unaligned dcl 2-844 set ref 708 721* 1186 namelist 10(34) based bit(1) level 4 packed packed unaligned dcl 2-844 ref 708 need_consolidation_pass 000355 automatic bit(1) dcl 257 set ref 536* 2787 3119 4759 need_new_unit 000576 automatic bit(1) dcl 782 set ref 798* 811* 817 856* 875* 883* 890* 896* 903* 910* 1427* neg_storage_add_op constant fixed bin(18,0) initial dcl 3-197 ref 4189 6117 6255 7785 negate_op constant fixed bin(18,0) initial dcl 3-197 ref 5734 negate_round 1540 based entry variable array level 2 dcl 477 ref 5637 new 003126 automatic pointer dcl 4720 in procedure "process_jump_label" set ref 4751* 4752 4763* 4764 new 002146 automatic pointer dcl 3931 in procedure "common" set ref 3939* 3944 3950 3971 new 001760 automatic pointer dcl 3295 in procedure "pop_loop" set ref 3325* 3326 3327 3344* 3345 3346 new_frame 003730 automatic pointer dcl 6718 set ref 6720* 6722 6723 6724 6727 new_fu 002156 automatic pointer dcl 3935 set ref 3950* 3952 3952 4001 4004 4004 new_increment 003611 automatic fixed bin(18,0) dcl 6005 set ref 6265* 6268 6273* new_incrp 003600 automatic pointer dcl 6003 set ref 6268* 6269 6300 new_induction_var 2(05) based bit(1) level 2 packed packed unaligned dcl 2-844 set ref 6773* 6831 new_label parameter fixed bin(18,0) dcl 2150 set ref 2146 2189* new_out 002160 automatic fixed bin(18,0) dcl 3936 in procedure "common" set ref 3944* 3945 3986* new_out 000100 automatic fixed bin(18,0) dcl 4409 in procedure "replace_inputs" set ref 4413* 4416 4418 4420 new_outp 002152 automatic pointer dcl 3935 set ref 3945* 3955 3957 3964 3964 3982 3982 3988 3989 new_statement 003422 automatic fixed bin(18,0) dcl 5258 in procedure "insert_stm_in_back_target" set ref 5263* 5264 5273 5278 5287 5296 5297 new_statement 001605 automatic fixed bin(18,0) dcl 2779 in procedure "optimize_subprogram" set ref 2823* 2824 2833* 2845 new_stm 003424 automatic pointer dcl 5259 in procedure "insert_stm_in_back_target" set ref 5264* 5266 5268 5269 5271 5279 5280 5282 5286 5289 5291 new_stm parameter pointer dcl 2151 in procedure "insert_flow_unit_before" set ref 2146 2190* new_target parameter pointer dcl 2198 ref 2195 2212 2213 2215 next based pointer level 2 in structure "lchain" packed packed unaligned dcl 1-94 in procedure "fort_optimizer" set ref 2840 2842* 7-192* next 2 based bit(18) level 2 in structure "opt_statement" packed packed unaligned dcl 1-176 in procedure "fort_optimizer" set ref 809 1053 1593 2097 2292 2305* 2305 2580 2592* 2594* 3539 7229 7553 7626 7631* 7631 7736 7-148 next based pointer level 2 in structure "flow_unit" packed packed unaligned dcl 1-46 in procedure "fort_optimizer" set ref 1010 1436* 1937 1939 2108 2125 2129 2171* 2173* 2177 2246 2280 2281 2542* 2542 2543 2545* 2674 2915 2923 2928 2981 2989 3048 3056 3061 3520 3520 7221 7221 7485 7502 7548 7728 7728 8152 8329 8563 next based pointer level 2 in structure "sr_var" packed packed unaligned dcl 404 in procedure "fort_optimizer" set ref 2860 2861* 6291* 6453 6454* 6704 6749* 6749 6751 6755 6811 7058 next based pointer level 2 in structure "input_to" packed packed unaligned dcl 1-87 in procedure "fort_optimizer" set ref 3988* 4045* 4421 4632 5683 5694* 6133 6390 8566 7-75* 7-83* 7-98 7-256 7-268* 7-268 7-269 7-273 7-275 next based pointer level 2 in structure "equiv_array" packed packed unaligned dcl 429 in procedure "fort_optimizer" set ref 662* 684 687* next based pointer level 2 in structure "primary" packed packed unaligned dcl 1-234 in procedure "fort_optimizer" set ref 3145 3204 3215 3243 3247* 3315 3338 3490 3494 3678 3690 4754 4767 4826 4840 4908 4924 4951 4972 5020* 5038 5038 5040 5042* 5042 5050* 5067 5071* 5090 5090 5092* 5092 5103* 5122 5126* 8723 8732 next based pointer level 2 in structure "sr_cand" packed packed unaligned dcl 398 in procedure "fort_optimizer" set ref 4365 4371* 4375* 6425 6476 6478* next 1 based fixed bin(18,0) level 2 in structure "operator" packed packed unsigned unaligned dcl 1-144 in procedure "fort_optimizer" set ref 984 1138 1501 2306* 2599* 2651 2652* 2652 2654* 3544 5190 5192* 5192 5194* 7256 7557 7861 8166 8342 8530 7-162 7-165 7-168* 7-168 7-172* next based pointer level 2 in structure "dead_assign_cand" packed packed unaligned dcl 424 in procedure "fort_optimizer" set ref 7276* 7292 7381 7383* next based pointer level 2 in structure "chain" packed packed unaligned dcl 1-27 in procedure "fort_optimizer" set ref 1549* 1569* 1576* 1599 1602 1606* 1618 1619 1621* 1624 1628* 1836* 1887 1894* 1999* 2017 2508 3177 3180 3399 3401* 4636 4640* 4706* 4780* 5003 5007* 7968* 8024 8028* 8066 8071 8075* 8107 8379 8398 8402* 8409 8413* 8637 8682* 8694* 8694 8696 8698* 7-38 next 004020 automatic pointer dcl 6877 in procedure "find_new_induction_vars_on_ass_chain" set ref 6894* 6917 next based pointer level 2 in structure "range" packed packed unaligned dcl 1-243 in procedure "fort_optimizer" set ref 8591 8613* next based pointer level 2 in structure "incr" packed packed unaligned dcl 418 in procedure "fort_optimizer" set ref 4394 4400* 6066 6460 6484* 6491 6495* 6894 6909* 6909 6911 6912* 7025 next based pointer level 2 in structure "lp_frame" packed packed unaligned dcl 434 in procedure "fort_optimizer" set ref 3276 3278 3419* 3421* next based pointer level 2 in structure "secondary" packed packed unaligned dcl 392 in procedure "fort_optimizer" ref 4459 4477 4513 4543 4554 4571 4996 next 4 based pointer level 3 in structure "edge" packed packed unaligned dcl 1-33 in procedure "fort_optimizer" set ref 1659* 1712 1969 2003 2364* 2364 2366 2367 2367 next 1 based pointer level 2 in structure "sr_frame" packed packed unaligned dcl 6014 in procedure "reduce_strength" set ref 6229 6250 6580 6580 6722* 6724* next 1 based pointer level 3 in structure "edge" packed packed unaligned dcl 1-33 in procedure "fort_optimizer" set ref 1654* 1708 1754 1775 1825 1883 2075 2203 2208* 2213* 2358* 2358 2360 2361 2361 2438 next 3 based fixed bin(18,0) level 2 in structure "temporary" packed packed unsigned unaligned dcl 2-1005 in procedure "fort_optimizer" set ref 5333* 6393* 7408 next_c 005112 automatic pointer dcl 8627 set ref 8637* 8677 next_constant 3 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-256 set ref 8-91* next_edge 001250 automatic pointer dcl 2201 in procedure "redirect_edge" set ref 2203* 2206 2208 2209 2209 next_edge 001202 automatic pointer dcl 2036 in procedure "create_new_back_target" set ref 2075* 2138 next_frame 003660 automatic pointer dcl 6550 set ref 6580* 6582* 6584 6585 6586 6587 6588 6589 6592 6597 6598 6600 6607 6615 6615 6619 6629 6634 6655 6655 6658 6663 next_free_operand 42 based fixed bin(18,0) level 2 dcl 477 set ref 9-20 9-22 9-23* 9-23 next_free_opt 50 based fixed bin(18,0) level 2 dcl 477 set ref 7-13 7-16* 7-16 7-18 7-22* next_free_polish 41 based fixed bin(18,0) level 2 dcl 477 set ref 7-114 7-116* 7-116 7-118 next_free_quad 45 based fixed bin(18,0) level 2 dcl 477 set ref 7-50 7-51* 7-51 7-52 next_free_temp 47 based fixed bin(18,0) level 2 dcl 477 set ref 5333 5334* 6393 6394* 7399 7406 7408* next_fu 001322 automatic pointer dcl 2277 set ref 2281* 2314 next_header 3 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-436 ref 691 next_in_loop 6 based pointer level 2 packed packed unaligned dcl 1-46 set ref 1984* 2479 2915 2935 3022 3048 6971 7259 7574 7863 next_label 3 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-530 set ref 2530* next_lp 001642 automatic pointer dcl 2874 in procedure "optimize_loop" set ref 2895* 2905 2923* 2925 2925* next_lp 4 based pointer level 3 in structure "lp_frame" packed packed unaligned dcl 434 in procedure "fort_optimizer" set ref 3031 3056* 3058 3058 3098* next_lp 001734 automatic pointer dcl 3194 in procedure "push_loop" set ref 3229* 3230* 3274 next_member 7(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-844 ref 671 685 next_o 001514 automatic pointer dcl 2617 set ref 2651* 2655 next_op 004367 automatic fixed bin(18,0) dcl 7542 in procedure "remove_units_from_loop" set ref 7557* 7559 next_op 002210 automatic pointer dcl 4064 in procedure "check_str_reducibility" set ref 4070* 4071 4071 4071 next_op 002043 automatic fixed bin(18,0) dcl 3447 in procedure "optimize_flow_unit" set ref 3544* 3872 next_operator 001470 automatic fixed bin(18,0) dcl 2561 set ref 2585* 2596 next_p 003170 automatic pointer dcl 4802 set ref 4826* 4831 4840* 4869 next_statement 004430 automatic fixed bin(18,0) dcl 7623 in procedure "free_statement" set ref 7626* 7627 next_statement 004501 automatic fixed bin(18,0) dcl 7690 in procedure "analyze_loop_index_values" set ref 7736* 7738 7862 next_statement 001326 automatic fixed bin(18,0) dcl 2278 in procedure "detach_flow_units" set ref 2292* 2293 2306 next_statement 004200 automatic fixed bin(18,0) dcl 7209 in procedure "process_flow_units" set ref 7229* 7231 7257 next_statement 005227 automatic fixed bin(18,0) dcl 7-134 in procedure "derive_insert_for_bt" set ref 7-148* 7-149 next_statement 000613 automatic fixed bin(17,0) dcl 784 in procedure "build_flow_units" set ref 809* 823 858 989 1053* 1058 1145 1474 next_statement 002044 automatic fixed bin(18,0) dcl 3447 in procedure "optimize_flow_unit" set ref 3539* 3541 3875 next_statement 004370 automatic fixed bin(18,0) dcl 7542 in procedure "remove_units_from_loop" set ref 7553* 7555 7565 next_statement 001467 automatic fixed bin(18,0) dcl 2560 in procedure "insert_statement_after" set ref 2580* 2581 2585 2592 next_subprogram 1(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-753 ref 568 next_symbol 3 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-844 set ref 732 773 6779* next_unit 000764 automatic pointer dcl 1425 set ref 1429* 1431* 1433 1433 1434 1436 1437 1442* 1446 next_unit_statement 004371 automatic fixed bin(18,0) dcl 7542 in procedure "remove_units_from_loop" set ref 7548* 7550 next_unit_statement 004503 automatic fixed bin(18,0) dcl 7690 in procedure "analyze_loop_index_values" set ref 7728* 7730* 7732 next_unit_statement 002045 automatic fixed bin(18,0) dcl 3447 in procedure "optimize_flow_unit" set ref 3520* 3522* 3536 next_unit_statement 004201 automatic fixed bin(18,0) dcl 7209 in procedure "process_flow_units" set ref 7221* 7223* 7225 nextop 001500 automatic pointer dcl 2562 set ref 2586* 2598 nextp 001476 automatic pointer dcl 2562 in procedure "insert_statement_after" set ref 2581* 2586 2587 2595 nextp 000100 automatic pointer dcl 7-158 in procedure "unthread" set ref 7-165* 7-167 ninst 003717 automatic fixed bin(18,0) dcl 6674 in procedure "search_for_equivalent" set ref 6677* 6678 6680 6684 ninst 7 based fixed bin(18,0) level 3 in structure "sr_frame" dcl 6014 in procedure "reduce_strength" set ref 6105* 6309 6588* 6588 6677 ninst 7 based fixed bin(18,0) level 2 in structure "sr_var" dcl 404 in procedure "fort_optimizer" set ref 6309* 6310 6315 6680 7049 7053 7055 no_op 000376 constant fixed bin(18,0) initial dcl 3-197 set ref 863 1499 6094* node based structure level 1 dcl 2-63 node_offset 000107 automatic fixed bin(17,0) dcl 8-31 set ref 8-61* 8-62 8-63 8-65 8-69* 8-74* 8-76 8-78 8-80 8-89 8-91 8-93 8-95 node_ptr 000110 automatic pointer dcl 8-32 set ref 8-63* 8-65 8-65 8-69 8-78 8-80* 8-81 8-82 8-83 8-84 8-85 node_type based fixed bin(4,0) level 2 in structure "temporary" packed packed unaligned dcl 2-1005 in procedure "fort_optimizer" set ref 7410* node_type based fixed bin(4,0) level 2 in structure "node" packed packed unaligned dcl 2-63 in procedure "fort_optimizer" set ref 922 1076 1184 1206 1209 1223 1316 1327 3149 3240 3321 3548 3569 3577 3594 3623 3646 3716 3912 3912 3914 3964 3978 3994 4042 4042 4081 4084 4087 4130 4132 4174 4174 4230 4233 4238 4275 4281 4343 4343 4434 4437 4609 4689 4692 5202 5208 5226 5233 5331 5337 5374 5385 5391 5398 5505 5956 5971 6280 6528 6531 6534 6592 6607 6625 6625 6644 6831 7077 7080 7124 7594 7597 7606 7747 7772 7886 7889 7892 7924 7952 8017 8304 8351 8360 8479 7-224 7-224 9-25* non_auto_mask based bit dcl 258 set ref 741 741 742* 760* 2447 non_auto_mask_p 000356 automatic pointer dcl 259 set ref 741* 741 741 742 760 2447 non_executable constant fixed bin(18,0) initial dcl 3-197 ref 1499 not_in_storage 0(23) based bit(1) level 3 packed packed unaligned dcl 2-1005 set ref 7419* nst 001310 automatic pointer dcl 2277 in procedure "detach_flow_units" set ref 2293* 2307 2308 nst 004432 automatic pointer dcl 7624 in procedure "free_statement" set ref 7627* 7632 null builtin function dcl 470 ref 499 505 506 510 512 644 664 673 678 689 706 795 799 799 997 997 1008 1042 1429 1463 1527 1564 1586 1588 1597 1604 1608 1611 1613 1618 1623 1626 1630 1648 1649 1656 1661 1701 1708 1735 1745 1747 1763 1773 1810 1821 1848 1850 1871 1889 1896 1914 1931 1937 1946 1969 1980 1989 2012 2074 2175 2206 2209 2214 2216 2332 2336 2358 2361 2364 2367 2417 2472 2481 2504 2575 2632 2670 2702 2710 2726 2736 2785 2789 2809 2829 2848 2854 2865 2895 2897 2960 2966 2969 3009 3009 3009 3018 3020 3095 3096 3098 3113 3144 3168 3177 3198 3201 3209 3212 3235 3237 3245 3248 3252 3276 3306 3312 3314 3335 3337 3367 3391 3395 3396 3403 3419 3421 3423 3487 3520 3526 3551 3670 3682 3762 4132 4217 4281 4298 4306 4361 4371 4373 4390 4399 4415 4442 4455 4473 4509 4536 4567 4585 4588 4590 4593 4609 4615 4620 4638 4695 4699 4743 4747 4750 4762 4774 4787 4825 4839 4845 4896 4900 4902 4904 4917 4945 4950 4971 4995 5000 5001 5005 5018 5022 5038 5040 5046 5053 5063 5070 5072 5090 5094 5098 5102 5106 5118 5127 5283 5316 5669 6045 6062 6100 6102 6102 6131 6206 6302 6382 6442 6443 6447 6448 6458 6462 6467 6482 6488 6489 6493 6499 6580 6678 6722 6724 6745 6746 6749 6775 6791 6807 6891 6893 6909 6938 6948 6952 6969 6986 6991 7041 7043 7172 7189 7193 7211 7221 7288 7315 7317 7385 7456 7464 7468 7545 7547 7698 7711 7720 7727 7728 7779 7841 7988 7990 8026 8040 8043 8051 8053 8073 8099 8143 8148 8149 8161 8284 8322 8325 8326 8337 8369 8370 8376 8384 8400 8406 8407 8411 8518 8522 8525 8545 8588 8634 8636 8658 8661 8671 8671 8680 8694 7-34 7-75 7-94 7-123 7-247 7-251 7-266 7-269 7-273 8721 8730 nullx constant fixed bin(18,0) initial dcl 7-160 ref 7-162 7-172 number 11 based fixed bin(17,0) level 2 in structure "flow_unit" packed packed unaligned dcl 1-46 in procedure "fort_optimizer" set ref 802* 1002 1433 1433* 1757 1782 1790 1799 1816 1852 1874 1880 1981 1983 2015 2045 2168* 2251 3518 7005 number parameter fixed bin(18,0) dcl 2613 in procedure "insert_operator_after" ref 2610 2622 number based fixed bin(18,0) level 2 in structure "loop" dcl 1-100 in procedure "fort_optimizer" set ref 1907* 1919* 2732* 5428 6741 7515 number 003610 automatic fixed bin(18,0) dcl 6005 in procedure "reduce_strength" set ref 6224* 6254* 6260* 6265* 6271 number 0(11) based fixed bin(7,0) level 2 in structure "operator" packed packed unsigned unaligned dcl 1-144 in procedure "fort_optimizer" set ref 499 864* 970 1124 1161 1398 2629* 3562 3808 3900 3900 3903 4180* 4338 4662 5152 5220 5379 5492 5499 5711 7121 7236 7352 7588 7767 7937 8159 8471 nwords parameter fixed bin(18,0) dcl 7-7 in procedure "get_opt_space" ref 7-5 7-16 nwords parameter fixed bin(18,0) dcl 7-108 in procedure "get_polish_space" ref 7-106 7-116 o 005260 automatic pointer dcl 7-216 in procedure "connect_expression" set ref 7-220* 7-221 7-229* o 003776 automatic pointer dcl 6844 in procedure "add_new_induction_var" set ref 6850* 6852 6853 6864* o 001210 automatic pointer dcl 2036 in procedure "create_new_back_target" set ref 2096* 2097* 2097 2098* 2098 2100 2100 2103 2103 2105 2105 2112 2114 2114 2118 2120 2121 2121 o 000100 automatic pointer dcl 5453 in procedure "constant_expression" set ref 5488* 5492 5495 5499 5500 5524 5682 5700* 5711 o parameter pointer dcl 7-66 in procedure "chain_input" ref 7-62 7-76 o 003552 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6135* 6138 6138* 6138* 6342 6342* 6342* 6349 6354 6357* o 001722 automatic pointer dcl 3194 in procedure "push_loop" set ref 3238* 3239 3240 o 003654 automatic pointer dcl 6547 in procedure "reduce" set ref 6555* 6564* 6565 6575* 6584 6587 6591 6603 6605 6655 o 000100 automatic pointer dcl 5307 in procedure "free_operator" set ref 5312* 5316 5318 5326 5331 5337* 5343 5344 5348* o 001012 automatic pointer dcl 1490 in procedure "get_final_target" set ref 1499* 1499 1499* 1501 1503 1505 o 001676 automatic pointer dcl 3105 in procedure "finish_loop" set ref 3147* 3148 3149 o parameter pointer dcl 7-158 in procedure "unthread" ref 7-156 7-162 7-165 7-166 7-167 7-168 7-172 7-172 o parameter pointer dcl 4027 in procedure "have_identity" set ref 4019 4033 4033 4036 4049* o parameter pointer dcl 6508 in procedure "is_reducible" ref 6503 6512 6512 6512 6512 o 000602 automatic pointer dcl 783 in procedure "build_flow_units" set ref 824* 825 834 837 853 858 863 864 872 880 881 895 906 909 917 920 922 937 946 959 970 971 971 976 984 1059* 1060 1069 1075 1080 1095 1099 1106 1115 1124 1125 1125 1130 1138 1161 1178 1193 1198* 1206* 1211* 1321* 1398 1399 1414 1525 1559 1562 o 003436 automatic pointer dcl 5360 in procedure "process_moved_descendants" set ref 5367* 5368 5370 5379 5380 o parameter pointer dcl 7-284 in procedure "in_namelist" ref 7-282 7-290 o 001072 automatic pointer dcl 1584 in procedure "connect_jump_assigneds" set ref 1594* 1595 o parameter pointer dcl 4355 in procedure "chain_sr_cand" ref 4350 4368 o 003506 automatic pointer dcl 5906 in procedure "constant_assign" set ref 5916* 5918 5919 5960 5967 o 004252 automatic pointer dcl 7305 in procedure "remove_dead_assignments" set ref 7337* 7338 7342 7342 7342* 7346 7346 7352 7353 7359 7359 7361 7364* o 003356 automatic pointer dcl 5168 in procedure "move" set ref 5176* 5185* 5191 5192 5193 5200 5201 5220 5221 o 001616 automatic pointer dcl 2780 in procedure "optimize_subprogram" set ref 2834* 2837 o 002436 automatic pointer dcl 4581 in procedure "free_them" set ref 4592* 4593 4594 4606* 4607 4609 4613* 4615 4619 4620 4625 o 003334 automatic pointer dcl 5141 in procedure "hash" set ref 5149* 5151 5152 5153 o 000102 automatic pointer dcl 7-238 in procedure "disconnect_temporary" set ref 7-245* 7-252 o parameter pointer dcl 7961 in procedure "chain_it" ref 7958 7967 o 004074 automatic pointer dcl 6983 in procedure "replace_tests" set ref 6994* 7005 7005 7012 7016 7074 7077* 7101 7101 7102 7104 7104 o 002274 automatic pointer dcl 4334 in procedure "decrement_input_ref_counts" set ref 4336* 4338 4339 o 005004 automatic pointer dcl 8437 in procedure "get_starting_value" set ref 8459* 8461 8461* 8466 8466 8468 8471 8472 8477 8479 8479 8482 8487 o 004462 automatic pointer dcl 7681 in procedure "analyze_loop_index_values" set ref 7740* 7741 7743 7745 7753 7753 7758 7761 7761 7767 7770 7777* 7803 7805 7812* 7820 7823* 7830 7838* 7846 7861 7937 7938 o 005230 automatic pointer dcl 7-135 in procedure "derive_insert_for_bt" set ref 7-139* 7-141 o 004402 automatic pointer dcl 7581 in procedure "remove_operator" set ref 7586* 7588 7589 7602 7604 7606 7610* o 004024 automatic pointer dcl 6878 in procedure "find_new_induction_vars_on_ass_chain" set ref 6895* 6896 6897 o 001122 automatic pointer dcl 1669 in procedure "make_constant_opt_subscript" set ref 1672* 1673 1674 1675 1676 o 004526 automatic pointer dcl 7884 in procedure "invariant" set ref 7894* 7895 7895 o 003160 automatic pointer dcl 4802 in procedure "intersection" set ref 4857* 4860 4862* 4865 4866* o 002024 automatic pointer dcl 3446 in procedure "optimize_flow_unit" set ref 3542* 3543 3544 3545 3547 3562 3563 3571* 3573* 3599 3603* 3605* 3646 3653* 3666* 3672* 3674* 3685* 3687* 3695* 3730* 3735 3737 3741 3742* 3753 3755 3756* 3762 3767 3768 3772* 3785* 3793* 3808 3810 3810 3821 3828 3833 3835 3844 3848 4071 4071 4079 4111* 4127 4145* 4147* 4163 4179 4180 4183 4184 4188 4189 4191 4205* 4212* 4217 4250* o 001512 automatic pointer dcl 2617 in procedure "insert_operator_after" set ref 2624* 2628 2629 2630 2631 2632 2640 2652 2653 o 003062 automatic pointer dcl 4649 in procedure "record_secondaries" set ref 4658* 4659 4662 4664 4671 4672 4705 o 000102 automatic pointer dcl 5086 in procedure "release_primary" set ref 5097* 5098 5099 5099 o 001764 automatic pointer dcl 3295 in procedure "pop_loop" set ref 3316* 3318 3320 3321 3324* 3327 3328* 3339* 3341 3343* 3346 3347 3347* o parameter pointer dcl 4386 in procedure "chain_incr" ref 4381 4397 o parameter pointer dcl 6821 in procedure "output_is_new_induction_var" ref 6818 6829 o 004362 automatic pointer dcl 7541 in procedure "remove_units_from_loop" set ref 7556* 7557 7558* o 005114 automatic pointer dcl 8627 in procedure "process_assignment_list" set ref 8638* 8639 8640 o 004172 automatic pointer dcl 7208 in procedure "process_flow_units" set ref 7234* 7236 7237 7243 7249 7249* 7256 o 005040 automatic pointer dcl 8501 in procedure "is_suitable_loop_exit" set ref 8523* 8525 8528 8530* 8530 8535 8537 o 004666 automatic pointer dcl 8126 in procedure "calculate_range_by_subscripts" set ref 8138* 8153* 8157 8158* 8159 8161 8164 8166* 8166 8171 8173 8175 8185 8187 8198 8198 8204 o 004742 automatic pointer dcl 8266 in procedure "calculate_range_for_counter" set ref 8323* 8330* 8334 8335* 8337 8340 8342* 8342 8347 8347 8350 8351* 8357 8359 8360* 8364 8372* 8373 8388 8388 o1 003712 automatic pointer dcl 6673 set ref 6691* 6693 6693 o2 003714 automatic pointer dcl 6673 set ref 6692* 6693 6693 o_after 003376 automatic pointer dcl 5174 set ref 5190* 5195 o_before 003374 automatic pointer dcl 5174 set ref 5189* 5190 5192 5194 obits based bit dcl 382 set ref 2719 2719 2972* 4743 4743 4753* 4765* 4828 4852* 4896 4896 4907* 4918 4920* 7716* 7716 7716 7753* 7895 obptr 003172 automatic pointer dcl 4802 in procedure "intersection" set ref 4820* 4828 4852 obptr 003220 automatic pointer dcl 4889 in procedure "union" set ref 4898* 4907 4918 4920 oexpr 002224 automatic pointer dcl 4123 set ref 4157* 4158 4165 4173 4184 4188 4201* off 002377 automatic fixed bin(18,0) dcl 4525 set ref 4531* 4538 offset 000100 automatic fixed bin(18,0) dcl 9-13 in procedure "create_node" set ref 9-22* 9-24 9-25 9-26 offset 17 based fixed bin(24,0) level 2 in structure "symbol" dcl 2-844 in procedure "fort_optimizer" ref 667 668 681 681 4531 4538 old 002144 automatic pointer dcl 3931 set ref 3938* 3943 3978 4013* 4015* old_label 001215 automatic fixed bin(18,0) dcl 2037 set ref 2065* 2069* 2094 2105 2114 2121 old_lp 001774 automatic pointer dcl 3295 set ref 3302* 3393* old_out 002161 automatic fixed bin(18,0) dcl 3936 set ref 3943* 3946 old_outp 002150 automatic pointer dcl 3935 set ref 3946* 3978 3980 3982 3983 3984 3989 3994 3996* 3996 4003 old_startp 002154 automatic pointer dcl 3935 set ref 3984* 3986* 3988 old_target 001252 automatic pointer dcl 2201 set ref 2204* 2206 one 000360 automatic fixed bin(18,0) dcl 260 set ref 525* 526* 526 526 527 4033 6113 6257 6619 7645 onep 000362 automatic pointer dcl 261 set ref 527* 4176 7797 op 004751 automatic fixed bin(18,0) dcl 8267 in procedure "calculate_range_for_counter" set ref 8329* 8330 8334* 8334* 8335 8342* op 000612 automatic fixed bin(17,0) dcl 784 in procedure "build_flow_units" set ref 823* 823* 824* 1058* 1058* 1059* op 005047 automatic fixed bin(18,0) dcl 8502 in procedure "is_suitable_loop_exit" set ref 8522* 8522* 8523 8530* op parameter fixed bin(18,0) dcl 7392 in procedure "create_integer_temporary" ref 7389 7418 op 004262 automatic fixed bin(18,0) dcl 7306 in procedure "remove_dead_assignments" set ref 7336* 7336* 7337* op 001606 automatic fixed bin(18,0) dcl 2779 in procedure "optimize_subprogram" set ref 2833* 2834 3541* 3541* 3542* op parameter fixed bin(18,0) dcl 7-211 in procedure "connect_expression" ref 7-209 7-220 op 004502 automatic fixed bin(18,0) dcl 7690 in procedure "analyze_loop_index_values" set ref 7738* 7738* 7740* op 004366 automatic fixed bin(18,0) dcl 7542 in procedure "remove_units_from_loop" set ref 7555* 7555* 7556* op 003371 automatic fixed bin(18,0) dcl 5173 in procedure "move" set ref 5193* 5194 5195 5196 op 004202 automatic fixed bin(18,0) dcl 7209 in procedure "process_flow_units" set ref 7231* 7231* 7234* op 004673 automatic fixed bin(18,0) dcl 8127 in procedure "calculate_range_by_subscripts" set ref 8152* 8153 8157* 8157* 8158 8166* op 001520 automatic fixed bin(18,0) dcl 2618 in procedure "insert_operator_after" set ref 2623* 2624 2654 2655 2657 op 005002 automatic fixed bin(18,0) dcl 8436 in procedure "get_starting_value" set ref 8458* 8458* 8459* op_class 000704 constant fixed bin(17,0) initial array dcl 326 ref 481 826 1061 2636 3656 3695 3701 3801 7361 op_code 004477 automatic fixed bin(17,0) dcl 7689 in procedure "analyze_loop_index_values" set ref 7741* 7747 7756 7785 op_code 003607 automatic fixed bin(18,0) dcl 6005 in procedure "reduce_strength" set ref 6225* 6255* 6259* 6262* 6265* 6277 op_code 002234 automatic fixed bin(18,0) dcl 4124 in procedure "check_increment" set ref 4158* 4160 4160 4176 op_code based fixed bin(8,0) level 2 in structure "operator" packed packed unaligned dcl 1-144 in procedure "fort_optimizer" set ref 825 863* 1060 1499 1499 1503 2100 2103 2103 2112 2118 2628* 3149 3240 3321 3543 3897 3897 3914 3978 4071 4158 4179* 4183* 4189* 4191* 4217 4609 4659 5151 5200 5331 5368 5524 5673 6110 6113 6117 6234 6342 6349 6512 6512 6512 6603 6655 6693 6693 7005 7005 7089 7104* 7104 7249 7342 7342 7346 7346 7359 7361 7606 7741 7993 7999 8161 8171 8198 8337 8347 8461 8466 8466 8479 8525 8551 7-141 op_code parameter fixed bin(18,0) dcl 2613 in procedure "insert_operator_after" ref 2610 2628 2636 op_code 000614 automatic fixed bin(17,0) dcl 784 in procedure "build_flow_units" set ref 825* 826 981 1060* 1061 1135 1191 1198 1202 1318 op_code 000120 automatic fixed bin(18,0) dcl 5462 in procedure "constant_expression" set ref 5524* 5528 5634 5637 5641 5650 5722 5722 5722 5734 5746 5753 5760 5767 5774 op_code 004632 automatic fixed bin(17,0) dcl 7979 in procedure "process_comparison_list" set ref 7993* 8015 8017 8041* 8304 8304 8311 8313 op_code based fixed bin(8,0) level 2 in structure "opt_statement" packed packed unaligned dcl 1-176 in procedure "fort_optimizer" set ref 2572* op_code 003373 automatic fixed bin(18,0) dcl 5173 in procedure "move" set ref 5200* 5204 5226 5244 op_code 003443 automatic fixed bin(18,0) dcl 5364 in procedure "process_moved_descendants" set ref 5368* 5374 5398 op_code 002046 automatic fixed bin(18,0) dcl 3447 in procedure "optimize_flow_unit" set ref 3543* 3571 3596 3596 3596 3603 3612 3653 3656 3661 3695 3701 3709 3758 3779 3779 3779 3782 3796 3801 3803 3855 4033 4033 4033 4068 operand 4 based fixed bin(18,0) array level 2 dcl 1-144 set ref 853* 858 872* 880 881* 895* 906* 909 922 937 946 971 971 976 1099 1106 1125 1125 1130 1178 1193* 1218 1220 1399 1505 1525 1559 1595 1673 1674 1675* 1676* 2100* 2105 2105* 2114 2114* 2120 2121 2121* 2231* 2837* 3563 3599* 3599 3646 3810 3810 3821 3828 3833 3835 3844 3848 3894 3894 3904 3904 4033 4033 4036 4071 4071 4079 4127 4165 4173 4184* 4184 4188* 4188 4273 4319 4339 4416* 4664 5153 5221 5380 5500 5675 5676* 5678* 5680* 5682 5918 5960* 5967* 6055 6119 6184* 6226 6239 6512 6591 6605 6643 6693 6693 6853 6897 7012 7016 7074 7096 7102* 7123 7237 7353 7492* 7502* 7589 7758 7761 7761 7770 7803 7805 7820 7830 7846 7938 7995 8001 8017 8100 8104 8104 8173 8175 8185 8187 8198 8304 8308 8347 8350 8373 8388 8388 8472 8479 8482 8556 8639 7-221* 7-290 operand_base 2 based pointer level 2 in structure "shared_globals" dcl 477 in procedure "fort_optimizer" ref 494 operand_base 000364 automatic pointer dcl 262 in procedure "fort_optimizer" set ref 494* 527 534 653 656 668 676 704 754 811 811 858 909 922 937 946 948 948 1075 1076 1099 1106 1109 1109 1182 1191 1220 1228 1314 1323 1496 1525 1559 1562 1595 1673 1674 2524 2530 2857 3148 3239 3320 3547 3567 3583 3646 3712 3810 3810 3848 3851 3851 3910 3911 3945 3946 3996 4037 4079 4128 4173 4273 4342 4434 4607 4672 4687 4689 4723 5099 5201 5204 5224 5235 5287 5329 5373 5383 5395 5495 5503 5675 5918 5919 6078 6081 6153 6196 6279 6354 6365 6448 6449 6526 6565 6587 6591 6614 6623 6643 6766 6779 6829 6852 6853 6896 6897 6989 7044 7075 7107 7107 7110 7123 7167 7319 7402 7407 7592 7604 7745 7761 7761 7770 7785 7803 7805 7820 7830 7846 7849 7849 7939 7939 7995 8001 8017 8100 8100 8104 8104 8173 8187 8239 8304 8308 8350 8359 8383 8388 8388 8479 8482 8544 8556 8639 8640 7-222 7-290 9-24 9-25 8-61 8-63 8-76 8-76 8-80 8-91 operand_max_len 000366 automatic fixed bin(19,0) dcl 263 in procedure "fort_optimizer" set ref 489* 9-20 9-29 9-29 operand_max_len 35 based fixed bin(19,0) level 2 in structure "shared_globals" dcl 477 in procedure "fort_optimizer" ref 489 operand_type 0(09) based fixed bin(4,0) level 2 in structure "temporary" packed packed unaligned dcl 2-1005 in procedure "fort_optimizer" set ref 7416* operand_type 0(09) based fixed bin(4,0) level 2 in structure "constant" packed packed unaligned dcl 2-256 in procedure "fort_optimizer" set ref 8-82* operand_type 0(09) based fixed bin(4,0) level 2 in structure "label" packed packed unaligned dcl 2-530 in procedure "fort_optimizer" set ref 2528* operand_type 0(09) based fixed bin(4,0) level 2 in structure "symbol" packed packed unaligned dcl 2-844 in procedure "fort_optimizer" set ref 6770* operator 1 based pointer level 2 in structure "sr_cand" packed packed unaligned dcl 398 in procedure "fort_optimizer" set ref 4368* 6046 6471 operator 10 based pointer array level 3 in structure "sr_var" packed packed unaligned dcl 404 in procedure "fort_optimizer" set ref 6316* 6685 6692 7086 operator 2 based pointer level 3 in structure "sr_frame" packed packed unaligned dcl 6014 in procedure "reduce_strength" set ref 6153 6184 6231 6316 6328 6362 6584* 6685 6691 operator 1 based pointer level 2 in structure "input_to" packed packed unaligned dcl 1-87 in procedure "fort_optimizer" set ref 4070 4416 4418 4420 4613 5670 6135 6384 6389 8548 7-76* 7-252 operator based structure level 1 dcl 1-144 in procedure "fort_optimizer" set ref 2623 2623 operator_list 7 based pointer level 2 packed packed unaligned dcl 1-176 set ref 2575* 2960 2965 2969* 4787* 4818 4874* 4900 4910* 4914 4927* 4945 4948 4956* 5282* 5282 5283* opnd 000703 automatic fixed bin(18,0) dcl 1172 in procedure "use_one_input" set ref 1178* 1180 1182 opnd parameter fixed bin(18,0) dcl 6522 in procedure "is_invariant" ref 6519 6526 opnd parameter fixed bin(18,0) dcl 7-211 in procedure "connect_expression" ref 7-209 7-221 7-222 opnd parameter fixed bin(18,0) dcl 1300 in procedure "set" ref 1295 1310 1314 opnd 002047 automatic fixed bin(18,0) dcl 3447 in procedure "optimize_flow_unit" set ref 3563* 3565 3567 opnd 004553 automatic fixed bin(17,0) dcl 7935 in procedure "disqualify_inputs" set ref 7938* 7939 7939 7939 opnd 002273 automatic fixed bin(18,0) dcl 4333 in procedure "decrement_input_ref_counts" set ref 4339* 4340 4342 opnd 004464 automatic pointer array dcl 7681 in procedure "analyze_loop_index_values" set ref 7803* 7805* 7808* 7810* 7812* 7812* opnd 004411 automatic fixed bin(18,0) dcl 7584 in procedure "remove_operator" set ref 7589* 7590 7592 opnd 003370 automatic fixed bin(18,0) dcl 5173 in procedure "move" set ref 5221* 5222 5224 opnd parameter fixed bin(18,0) dcl 4681 in procedure "record" ref 4678 4685 4687 opnd 000116 automatic fixed bin(18,0) dcl 5462 in procedure "constant_expression" set ref 5500* 5501 5503 5657* 5680 5687* 5692* opnd 003442 automatic fixed bin(18,0) dcl 5364 in procedure "process_moved_descendants" set ref 5370* 5371 5373 5380* 5381 5383 opt based fixed bin(35,0) array dcl 384 set ref 7-13 opt_base 10 based pointer level 2 in structure "shared_globals" dcl 477 in procedure "fort_optimizer" set ref 496 7-22* opt_base 000370 automatic pointer dcl 264 in procedure "fort_optimizer" set ref 496* 7-13 7-22* opt_max_len 000372 automatic fixed bin(19,0) dcl 265 in procedure "fort_optimizer" set ref 491* 7-18 opt_max_len 40 based fixed bin(19,0) level 2 in structure "shared_globals" dcl 477 in procedure "fort_optimizer" ref 491 opt_mode 001607 automatic fixed bin(18,0) dcl 2779 set ref 2983* 2985* 2988* opt_statement based structure level 1 dcl 1-176 set ref 2566 2566 2571* opt_subscript_chain 004762 automatic pointer dcl 8271 set ref 8322* 8351* 8370 8403 opt_subscript_op constant fixed bin(18,0) initial dcl 3-197 ref 1191 1198 1202 1318 3149 3240 3321 3571 3596 3603 3612 3661 3709 3758 3796 3855 3914 3978 4609 4659 5204 5226 5244 5331 5374 5398 5673 7606 7747 8171 8347 optimizing 11(25) based structure level 3 packed packed unaligned dcl 2-753 optimizing_loop 002062 automatic bit(1) dcl 3449 set ref 3530* 3532* 3560 3589 3618 3779 options 11 based structure level 2 dcl 2-753 orig_o 004622 automatic pointer dcl 7978 in procedure "process_comparison_list" set ref 7992* 7993 7995 7999 8001 8017 8017* 8060* 8138 8304 8304* 8308 8323 orig_o 005024 automatic pointer dcl 8495 in procedure "is_suitable_loop_exit" set ref 8510* 8522 8544 other 002172 automatic fixed bin(18,0) dcl 4030 set ref 4036* 4037 4040* other_dt 000734 automatic fixed bin(18,0) dcl 1306 in procedure "set" set ref 1366* 1369* 1372* 1374 1374 1374 1377 other_dt 000722 automatic fixed bin(18,0) dcl 1239 in procedure "use_symbol" set ref 1276* 1279* 1282* 1284 1286 1287 other_increment 004767 automatic fixed bin(18,0) dcl 8272 set ref 8384* 8386* 8388 8388 other_value 004757 automatic fixed bin(35,0) dcl 8269 set ref 8308* 8311 8313 otherp 002174 automatic pointer dcl 4031 set ref 4037* 4042 4042 4044 4044 4045 4046 our_depth 002020 automatic fixed bin(18,0) dcl 3443 in procedure "optimize_flow_unit" set ref 3454* 3952 our_depth 001552 automatic fixed bin(18,0) dcl 2770 in procedure "optimize_subprogram" set ref 2881* 2913* 2925 2986* 2988* 3036* 3058 3093* 3365* 3382* 4759 our_depth 003240 automatic fixed bin(18,0) dcl 4943 in procedure "trim_operator_list" set ref 4947* 4952 our_level 000104 automatic fixed bin(18,0) dcl 1729 set ref 1743* 1770 our_statement 001466 automatic fixed bin(18,0) dcl 2560 set ref 2566* 2567 2594 2595 2598 2599 2606 ourp 001474 automatic pointer dcl 2562 set ref 2567* 2571 2572 2573 2574 2575 2592 2593 2596 2597 2603 2604 out_dt 003515 automatic fixed bin(4,0) dcl 5907 set ref 5922* 5926 5928 5967* outp 003512 automatic pointer dcl 5906 in procedure "constant_assign" set ref 5919* 5922 5956 5956 5960 5960 5971 outp 002026 automatic pointer dcl 3446 in procedure "optimize_flow_unit" set ref 3547* 3548 3551* 3641 3643 3646 3661 3661 3703 3760* 3768 3779 3796* 3803 3855 4038 4044 4046 4070 4141 4141 4144 4198 4198 4225 4225 4248 outp 004470 automatic pointer dcl 7681 in procedure "analyze_loop_index_values" set ref 7745* 7747 7747 7747 7761 7775* 7778* 7779 7783* 7790 7791* 7795* 7797 7798* 7833* 7839* 7841 outp 005042 automatic pointer dcl 8501 in procedure "is_suitable_loop_exit" set ref 8544* 8545 outp 002440 automatic pointer dcl 4581 in procedure "free_them" set ref 4607* 4609 4609 4609 outp 003662 automatic pointer dcl 6550 in procedure "reduce" set ref 6565* 6566 6566 outp 000110 automatic pointer dcl 5455 in procedure "constant_expression" set ref 5495* 5667 5687 5690 5694 outp 001704 automatic pointer dcl 3105 in procedure "finish_loop" set ref 3148* 3149 3149 3149 3149 3149* outp 001766 automatic pointer dcl 3295 in procedure "pop_loop" set ref 3320* 3321 3321 outp 005116 automatic pointer dcl 8627 in procedure "process_assignment_list" set ref 8640* 8645* 8657* 8671 8673 outp 003402 automatic pointer dcl 5174 in procedure "move" set ref 5201* 5202 5246 5247 outp 004406 automatic pointer dcl 7583 in procedure "remove_operator" set ref 7604* 7606 7606 7606 outp 003444 automatic pointer dcl 5365 in procedure "process_moved_descendants" set ref 5373* 5374 5374 5374* outp 003560 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6153* 6154 6162 6162 6167 6187* 6190 6354* 6355 6365* 6377 6382 6393 6400 outp 001732 automatic pointer dcl 3194 in procedure "push_loop" set ref 3239* 3240 3240 outp_node_type 002050 automatic fixed bin(18,0) dcl 3447 in procedure "optimize_flow_unit" set ref 3548* 3552* 3639 3646 3661 3707 3709 3758 3796 3796 3855 4132 4198 4222 outp_node_type 003372 automatic fixed bin(18,0) dcl 5173 in procedure "move" set ref 5202* 5204 5244 output 3 based fixed bin(18,0) level 2 dcl 1-144 set ref 837 917 920 959 1069 1075 1080 1095 1115 1414 1562 3148 3239 3320 3545 3547 3768 3908 3908 3910 3911 3943 3944 4071 4071 4163 4418* 4607 4671 5099 5201 5326 5343* 5370 5495 5919 6064 6153 6183* 6184 6242* 6269* 6354 6365 6394 6395* 6565 6587 6634* 6829 6852 6896 6988 7098* 7359 7602 7604 7743 7745 8100 8100 8104 8357 8359 8377 8468 8477 8535 8544 8640 output_by 6(18) based fixed bin(18,0) level 2 in structure "array_ref" packed packed unsigned unaligned dcl 2-155 in procedure "fort_optimizer" ref 1215 output_by 6(18) based fixed bin(18,0) level 2 in structure "temporary" packed packed unsigned unaligned dcl 2-1005 in procedure "fort_optimizer" set ref 4157 4238 4269 5424 7418* 7894 overflow 000212 stack reference condition dcl 5479 ref 5519 p 004160 automatic pointer dcl 7162 in procedure "used_in_loop" set ref 7177* 7180 7184* 7189 7189* 7189 7193 7194* 7194 7195 7199* 7199 p 004472 automatic pointer dcl 7681 in procedure "analyze_loop_index_values" set ref 7711* 7711* 7712 7714 7714 7714 7716* 7717 7720* 7720* 7721 7721 7721* 7723 7770* 7772 7772* 7772* 7781* 7785* 7785 7790 7820* 7823* 7823* 7826* 7830* 7833* 7836* p 004142 automatic pointer dcl 7117 in procedure "eliminate_increment" set ref 7123* 7124 7124* p 003742 automatic pointer dcl 6739 in procedure "create_var" set ref 6766* 6768 6769 6770 6771 6772 6772 6773 6775 6794 p 001724 automatic pointer dcl 3194 in procedure "push_loop" set ref 3201* 3201* 3203* 3204 3212* 3212* 3214* 3215 3237* 3237* 3238 3242* 3243 p 003266 automatic pointer dcl 4991 in procedure "detach_secondaries" set ref 4995* 4995* 4996 4998 5001 5008 5011* p 001530 automatic pointer dcl 2664 in procedure "create_flow_unit" set ref 2670* 2673* 2677 2679 2680 2681 2682 2683 2684 2685 2686 2689 p 002206 automatic pointer dcl 4064 in procedure "check_str_reducibility" set ref 4079* 4081 4084 4087 4087 4092 4094 4094 4094 p 004644 automatic pointer dcl 8084 in procedure "try_to_calculate_range" set ref 8091* 8093* 8097 8113* p 002366 automatic pointer dcl 4521 in procedure "set_equivalences" set ref 4528* 4530 4531 4533 4538 4538 p 004776 automatic pointer dcl 8432 in procedure "get_starting_value" set ref 8442* 8445 8447 8448 p 004316 automatic pointer dcl 7432 in procedure "remove_loop" set ref 7458* 7462* 7464 7464* 7464 7468 7469* 7469 7470 7474* 7474 p 005060 automatic pointer dcl 8579 in procedure "find_range" set ref 8585* 8589 8595* p 001752 automatic pointer dcl 3295 in procedure "pop_loop" set ref 3314* 3314* 3315 3316 3326 3331* 3337* 3337* 3338 3339 3345 3351* p 004624 automatic pointer dcl 7978 in procedure "process_comparison_list" set ref 7995* 7997* 8001* 8003* 8008* 8012* 8015* 8022* 8045* 8047* 8049* 8062* 8068* p 001416 automatic pointer dcl 2467 in procedure "summarize_loop_usage" set ref 2472* 2472* 2473 2473 2476 2477 2478* 2479 2481* 2481* 2482 2482 2485 2486 2487* 2488 p 005262 automatic pointer dcl 7-216 in procedure "connect_expression" set ref 7-222* 7-224 7-224 7-227 7-227 7-228 7-228 7-229* p 001312 automatic pointer dcl 2277 in procedure "detach_flow_units" set ref 2280* 2280* 2281 2283 2285 2290 2312* p 002030 automatic pointer dcl 3446 in procedure "optimize_flow_unit" set ref 3478* 3478* 3479 3481 3486* 3487 3488 3490 3491* 3492* 3494* 3494 3567* 3569 3577 3579 3580 3582 3583* 3583 3585 3590 3594 3596 3599 3614 3623 3625 3625* 3630 3631 3633 3670* 3670* 3671* 3678 3682* 3682* 3684* 3690 3703* 3711 3712* 3712 3716 3718 3734* 3735 3736 3737 3752* 3753 3754 3755 p 003232 automatic pointer dcl 4942 in procedure "trim_operator_list" set ref 4950* 4950* 4951 4952 4952* p 001146 automatic pointer dcl 1683 in procedure "flow_analysis" set ref 1698* 1699 1701 1708 1815* 1816 1821 1823 1830 1838 1839 1851* 1852 1856 1857 1858 1859 1868 1914* 1914* 1917 1919 1920 1921 1922* 1923 1931* 1931* 1932 1932* 1933 1937* 1937* 1938 1938* 1939 1946* 1946* 1947 1947 1950 1950* 1952 1966* 1967 1969* 1980* 1980* 1981 1982 1983 1984 1985 1989* 2004 2013* 2014 2015 p parameter pointer dcl 7950 in procedure "disqualify" ref 7945 7952 7952 7952 p 003666 automatic pointer dcl 6550 in procedure "reduce" set ref 6643* 6644 6644 p 003212 automatic pointer dcl 4889 in procedure "union" set ref 4905* 4906 4907 4917* 4917* 4918 4920 4922* 4924 p 001540 automatic pointer dcl 2698 in procedure "create_loop" set ref 2700* 2707 2708 2709 2710 2712 2713 2714 2715 2716 2717 2718 2719 2726 2726 2726 2726 2726 2726 2726 2726 2729 2732 2732 2732 2734 2736 2736 2736 2736 2736 2736 2736 2736 2736 2736 2736 2736 2736 2736 2736 2736 2741 2742 2743 2744 2748 p 000704 automatic pointer dcl 1173 in procedure "use_one_input" set ref 1182* 1184 1186 1191 1193 1202* 1206 1206* 1209 1211* 1215 1228 p 000102 automatic pointer array dcl 5455 in procedure "constant_expression" set ref 5492 5503* 5505 5507 5508 5714 5714 5725 5725 5737 5737 5749 5749 5756 5756 5763 5763 5770 5770 p 003644 automatic pointer dcl 6524 in procedure "is_invariant" set ref 6526* 6528 6531 6534 6534 6537 p 000100 automatic pointer dcl 7-238 in procedure "disconnect_temporary" set ref 7-244* 7-249 7-269 7-273 7-273 7-275 7-277 7-277 7-278 7-278 p 005242 automatic pointer dcl 7-179 in procedure "put_in_loop_end" set ref 7-186* 7-193 7-199 7-199 7-203* 7-205 p 003400 automatic pointer dcl 5174 in procedure "move" set ref 5201* 5204* 5204 5208 5210 5224* 5226 5226 5229 5233 5235* 5235 5236 p 003314 automatic pointer dcl 5060 in procedure "create_o_node" set ref 5063* 5066* 5070 5071 5072 5074 5075 p parameter pointer dcl 7882 in procedure "invariant" ref 7879 7886 7889 7889 7892 7894 p 004726 automatic pointer dcl 8262 in procedure "calculate_range_for_counter" set ref 8281* 8284 8286 8287* 8304* p 004660 automatic pointer dcl 8123 in procedure "calculate_range_by_subscripts" set ref 8137* 8143 8145 8146 p 002336 automatic pointer dcl 4430 in procedure "set" set ref 4433* 4434 4434* 4434 4437 4439 4441 4450 4452 4465 4470 4475 4485 4487* 4492* 4495* p 005216 automatic pointer dcl 7-110 in procedure "get_polish_space" set ref 7-114* 7-118 p 003304 automatic pointer dcl 5033 in procedure "release_node" set ref 5036* 5038 5038 5038 5040 5040 5042 5042 5046 5047 5050 5051 5053 p 002276 automatic pointer dcl 4334 in procedure "decrement_input_ref_counts" set ref 4342* 4343 4343 4343 4343 p parameter pointer dcl 7906 in procedure "check_busy_on_exit" set ref 7903 7912 7912* p 003572 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6206* 6206* 6207 6208 6208 6211* 6212 6229* 6231 6232 6249* 6250* 6314* 6316 6317 6318* 6318 6453* 6456 p 003162 automatic pointer dcl 4802 in procedure "intersection" set ref 4825* 4825* 4826 4828 4828* 4837* 4839 4840 4845 4852 4854* 4857 4864 4869* p parameter pointer dcl 7922 in procedure "eligible" ref 7917 7924 7924 7924 p 004234 automatic pointer dcl 7286 in procedure "create_da_node" set ref 7288* 7291* 7295 p 005142 automatic pointer dcl 7-9 in procedure "get_opt_space" set ref 7-13* 7-18 p 000604 automatic pointer dcl 783 in procedure "build_flow_units" set ref 1008* 1008* 1009* 1010 1075* 1076 1076* 1076 1079* p 005306 automatic pointer dcl 8717 in procedure "print_hash_bucket_meters" set ref 8721* 8721* 8723 8730* 8730* 8732 p 002006 automatic pointer dcl 3415 in procedure "create_lp_frame" set ref 3417* 3419 3420 3421 3423 3425 p 001170 automatic pointer dcl 2033 in procedure "create_new_back_target" set ref 2043* 2045 2049 2050 2051 2052 2053 2055 2065 2067 2074 2078 2108 2125 2142* p 000110 automatic pointer dcl 1730 in begin block on line 1724 set ref 1733* 1735 1735 1743 1747 1764 1778 1781 1782 p parameter pointer dcl 8606 in procedure "create_range" ref 8603 8612 p 004404 automatic pointer dcl 7583 in procedure "remove_operator" set ref 7592* 7594 7594 7594 7597 7597 7597 p 002246 automatic pointer dcl 4259 in procedure "process_frozen_for_do" set ref 4265* 4269 4294 4294 4300 4300 4309* 4310 4311 4312 4319 4319 p 004116 automatic pointer dcl 7032 in procedure "change_test" set ref 7043* 7043* 7044 7044 7044 7049 7050 7053 7053 7055 7056* 7058 p 000100 automatic pointer dcl 5086 in procedure "release_primary" set ref 5088* 5090 5090 5090 5092 5092 5094 5097 5102 5103 5104 5106 p 003710 automatic pointer dcl 6673 in procedure "search_for_equivalent" set ref 6683* 6685 6688 6690 6691 6698* 6698 p 001700 automatic pointer dcl 3105 in procedure "finish_loop" set ref 3113* 3113* 3114* 3115 3144* 3144* 3145 3147 3155* p 004044 automatic pointer dcl 6930 in procedure "force_used_in_loop" set ref 6943* 6946* 6948 6948* 6948 6952 6953* 6953 6954 6958* 6958 p 002442 automatic pointer dcl 4581 in procedure "free_them" set ref 4589* 4590 4592 4597* 4619* 4630* p 001336 automatic pointer dcl 2326 in procedure "detach_flow_unit" set ref 2328* 2332 2333 2336 2337 2342* p 004224 automatic pointer dcl 7273 in procedure "chain_dac" set ref 7275* 7276 7277 7278 7279 p 003466 automatic pointer dcl 5415 in procedure "put_in_a_loop_end" set ref 5418* 5424 5439 5439* 5442 p parameter pointer dcl 7-66 in procedure "chain_input" ref 7-62 7-79 7-79 7-82 7-85 p 005152 automatic pointer dcl 7-30 in procedure "create_chain" set ref 7-37* 7-39 p 003324 automatic pointer dcl 5116 in procedure "create_primary" set ref 5118* 5121* 5125 5126 5127 5129 5131 p 003250 automatic pointer dcl 4967 in procedure "clear" set ref 4971* 4971* 4972 4973* p 003446 automatic pointer dcl 5365 in procedure "process_moved_descendants" set ref 5383* 5385 5385 5385* 5391 5393 5393* 5395* 5395 5398 5401 p 000736 automatic pointer dcl 1308 in procedure "set" set ref 1314* 1316 1321* 1323* 1323 1327 1329 1336 1338 1340 p 003140 automatic pointer dcl 4720 in procedure "process_jump_label" set ref 4777* 4783* 4784* p 001400 automatic pointer dcl 2391 in procedure "compute_busy_on_exit" set ref 2402* 2403 2405 p1 003670 automatic pointer dcl 6550 set ref 6623* 6625 6627 p2 003672 automatic pointer dcl 6550 set ref 6591* 6592 6607 6610 6614* 6625 6628 p_adam parameter pointer dcl 7152 ref 7147 7165 p_bt parameter pointer dcl 5168 ref 5165 5179 p_code parameter fixed bin(18,0) dcl 4649 ref 4646 4660 p_detach_constant_assignments parameter bit(1) dcl 4989 ref 4984 4993 p_do_analysis parameter bit(1) dcl 7678 ref 7675 7697 p_dt parameter fixed bin(4,0) dcl 4521 ref 4518 4529 p_fu parameter pointer dcl 3440 in procedure "optimize_flow_unit" ref 3429 3452 p_fu parameter pointer dcl 5168 in procedure "move" ref 5165 5178 p_fu parameter pointer dcl 7152 in procedure "used_in_loop" set ref 7147 7245* p_i parameter fixed bin(18,0) dcl 4803 ref 4794 4807 p_induction_var parameter fixed bin(18,0) dcl 7152 ref 7147 7166 p_inp parameter pointer dcl 4408 ref 4405 4415 p_ins parameter pointer dcl 2034 in procedure "create_new_back_target" ref 2030 2044 p_ins parameter pointer dcl 2149 in procedure "insert_flow_unit_before" ref 2146 2156 p_list 000432 automatic pointer array level 2 in structure "p_list_st" packed packed unaligned dcl 285 in procedure "fort_optimizer" set ref 505* 3200 3201 3234 3237 3250 3252* 3485 3486 3670 4749 4750 4824 4825 4970 4971 5161 8719 8721 p_list parameter pointer array level 2 in structure "p_list_st" packed packed unaligned dcl 4885 in procedure "union" ref 4903 4904 4916 4917 p_list_st parameter structure array level 1 dcl 4885 in procedure "union" ref 4879 p_list_st 000432 automatic structure array level 1 dcl 285 in procedure "fort_optimizer" set ref 3325* 3397* 3752* 4863* p_lp parameter pointer dcl 8495 in procedure "is_suitable_loop_exit" ref 8492 8511 p_lp parameter pointer dcl 6875 in procedure "find_new_induction_vars_on_ass_chain" ref 6872 6885 p_lp parameter pointer dcl 2872 in procedure "optimize_loop" ref 2867 2878 p_lp parameter pointer dcl 7678 in procedure "analyze_loop_index_values" ref 7675 7696 p_lp parameter pointer dcl 4563 in procedure "set_loop_variants" ref 4560 4565 p_lp parameter pointer dcl 6001 in procedure "reduce_strength" ref 5996 6029 p_new parameter pointer dcl 3931 ref 3926 3939 p_new_out parameter fixed bin(18,0) dcl 4409 ref 4405 4413 p_o parameter pointer dcl 8495 in procedure "is_suitable_loop_exit" ref 8492 8510 p_o parameter pointer dcl 1669 in procedure "make_constant_opt_subscript" ref 1666 1672 p_o parameter pointer dcl 5453 in procedure "constant_expression" ref 5448 5488 p_o parameter pointer dcl 7-238 in procedure "disconnect_temporary" ref 7-236 7-245 p_o parameter pointer dcl 7581 in procedure "remove_operator" ref 7578 7586 p_o parameter pointer dcl 7152 in procedure "used_in_loop" set ref 7147 7243* p_o parameter pointer dcl 6844 in procedure "add_new_induction_var" ref 6841 6850 p_o parameter pointer dcl 5360 in procedure "process_moved_descendants" ref 5352 5367 p_o parameter pointer dcl 5307 in procedure "free_operator" ref 5301 5312 p_o parameter pointer dcl 5168 in procedure "move" ref 5165 5176 p_o parameter pointer dcl 5141 in procedure "hash" ref 5135 5149 p_o parameter pointer dcl 6547 in procedure "reduce" ref 6541 6555 p_o parameter pointer dcl 4649 in procedure "record_secondaries" ref 4646 4658 p_o parameter pointer dcl 4334 in procedure "decrement_input_ref_counts" ref 4328 4336 p_o parameter pointer dcl 5904 in procedure "constant_assign" ref 5893 5916 p_old parameter pointer dcl 3931 ref 3926 3938 p_our_depth parameter fixed bin(18,0) dcl 3443 ref 3429 3454 p_secp parameter pointer dcl 4551 in procedure "free_secondary" set ref 4548 4553 4554* p_secp parameter pointer dcl 4579 in procedure "free_them" ref 4576 4586 p_st_found parameter fixed bin(18,0) dcl 7152 set ref 7147 7244* p_state parameter pointer dcl 4802 ref 4794 4806 p_stm parameter pointer dcl 5168 ref 5165 5177 p_which parameter fixed bin(18,0) dcl 7-211 in procedure "connect_expression" ref 7-209 7-218 p_which parameter fixed bin(18,0) dcl 6547 in procedure "reduce" ref 6541 6556 pa parameter pointer dcl 3882 ref 3879 3887 parameter 11(04) based bit(1) level 4 packed packed unaligned dcl 2-844 ref 711 725 1253 1340 4450 4457 4475 4511 4538 8241 parent 11(18) based fixed bin(18,0) level 2 in structure "array_ref" packed packed unsigned unaligned dcl 2-155 in procedure "fort_optimizer" ref 1076 1228 1323 3583 3712 3996 4434 4689 5204 5235 5395 parent 7 based fixed bin(18,0) level 2 in structure "symbol" packed packed unsigned unaligned dcl 2-844 in procedure "fort_optimizer" ref 4530 4538 partial_fu constant fixed bin(18,0) initial dcl 295 set ref 3382* passed_as_arg 0(28) based bit(1) level 5 packed packed unaligned dcl 2-844 ref 714 pb parameter pointer dcl 3882 ref 3879 3888 pf 000540 automatic fixed bin(18,0) dcl 603 in procedure "timer" set ref 617* 620 622 pf 003142 automatic pointer dcl 4720 in procedure "process_jump_label" set ref 4775* 4780 4781 4782* 4782 pf 5 000460 automatic fixed bin(18,0) array level 3 in structure "timing_info" dcl 455 in procedure "fort_optimizer" set ref 575 581* 613* 620* 620 place 005162 automatic fixed bin(18,0) dcl 7-48 set ref 7-50* 7-58 plp parameter pointer dcl 8579 ref 8574 8586 pnum 001154 automatic fixed bin(18,0) dcl 1684 in procedure "flow_analysis" set ref 1816* 1823 1852* 1867 1874 1981* 2001 pnum 001214 automatic fixed bin(18,0) dcl 2037 in procedure "create_new_back_target" set ref 2045* 2057 2078 polish based fixed bin(18,0) array dcl 388 set ref 722 938 939 947 948 948 1101 1102 1108 1109 1109 3850 3851 3851 3984 3988 4038 4045 4070 4319 4319 4609 5667 5690 5694 6154 6355 6382 6587 7606 7606 7848 7849 7849 8545 7-82 7-114 7-249 7-292 7-293 polish_base 000374 automatic pointer dcl 266 in procedure "fort_optimizer" set ref 497* 722 938 939 947 948 948 1101 1102 1108 1109 1109 3850 3851 3851 3984 3988 4038 4045 4070 4319 4319 4609 5667 5690 5694 6154 6355 6382 6587 7606 7606 7848 7849 7849 8545 7-82 7-114 7-249 7-292 7-293 polish_base based pointer level 2 in structure "shared_globals" dcl 477 in procedure "fort_optimizer" ref 497 polish_max_len 34 based fixed bin(19,0) level 2 in structure "shared_globals" dcl 477 in procedure "fort_optimizer" ref 492 polish_max_len 000376 automatic fixed bin(19,0) dcl 267 in procedure "fort_optimizer" set ref 492* 7-118 7-122 7-122 position 10 based fixed bin(17,0) level 2 dcl 1-46 set ref 802* 1433* 1947 1947 1950 1950 1969 1969 2063 2085 2169* 2169 2176* 2176 3149 4736 4736 5430 5432 7-205 possibly_found 002063 automatic bit(1) dcl 3449 in procedure "optimize_flow_unit" set ref 3666* 3668 possibly_found 003176 automatic bit(1) dcl 4804 in procedure "intersection" set ref 4862* possibly_found 001751 automatic bit(1) dcl 3294 in procedure "pop_loop" set ref 3324* 3343* possibly_found parameter bit(1) dcl 5141 in procedure "hash" set ref 5135 5158* possibly_found 002255 automatic bit(1) dcl 4263 in procedure "process_frozen_for_do" set ref 4308* pr 001204 automatic pointer dcl 2036 in procedure "create_new_back_target" set ref 2076* 2078 2078 2085 2096 2108 2108* 2125 2125* 2129 2132 2133 2133 2134* pr parameter pointer dcl 2238 in procedure "splice_in_another_fu" ref 2235 2246 2249 2250 2251 pr 000104 automatic pointer dcl 5309 in procedure "free_operator" set ref 5318* 5319* predecessors 3 based pointer level 2 packed packed unaligned dcl 1-46 set ref 1654 1655* 1708 1747 1773 1821 1871 2074 2206* 2213 2215* 2332 2333 2360* 2417 pregs_used 32 based fixed bin(4,0) level 2 dcl 1-100 set ref 2732* prev 004022 automatic pointer dcl 6877 in procedure "find_new_induction_vars_on_ass_chain" set ref 6891* 6909 6909 6916* prev 001542 automatic pointer dcl 2698 in procedure "create_loop" set ref 2708* 2710 2710 prev based pointer level 2 in structure "sr_frame" packed packed unaligned dcl 6014 in procedure "reduce_strength" set ref 6318 6417 6698 6723* prev_brother 4 based pointer level 2 packed packed unaligned dcl 1-100 set ref 1923 2708* 2726* prev_fu 004626 automatic pointer dcl 7978 set ref 8051* 8056 8058* prev_operator 1(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 1-176 set ref 1594 2098 2296 2308* 2587 2597* 7-144 7-149 primary based structure level 1 dcl 1-234 in procedure "fort_optimizer" set ref 5020 5021 5050 5051 5063 5063 5063 5066 5067 5067 5118 5118 5118 5121 5122 5122 primary 2 based pointer level 2 in structure "operator" packed packed unaligned dcl 1-144 in procedure "fort_optimizer" set ref 2632* 3327* 3346* 3737* 3755* 3762 3950 3971 4238 4306 4312* 4593* 4615 4619 4620* 4705 4845 4865* 5098* 5316 5318 5424 primary 3 based pointer level 2 in structure "secondary" packed packed unaligned dcl 392 in procedure "fort_optimizer" set ref 3599 4588 4641 4699* 4706 4707* 5001 5008 print_message 1530 based entry variable level 2 dcl 477 ref 483 698 981 1135 2163 2301 2643 3170 4627 5781 6384 6790 7442 7-54 7-122 7-262 9-29 8-45 processed 15 based bit(1) level 3 packed packed unaligned dcl 1-46 set ref 801* 2976* 3478 3877* pt parameter pointer dcl 7-238 in procedure "disconnect_temporary" ref 7-236 7-244 pt parameter pointer dcl 2033 in procedure "create_new_back_target" ref 2030 2043 pt parameter pointer dcl 8432 in procedure "get_starting_value" ref 8429 8442 pt parameter pointer dcl 5415 in procedure "put_in_a_loop_end" ref 5412 5418 pt parameter pointer dcl 2326 in procedure "detach_flow_unit" ref 2320 2328 pt parameter pointer dcl 4430 in procedure "set" ref 4425 4433 pt parameter pointer dcl 7-179 in procedure "put_in_loop_end" ref 7-177 7-186 pt parameter pointer dcl 5033 in procedure "release_node" ref 5027 5036 pt parameter pointer dcl 8579 in procedure "find_range" ref 8574 8585 pt parameter pointer dcl 4521 in procedure "set_equivalences" ref 4518 4528 pt parameter pointer dcl 8084 in procedure "try_to_calculate_range" ref 8081 8091 pt parameter pointer dcl 8262 in procedure "calculate_range_for_counter" ref 8259 8281 pt parameter pointer dcl 4259 in procedure "process_frozen_for_do" ref 4254 4265 pt parameter pointer dcl 5086 in procedure "release_primary" ref 5079 5088 pt parameter pointer dcl 8123 in procedure "calculate_range_by_subscripts" ref 8120 8137 pt1 parameter pointer dcl 213 ref 20 487 put_in_map 4 based bit(1) level 3 packed packed unaligned dcl 1-176 set ref 817 2574* 2824* q 003122 automatic pointer dcl 4720 in procedure "process_jump_label" set ref 4750* 4750* 4752 4753* 4754 4762* 4762* 4764 4765* 4767 q 000112 automatic pointer dcl 5455 in procedure "constant_expression" set ref 5670* 5673 5675 5676 5678 5680 5682 q 002032 automatic pointer dcl 3446 in procedure "optimize_flow_unit" set ref 3490* 3492 3671* 3672* 3674* 3684* 3685* 3687* q 003602 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6231* 6234 6239 q 001112 automatic pointer dcl 1644 in procedure "link" set ref 1654* 1656 1656 1659* 1661 1661 q 002340 automatic pointer dcl 4430 in procedure "set" set ref 4456* 4457 4457 4457 4474* 4475 4475 4475 q 001150 automatic pointer dcl 1683 in procedure "flow_analysis" set ref 1702* 1703 1705 1707 1708 1708 1822* 1823 1823 1872* 1874 1874 1874 1879 1880 1881 1967* 1969 1969 1969* 1973 1974 1991* 1995 1995 q 005206 automatic pointer dcl 7-92 in procedure "create_input_to" set ref 7-94* 7-97* 7-101 q 003234 automatic pointer dcl 4942 in procedure "trim_operator_list" set ref 4951* 4954 q 002372 automatic pointer dcl 4524 in procedure "set_equivalences" set ref 4537* 4538 4538 4538 4538 4538 4538 4538 q 001402 automatic pointer dcl 2391 in procedure "compute_busy_on_exit" set ref 2418* 2419 2419 2422 2422 2422 2426 2428 2429 2429 2434 2435 q 001612 automatic pointer dcl 2780 in procedure "optimize_subprogram" set ref 2857* 2858 2858 2858 2860* 2863 2966* 2966* 2967* q 001176 automatic pointer dcl 2036 in procedure "create_new_back_target" set ref 2047* 2049 2050 2051 2052 2053 2061 2063 2067 2069 2069* 2090* 2108* 2125* 2129 2142* 2144 q 003270 automatic pointer dcl 4991 in procedure "detach_secondaries" set ref 4996* 5013 q 003252 automatic pointer dcl 4967 in procedure "clear" set ref 4972* 4974 q 001726 automatic pointer dcl 3194 in procedure "push_loop" set ref 3202* 3203 3213* 3214 q 004122 automatic pointer dcl 7032 in procedure "change_test" set ref 7086* 7089 7096 q 001232 automatic pointer dcl 2153 in procedure "insert_flow_unit_before" set ref 2158* 2168 2169 2170 2171 2172 2173 2173 2179 2180 2181 2184 2187 2191 q 001272 automatic pointer dcl 2242 in procedure "splice_in_another_fu" set ref 2246* 2248 2249 2250 2251 2252 2258 2260* 2264* 2266* q 003214 automatic pointer dcl 4889 in procedure "union" set ref 4904* 4904* 4906* 4908 q 001754 automatic pointer dcl 3295 in procedure "pop_loop" set ref 3315* 3332 3338* 3352 q 000710 automatic pointer dcl 1175 in procedure "use_one_input" set ref 1215* 1218 1220 q 001702 automatic pointer dcl 3105 in procedure "finish_loop" set ref 3145* 3156 q 003474 automatic pointer dcl 5415 in procedure "put_in_a_loop_end" set ref 5428* 5428* 5430 5432 5433* 5435 q 005174 automatic pointer dcl 7-71 in procedure "chain_input" set ref 7-73* 7-75 7-76 7-77 7-78 7-83 q 000112 automatic pointer dcl 1730 in begin block on line 1724 set ref 1748* 1749 1751 1752 1768* 1770 1770 1773 q_statement 001236 automatic fixed bin(18,0) dcl 2154 in procedure "insert_flow_unit_before" set ref 2179* 2180 2181 2183 2186* q_statement 001324 automatic fixed bin(18,0) dcl 2278 in procedure "detach_flow_units" set ref 2290* 2291 q_statement parameter fixed bin(18,0) dcl 2518 in procedure "create_label" ref 2513 2526 2527 qlab 001450 automatic pointer dcl 2521 set ref 2524* 2527 2528 2529 2529 qlabel 001446 automatic fixed bin(18,0) dcl 2520 in procedure "create_label" set ref 2523* 2524 2526 2530 2531 2533 qlabel 001213 automatic fixed bin(18,0) dcl 2037 in procedure "create_new_back_target" set ref 2047* 2100 2105 2108* 2114 2121 2125* 2134* qlabel 001237 automatic fixed bin(18,0) dcl 2154 in procedure "insert_flow_unit_before" set ref 2186* 2189 qnum 001155 automatic fixed bin(18,0) dcl 1684 set ref 1699* 1705 qoff 005172 automatic fixed bin(18,0) dcl 7-70 set ref 7-78* 7-79 7-85 qpos 001216 automatic fixed bin(18,0) dcl 2037 set ref 2063* 2085 qst 001234 automatic pointer dcl 2153 in procedure "insert_flow_unit_before" set ref 2183* 2184 2190 qst 001206 automatic pointer dcl 2036 in procedure "create_new_back_target" set ref 2047* 2085 qst 001314 automatic pointer dcl 2277 in procedure "detach_flow_units" set ref 2291* 2292 2301 2305 quad based fixed bin(18,0) array dcl 390 set ref 808 824 1052 1059 1215 1497 1499 1501 1525 1559 1592 1593 1594 1830 2065 2096 2097 2098 2183 2231 2286 2291 2293 2295 2297 2526 2567 2579 2581 2588 2624 2650 2651 2824 2834 2957 3268 3268 3374 3459 3538 3542 4157 4238 4269 4723 4731 4892 5181 5189 5190 5264 5277 5424 6182 6242 6245 6245 6268 6633 7098 7228 7234 7337 7492 7498 7500 7528 7552 7556 7627 7629 7735 7740 7894 8060 8153 8158 8166 8330 8335 8342 8459 8523 8530 8557 7-138 7-139 7-149 7-165 7-166 7-220 quad_max_len 37 based fixed bin(19,0) level 2 in structure "shared_globals" dcl 477 in procedure "fort_optimizer" ref 490 quad_max_len 000377 automatic fixed bin(19,0) dcl 268 in procedure "fort_optimizer" set ref 490* 7-52 7-54 7-54 quadruple_base 6 based pointer level 2 in structure "shared_globals" dcl 477 in procedure "fort_optimizer" ref 495 quadruple_base 000400 automatic pointer dcl 269 in procedure "fort_optimizer" set ref 495* 808 824 1052 1059 1215 1497 1499 1501 1525 1559 1592 1593 1594 1830 2065 2096 2097 2098 2183 2231 2286 2291 2293 2295 2297 2526 2567 2579 2581 2588 2624 2650 2651 2824 2834 2957 3268 3268 3374 3459 3538 3542 4157 4238 4269 4723 4731 4892 5181 5189 5190 5264 5277 5424 6182 6242 6245 6245 6268 6633 7098 7228 7234 7337 7492 7498 7500 7528 7552 7556 7627 7629 7735 7740 7894 8060 8153 8158 8166 8330 8335 8342 8459 8523 8530 8557 7-138 7-139 7-149 7-165 7-166 7-220 queue 002454 automatic pointer array packed unaligned dcl 4583 set ref 4594* 4603 4606 4623 4625* 4627 r 004630 automatic pointer dcl 7978 in procedure "process_comparison_list" set ref 8012* 8013 8013 8015 8015 8049* 8053 8064 8064 8068 r 005064 automatic pointer dcl 8583 in procedure "find_range" set ref 8588* 8588* 8589 8589* 8591 8595* 8596 8599 r 005074 automatic pointer dcl 8609 in procedure "create_range" set ref 8611* 8612 8613 8614 8616 r1 002122 automatic pointer dcl 3884 set ref 3910* 3912 3914 r2 002124 automatic pointer dcl 3884 set ref 3911* 3912 rands based fixed bin(18,0) array dcl 386 set ref 527 534 653 656 668 676 704 754 811 811 858 909 922 937 946 948 948 1075 1076 1099 1106 1109 1109 1182 1191 1220 1228 1314 1323 1496 1525 1559 1562 1595 1673 1674 2524 2530 2857 3148 3239 3320 3547 3567 3583 3646 3712 3810 3810 3848 3851 3851 3910 3911 3945 3946 3996 4037 4079 4128 4173 4273 4342 4434 4607 4672 4687 4689 4723 5099 5201 5204 5224 5235 5287 5329 5373 5383 5395 5495 5503 5675 5918 5919 6078 6081 6153 6196 6279 6354 6365 6448 6449 6526 6565 6587 6591 6614 6623 6643 6766 6779 6829 6852 6853 6896 6897 6989 7044 7075 7107 7107 7110 7123 7167 7319 7402 7407 7592 7604 7745 7761 7761 7770 7785 7803 7805 7820 7830 7846 7849 7849 7939 7939 7995 8001 8017 8100 8100 8104 8104 8173 8187 8239 8304 8308 8350 8359 8383 8388 8388 8479 8482 8544 8556 8639 8640 7-222 7-290 range based structure level 1 dcl 1-243 set ref 8611 8611 range_bits 004651 automatic structure level 1 packed packed unaligned dcl 8089 in procedure "try_to_calculate_range" set ref 8093* 8099 8100* 8104* 8113 8113* 8116 range_bits 004730 automatic structure level 1 packed packed unaligned dcl 8264 in procedure "calculate_range_for_counter" set ref 8282* 8425 range_bits 2 based structure level 3 in structure "range" packed packed unaligned dcl 1-243 in procedure "fort_optimizer" range_bits 004662 automatic structure level 1 packed packed unaligned dcl 8125 in procedure "calculate_range_by_subscripts" set ref 8208* 8214 range_bits 004635 automatic structure level 1 packed packed unaligned dcl 7983 in procedure "process_comparison_list" set ref 8008* 8010 8013 8062* 8064 range_list 35 based pointer level 2 packed packed unaligned dcl 1-100 set ref 2736* 8588 8613 8614* rc_t constant bit(6) initial packed unaligned dcl 10-6 ref 8-84 read_namelist_op constant fixed bin(18,0) initial dcl 3-197 ref 7342 8461 real_flt_bin_1_dtype constant fixed bin(17,0) initial dcl 6-25 ref 5877 real_flt_bin_2_dtype constant fixed bin(17,0) initial dcl 6-25 ref 5858 real_flt_hex_1_dtype constant fixed bin(17,0) initial dcl 6-25 ref 5875 real_flt_hex_2_dtype constant fixed bin(17,0) initial dcl 6-25 ref 5856 real_mode constant fixed bin(4,0) initial dcl 3-106 set ref 1276 1279 1366 1369 4492 4495* 5849 5851 5873 real_picture 000112 automatic picture(16) packed unaligned dcl 5837 set ref 5878 5878 5878 5878 5880 5881 5883 5884 5885 reducible 002055 automatic bit(1) dcl 3449 set ref 3559* 3580* 3631* 3641* 3656 ref_count 6 based fixed bin(17,0) level 2 in structure "temporary" packed packed unaligned dcl 2-1005 in procedure "fort_optimizer" set ref 3964 3980 3982* 3982 3982 3983* 4044* 4044 4044 4196 4206* 4206 4343* 4343 6167* 6190* 6377 6400 7597* 7597 7747 7-199* 7-199 7-227* 7-227 7-277* 7-277 ref_count 6 based fixed bin(17,0) level 2 in structure "array_ref" packed packed unaligned dcl 2-155 in procedure "fort_optimizer" set ref 4198* 4198 7594* 7594 ref_count_copy 11 based fixed bin(17,0) level 2 packed packed unaligned dcl 2-1005 set ref 7747* 7-228* 7-228 7-278* 7-278 referenced 0(27) based bit(1) level 5 in structure "label" packed packed unaligned dcl 2-530 in procedure "fort_optimizer" set ref 2529* referenced 0(27) based bit(1) level 5 in structure "symbol" packed packed unaligned dcl 2-844 in procedure "fort_optimizer" set ref 2858* referenced_backwards 4(03) based bit(1) level 3 packed packed unaligned dcl 1-176 set ref 2085* 3472 5289* 5289 5290* referenced_by_assign 4(04) based bit(1) level 3 packed packed unaligned dcl 1-176 set ref 1535* 1830 3472 4736 4809 4893 5291* 5291 5292* referenced_executable 0(29) based bit(1) level 4 packed packed unaligned dcl 2-530 set ref 811 2529* rel builtin function dcl 470 ref 5193 6216 6329 6408 7101 7101 8097 8146 8447 8517 7-78 7-193 7-269 7-275 rel_constant constant fixed bin(4,0) initial dcl 3-120 ref 2528 reloc 2(12) based bit(6) level 2 packed packed unaligned dcl 2-256 set ref 8-84* removable 4(07) based bit(1) level 3 packed packed unaligned dcl 1-176 set ref 1509* 2301 removed 15(08) based bit(1) level 3 packed packed unaligned dcl 1-46 set ref 2548* 7324 restore_prs 0(32) based bit(1) level 3 packed packed unaligned dcl 2-530 set ref 909* result 000126 automatic bit(72) dcl 5466 in procedure "constant_expression" set ref 5634* 5637* 5641* 5650* 5687* result 000116 automatic varying char(35) dcl 5837 in procedure "literal_value" set ref 5848* 5849* 5849 5850* 5850 5851* 5851 5852* 5852 5862* 5863* 5863 5864* 5864 5865* 5865 5866* 5866 5871* 5881* 5882* 5882 5883* 5883 5884* 5884 5885* 5885 5887* 5888 resume_st 13 based fixed bin(18,0) level 3 dcl 434 set ref 3270* 3373 reverse_rel_op 000337 constant fixed bin(18,0) initial array dcl 7035 ref 7104 right 004002 automatic pointer dcl 6846 in procedure "add_new_induction_var" set ref 6853* 6858 6862 right 004030 automatic pointer dcl 6878 in procedure "find_new_induction_vars_on_ass_chain" set ref 6897* 6899 rin 005120 automatic pointer dcl 8627 set ref 8660* 8661 8664* 8665 rout 005122 automatic pointer dcl 8627 set ref 8657* 8658 8665 s 003766 automatic pointer dcl 6823 in procedure "output_is_new_induction_var" set ref 6829* 6831 6831 6831 6831 6831 s 004670 automatic pointer dcl 8126 in procedure "calculate_range_by_subscripts" set ref 8173* 8179 8179 8192* s 002424 automatic pointer dcl 4563 in procedure "set_loop_variants" set ref 4568* 4569 s parameter pointer dcl 1238 in procedure "use_symbol" ref 1235 1241 1243 1249 1251 1253 s 004744 automatic pointer dcl 8266 in procedure "calculate_range_for_counter" set ref 8350* 8351 8351 8359* 8360 8360 s 000706 automatic pointer dcl 1174 in procedure "use_one_input" set ref 1220* 1223 1223* 1228* 1229* s 003104 automatic pointer dcl 4683 in procedure "record" set ref 4687* 4689 4689* 4689 4692 4692 4695 4698 4700 4702 s 000552 automatic pointer dcl 634 in procedure "assign_symbol_coordinates" set ref 656* 658 658 667 668 668 671 676* 678 681 681 681 685 704* 706 708 708 708 708 708 708 711 711 711 711 714 714 714 714 714 714 714 720 720 721 722 722 725 725 728 730 730 732 754* 756 758 760 763 763 766 768 773 s 002354 automatic pointer dcl 4506 in procedure "set_externals" set ref 4510* 4511 4511 s parameter pointer dcl 8221 in procedure "get_max_size" ref 8218 8233 8237 8239 8241 8241 8241 8241 8249 8249 8253 s 002252 automatic pointer dcl 4261 in procedure "process_frozen_for_do" set ref 4273* 4275 4281 4281 4281 s_list 000402 automatic pointer dcl 270 set ref 512* 4445* 4454 4472 4508 4535 4556* 4566 4697* 4995 5011* 6305* scan_bits 000100 automatic bit dcl 1727 in begin block on line 1724 set ref 1756* 1757* 1790 1799* scan_bits based bit dcl 363 in procedure "fort_optimizer" set ref 1847 1847 1865* 1867* 1874 1880* 2014* 2015* 2016 scan_bits_p 000404 automatic pointer dcl 271 set ref 1847* 1847 1847 1865 1867 1874 1880 2014 2015 2016 scan_vector 000100 automatic pointer array packed unaligned dcl 1726 in begin block on line 1724 set ref 1764* 1768 1801* scan_vector based pointer array level 2 in structure "scan_vector_st" packed packed unaligned dcl 376 in procedure "fort_optimizer" set ref 1868* 1871 1879* 2405* 2414 2434* scan_vector_p 000406 automatic pointer dcl 272 set ref 1846* 1846 1846 1868 1871 1879 2405 2414 2434 scan_vector_st based structure level 1 dcl 376 set ref 1846 1846 secondary 15(25) based pointer level 2 in structure "symbol" packed packed unaligned dcl 2-844 in procedure "fort_optimizer" set ref 706* 1564 1576 1577* 1597 1618 1622 1623* 3599 4441 4695 4700* 4702 5046* 6302 6304 6305 6307* 6448* 6775* 6862 7779* 7790* 7797* 7841* 8143 8145 8284 8286 8383 8671 8671 8673* 8673 secondary based structure level 1 dcl 392 in procedure "fort_optimizer" secp 002434 automatic pointer dcl 4579 in procedure "free_them" set ref 4586* 4588 4641 secp 002356 automatic pointer dcl 4506 in procedure "set_externals" set ref 4508* 4509 4510 4511* 4513* 4513 secp 002410 automatic pointer dcl 4551 in procedure "free_secondary" set ref 4553* 4554 4555* 4556* secp 002374 automatic pointer dcl 4524 in procedure "set_equivalences" set ref 4535* 4536 4537 4538* 4543* 4543 secp 002422 automatic pointer dcl 4563 in procedure "set_loop_variants" set ref 4566* 4567 4568 4569* 4571* 4571 secp 002342 automatic pointer dcl 4430 in procedure "set" set ref 4441* 4442 4444* 4445* 4454* 4455 4456 4457* 4459* 4459 4472* 4473 4474 4475* 4477* 4477 secp 003106 automatic pointer dcl 4683 in procedure "record" set ref 4697* 4698 4699 4700 4702* 4706 4707 section 000407 constant varying char(25) initial array dcl 450 set ref 579 581* set 21 based pointer level 2 in structure "loop" packed packed unaligned dcl 1-100 in procedure "fort_optimizer" set ref 1036 2473 2476 2476 2482 2482 2485 2485 2485 2742* 2891 3162 3284 3528 3586 3615 4092 4147 4233 4281 4569 5214 6203 6208 6211 6537 7135 7576 7708 7714 7721 7889 set 17 based pointer level 2 in structure "flow_unit" packed packed unaligned dcl 1-46 in procedure "fort_optimizer" set ref 1043 1332 1334 1342 1345 1345 1351 1354 1374 1377 1408 1410 1410 2473 2476 2680* 4281 5211 5211 5215 6198 7324 7368 7374 7567 8445 set 0(26) based bit(1) level 5 in structure "symbol" packed packed unaligned dcl 2-844 in procedure "fort_optimizer" set ref 714 2858* set_multiple 21 based pointer level 2 in structure "flow_unit" packed packed unaligned dcl 1-46 in procedure "fort_optimizer" set ref 1043 1332 1342 1342 1351 1374 1408 1408 2473 2683* 5213 7366 7375 7567 set_multiple 23 based pointer level 2 in structure "loop" packed packed unaligned dcl 1-100 in procedure "fort_optimizer" set ref 1036 2473 2473 2482 2482 2482 2743* 3719 4094 4141 4147 4225 6208 6831 7576 shared_globals based structure level 1 dcl 477 shared_struc_ptr 000410 automatic pointer dcl 273 set ref 483 487* 489 490 491 492 494 495 496 497 533 533 533 534 590 591 698 807 807 808 981 988 1051 1051 1052 1135 1434 2162 2163 2285 2286 2301 2643 3170 3536 3536 3538 4627 5333 5334 5630 5632 5634 5637 5641 5650 5781 5928 5960 6384 6393 6394 6790 7225 7225 7228 7244 7399 7406 7408 7441 7442 7550 7550 7552 7732 7732 7735 7-13 7-16 7-16 7-18 7-22 7-22 7-22 7-50 7-51 7-51 7-52 7-54 7-114 7-116 7-116 7-118 7-122 7-262 9-20 9-22 9-23 9-23 9-29 8-45 8-87 8-87 8-89 8-89 8-91 8-93 sign 12 based bit(1) level 3 dcl 6014 set ref 6107* 6117* 6255 6297 6297 6597* 6597 6615* 6615 6655* 6655 sign_differs 3 based bit(1) level 2 dcl 404 set ref 6297* 7104 sign_unknown 13 based bit(1) level 3 in structure "sr_frame" dcl 6014 in procedure "reduce_strength" set ref 6108* 6299 6598* 6598 6607* sign_unknown 4 based bit(1) level 2 in structure "sr_var" dcl 404 in procedure "fort_optimizer" set ref 6299* 7044 size builtin function dcl 470 in procedure "fort_optimizer" ref 741 741 744 744 746 746 1009 1009 1018 1018 1019 1019 1020 1020 1606 1607 1621 1622 1628 1629 1646 1646 1692 1692 1846 1846 1847 1847 1894 1895 1902 1902 1908 1908 1920 1920 2022 2022 2523 2523 2566 2566 2623 2623 2670 2670 2680 2680 2681 2681 2682 2682 2683 2683 2684 2684 2685 2685 2686 2686 2700 2700 2714 2714 2715 2715 2716 2716 2717 2717 2718 2718 2719 2719 2741 2741 2742 2742 2743 2743 2744 2744 2842 2843 3401 3402 3417 3417 4361 4361 4361 4364 4365 4365 4390 4390 4390 4393 4394 4394 4640 4641 4743 4743 4896 4896 5007 5008 5020 5021 5050 5051 5063 5063 5063 5066 5067 5067 5118 5118 5118 5121 5122 5122 6478 6479 6484 6485 6495 6496 6720 6720 6760 6760 6764 6764 6807 6807 7288 7288 7288 7291 7292 7292 7383 7384 7401 7401 8028 8029 8075 8076 8402 8403 8413 8414 8611 8611 8682 8683 8698 8699 7-34 7-34 7-34 7-37 7-38 7-38 7-94 7-94 size 7 based fixed bin(24,0) level 2 in structure "temporary" dcl 2-1005 in procedure "fort_optimizer" set ref 7417* size builtin function dcl 8-33 in procedure "create_constant" ref 8-74 8-74 size 000220 stack reference condition dcl 5479 in procedure "constant_expression" ref 5520 son 5 based pointer level 2 packed packed unaligned dcl 1-100 set ref 1946 2481 2712* 2736* 3113 6938 6943 6948 6948 7172 7177 7189 7189 7456 7458 7464 7464 7711 7720 source 001066 automatic pointer dcl 1584 in procedure "connect_jump_assigneds" set ref 1590* 1592 1598* source 000130 automatic bit(72) array packed unaligned dcl 5467 in procedure "constant_expression" set ref 5508* 5630* 5630* 5632* 5632* 5634* 5634* 5637* 5641* 5641* 5650* 5657 5676 5778 5778 source_as_int based structure array level 1 unaligned dcl 5469 source_id 3 based structure level 2 packed packed unaligned dcl 1-176 set ref 2603* 2603 5181 5181 5266 5266 5269* 5269 sr_cand based structure level 1 dcl 398 set ref 4361 4361 4361 4364 4365 4365 6478 6479 sr_chain 001564 automatic pointer dcl 2772 set ref 2789* 3096* 3223 3359* 4373* 6045 6462 6467 6479 6499* sr_frame based structure level 1 dcl 6014 set ref 6720 6720 sr_tail 001566 automatic pointer dcl 2772 set ref 2789* 3096* 3224 3360* 4373 4375 4377* 6478 6499* sr_var based structure level 1 dcl 404 set ref 6807 6807 src 002316 automatic pointer dcl 4359 in procedure "chain_sr_cand" set ref 4361* 4364* 4368 4369 4370 4371 4373 4375 4377 src 003540 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6045* 6045* 6046 6047 6052 6422* 6425 6467* 6467* 6468 6470 6471* 6476 srp 003534 automatic pointer dcl 6003 set ref 6046* 6050 6055 6124* 6471* 6474* srvp 003746 automatic pointer dcl 6739 in procedure "create_var" set ref 6746* 6746* 6747 6749 6751 6752 6754* 6755 6759* 6760 6765 6798 srvp 003756 automatic pointer dcl 6805 in procedure "create_sr_var_node" set ref 6807* 6810* 6814 srvp 004114 automatic pointer dcl 7032 in procedure "change_test" set ref 7041* 7050* 7056* 7060 7086 7087 7102 7104 7110 srvp 004004 automatic pointer dcl 6846 in procedure "add_new_induction_var" set ref 6862* 6863 srvp 003570 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6158* 6160 6291 6292 6296 6297 6299 6300 6307 6309 6310 6310 6315 6316 6317 6447* 6447* 6448 6449 6450 6450 6453 6454 6455* srvp 003706 automatic pointer dcl 6673 in procedure "search_for_equivalent" set ref 6678 6678* 6678* 6680 6685 6688 6692 6701* 6704 srvp 001624 automatic pointer dcl 2781 in procedure "optimize_subprogram" set ref 2854* 2854* 2855 2857 2860 2861 2862* st 001316 automatic pointer dcl 2277 in procedure "detach_flow_units" set ref 2286* 2294 2296 2301 2301 2307 st 000606 automatic pointer dcl 783 in procedure "build_flow_units" set ref 808* 809 811 811 811 817 823 929 987 1052* 1053 1054 1058 1429 1429 1447 st 001070 automatic pointer dcl 1584 in procedure "connect_jump_assigneds" set ref 1592* 1593* 1593 1594 st_found 004102 automatic fixed bin(18,0) dcl 6984 set ref 6994* 7005 st_list 003210 automatic pointer dcl 4889 in procedure "union" set ref 4902* 4905* 4910 4914* 4921* 4927 st_list 003236 automatic pointer dcl 4942 in procedure "trim_operator_list" set ref 4948* 4950 4952* 4956 st_list 003164 automatic pointer dcl 4802 in procedure "intersection" set ref 4818* 4837 4854* 4874 standard_bits 0(25) based structure level 4 in structure "symbol" packed packed unaligned dcl 2-844 in procedure "fort_optimizer" standard_bits 0(25) based structure level 3 in structure "node" packed packed unaligned dcl 2-63 in procedure "fort_optimizer" standard_bits 0(25) based structure level 4 in structure "label" packed packed unaligned dcl 2-530 in procedure "fort_optimizer" star_extents 11(09) based bit(1) level 3 packed packed unaligned dcl 2-844 ref 8241 start_inp 000114 automatic pointer dcl 5455 set ref 5667* 5669 5690* 5692* 5696 start_input_to 10 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-1005 set ref 3984 4038 4070 4319 4319 4609 4609 5667 5690 6154 6162* 6355 6382 6587 7606 7606 8545 7-79* 7-249 7-273* 7-275* starting_value 004756 automatic fixed bin(35,0) dcl 8269 in procedure "calculate_range_for_counter" set ref 8287* 8294 8297 8388 starting_value parameter fixed bin(35,0) dcl 8432 in procedure "get_starting_value" set ref 8429 8482* stat_op constant fixed bin(18,0) initial dcl 3-197 ref 2572 7359 8161 8337 8525 state 003156 automatic pointer dcl 4802 set ref 4806* 4809 4815 4818 4820 4874 state_discarded 000412 automatic bit(1) dcl 274 set ref 797* 855* 874* 889* 902* 1439 1444* 2880* 2903* 2905 2905* 2920* 2929* 3029* 3031 3031* 3053* 3062* 3092* 3354* 3466 3498 3502 3511* 3818* 3823* 3830* 3839* statement 5 based fixed bin(18,0) level 2 in structure "label" packed packed unsigned unaligned dcl 2-530 in procedure "fort_optimizer" set ref 858 1496 1525 1559 2527* 4723 5287* 8557 statement 2 based pointer level 2 in structure "incr" packed packed unaligned dcl 418 in procedure "fort_optimizer" set ref 4398* 6245 6863 statement 3 based pointer level 2 in structure "sr_cand" packed packed unaligned dcl 398 in procedure "fort_optimizer" set ref 4370* 6052 6470 static 11(01) based bit(1) level 4 packed packed unaligned dcl 2-844 set ref 714 720* stm 003206 automatic pointer dcl 4889 in procedure "union" set ref 4892* 4893 4900 4910 4914 4927 4930 stm 003564 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6052* 6053 6090* 6470* 6472 6564* 6864* stm 005044 automatic pointer dcl 8501 in procedure "is_suitable_loop_exit" set ref 8557* 8558 stm 003120 automatic pointer dcl 4720 in procedure "process_jump_label" set ref 4723* 4731* 4733 4736 4736 4736* 4787 4789 stm parameter pointer dcl 4940 in procedure "trim_operator_list" ref 4934 4945 4948 4956 stm parameter pointer dcl 4386 in procedure "chain_incr" ref 4381 4398 stm 003360 automatic pointer dcl 5168 in procedure "move" set ref 5177* 5181 5181* stm parameter pointer dcl 4355 in procedure "chain_sr_cand" ref 4350 4370 stm 001762 automatic pointer dcl 3295 in procedure "pop_loop" set ref 3374* 3375 3376 3386 stm parameter pointer dcl 7621 in procedure "free_statement" set ref 7618 7626 7628 7631 7632 7634* stm parameter pointer dcl 5255 in procedure "insert_stm_in_back_target" ref 5252 5266 5269 5271 stm 004364 automatic pointer dcl 7541 in procedure "remove_units_from_loop" set ref 7552* 7553 7555 7561 7562 7563 7563* stm 004174 automatic pointer dcl 7208 in procedure "process_flow_units" set ref 7228* 7229 7231 stm 004474 automatic pointer dcl 7681 in procedure "analyze_loop_index_values" set ref 7735* 7736 7738 stm 002034 automatic pointer dcl 3446 in procedure "optimize_flow_unit" set ref 3459* 3463 3468* 3469* 3472 3472 3498* 3504* 3505* 3508* 3538* 3539 3541 3730* 4111* 4145* 4147* 4250* stm 001610 automatic pointer dcl 2780 in procedure "optimize_subprogram" set ref 2957* 2958 2960 2965 2969 2973 stmnt parameter fixed bin(18,0) dcl 4729 ref 4726 4731 stmnt_func 10(33) based bit(1) level 4 packed packed unaligned dcl 2-844 ref 708 storage based fixed bin(17,0) array dcl 9-15 set ref 9-24* storage_add_one_op constant fixed bin(18,0) initial dcl 3-197 ref 4179 6113 6259 storage_add_op constant fixed bin(18,0) initial dcl 3-197 ref 4183 6262 storage_class 11 based structure level 3 packed packed unaligned dcl 2-844 storage_info 0(25) based structure level 3 in structure "label" packed packed unaligned dcl 2-530 in procedure "fort_optimizer" storage_info 0(25) based structure level 3 in structure "symbol" packed packed unaligned dcl 2-844 in procedure "fort_optimizer" storage_sub_op constant fixed bin(18,0) initial dcl 3-197 ref 4191 4217 string builtin function dcl 470 set ref 8008* 8010 8013* 8013 8013 8015 8062* 8064* 8064 8064 8093* 8099 8100* 8104* 8113 8113* 8116 8208* 8214 8282* 8425 8596* 8665* 8665 sub_index_op constant fixed bin(18,0) initial dcl 3-197 ref 5774 6349 sub_op constant fixed bin(18,0) initial dcl 3-197 ref 3779 4033 4160 6512 6655 subprogram based structure level 1 dcl 2-753 substr builtin function dcl 470 set ref 750* 760* 763* 768* 769* 1245* 1246 1246* 1266* 1267* 1286* 1287* 1332 1332* 1334* 1351 1351* 1354* 1374 1374* 1377* 1381* 1757* 1782* 1790 1799* 1823 1867* 1874 1874 1880* 1909* 1922* 1983* 2001* 2015* 2057 2057* 2078 2251* 3518 3586 3615 3719 3719 4004* 4004 4004 4004 4092 4094 4141 4141 4144* 4147 4147 4225 4233 4248* 4281 4281 4569 4753* 4765* 4828 4852* 4907* 4918 4920* 5158 5159* 5211 5211* 5213* 5214* 5215* 5216* 5216 5216 5230* 5237* 5404* 5405* 5428 5715 5726 5738 5849 5849 5851 5851 5862 5864 5865 5866 5870 5881 5883 5884 5885 6078 6081 6198* 6200* 6202* 6203* 6204* 6207* 6208 6208* 6211* 6450 6450 6537 6644* 6747 6796* 6831 6868* 6899 6905* 6967* 6970* 6991 7005 7044 7080* 7109* 7110* 7134* 7135* 7136* 7180 7212 7217* 7240* 7253* 7324 7324 7366 7368* 7374* 7375* 7376* 7515 7753* 7889 7895 7912 7924 7952* 8351 8360 8445 8648* succeeded parameter bit(1) dcl 3931 in procedure "common" set ref 3926 3967* 3974* succeeded 002061 automatic bit(1) dcl 3449 in procedure "optimize_flow_unit" set ref 3674* 3675 3687* successors 2 based pointer level 2 packed packed unaligned dcl 1-46 set ref 1659 1660* 1701 1969 1989 2336 2337 2366* 3229 sum builtin function dcl 470 ref 574 575 sym 000566 automatic fixed bin(18,0) dcl 635 in procedure "assign_symbol_coordinates" set ref 655* 655* 656* 675* 675* 676* 703* 703* 704* 753* 753* 754* sym 001074 automatic pointer dcl 1584 in procedure "connect_jump_assigneds" set ref 1595* 1597 1616* 1618 1622 1623 sym 001052 automatic pointer dcl 1557 in procedure "add_to_jump_assigned_target_list" set ref 1562* 1564 1568 1576 1577 symbol based structure level 1 dcl 2-844 in procedure "fort_optimizer" set ref 6764 6764 symbol 2 based pointer level 2 in structure "secondary" packed packed unaligned dcl 392 in procedure "fort_optimizer" set ref 4456 4474 4510 4537 4568 4698* 4998 5046 5047 symbol_node 001123 constant fixed bin(4,0) initial dcl 3-87 set ref 1184 1223 1327 3594 3716 4132 4132 4233 4281 4437 4692 5208 5226 5398 5956 5971 6644 6764* 6831 7080 7889 7924 7952 8351 8360 sys_info$max_seg_size 000020 external static fixed bin(18,0) dcl 8223 ref 8232 8235 t 003216 automatic pointer dcl 4889 in procedure "union" set ref 4921* 4922 t 003124 automatic pointer dcl 4720 in procedure "process_jump_label" set ref 4747* 4751* 4763* 4787 4787 t 003166 automatic pointer dcl 4802 in procedure "intersection" set ref 4863* 4864 4865 t 004302 automatic pointer dcl 7394 in procedure "create_integer_temporary" set ref 7402* 7407* 7408 7409 7410 7415 7416 7417 7418 7419 t 001614 automatic pointer dcl 2780 in procedure "optimize_subprogram" set ref 2965* 2966 2967* 2968 t 000102 automatic pointer dcl 5309 in procedure "free_operator" set ref 5329* 5331 5333 5337 5337* target 000776 automatic pointer dcl 1459 in procedure "link_to_target" set ref 1461* 1463 1466 1468 target 003516 automatic bit(72) dcl 5909 in procedure "constant_assign" set ref 5928* 5947* 5953* 5967* target parameter pointer dcl 1484 in procedure "get_final_target" set ref 1479 1497* 1499 1509 target 002232 automatic fixed bin(18,0) dcl 4124 in procedure "check_increment" set ref 4163* 4165 target 001044 automatic pointer dcl 1557 in procedure "add_to_jump_assigned_target_list" set ref 1560* 1575 target 001022 automatic pointer dcl 1523 in procedure "link_entry_to_target" set ref 1527* 1530* 1531 1534 1537* target_fu 003130 automatic pointer dcl 4720 set ref 4733* 4736 4743 4743 4745 4759 4773 4779 target_lp 003132 automatic pointer dcl 4720 set ref 4773* 4777 target_optr 003144 automatic pointer dcl 4720 set ref 4745* 4753 4765 target_st 001024 automatic pointer dcl 1523 in procedure "link_entry_to_target" set ref 1525* 1527 1527 1531 1535 target_st 001046 automatic pointer dcl 1557 in procedure "add_to_jump_assigned_target_list" set ref 1559* 1560 target_statement 000774 automatic fixed bin(18,0) dcl 1458 in procedure "link_to_target" set ref 1461* 1474 target_statement parameter fixed bin(18,0) dcl 1484 in procedure "get_final_target" set ref 1479 1496* 1497 target_unit 001000 automatic pointer dcl 1459 set ref 1465* 1466 1468* 1470 1472* temp 000106 automatic fixed bin(18,0) dcl 5310 in procedure "free_operator" set ref 5326* 5327 5329 5334 temp 004304 automatic fixed bin(18,0) dcl 7395 in procedure "create_integer_temporary" set ref 7401* 7402 7406* 7407 7421 temp_bits based bit dcl 365 set ref 2022 2022 2422* 2426 2428 2447* 2451 2453 temp_bits_p 000414 automatic pointer dcl 275 set ref 2022* 2022 2022 2422 2426 2428 2447 2451 2453 temp_type constant fixed bin(4,0) initial dcl 3-120 ref 7416 temporary based structure level 1 dcl 2-1005 set ref 7401 7401 7409* temporary_node 000704 constant fixed bin(4,0) initial dcl 3-87 set ref 1206 3149 3240 3321 3623 3646 3661 3707 3758 3796 3855 3914 3964 3978 4042 4087 4130 4174 4238 4343 4609 5244 5331 5385 6280 6534 7077 7124 7401* 7410 7597 7606 7747 7892 7-224 this_fu 2 based pointer level 3 packed packed unaligned dcl 434 set ref 3020 3021 3022* 3097* time_optimizer 11(25) based bit(1) level 4 packed packed unaligned dcl 2-753 ref 542 timing_info 000460 automatic structure level 1 dcl 455 tlabel parameter fixed bin(18,0) dcl 2224 ref 2221 2231 to 3 based structure level 2 dcl 1-33 to_unit parameter pointer dcl 1642 in procedure "link" ref 1637 1652 1654 1655 to_unit 001350 automatic pointer dcl 2353 in procedure "unlink" set ref 2356* 2360 total_pf 000510 automatic fixed bin(18,0) dcl 463 set ref 575* 584* total_vcpu 000511 automatic float bin(27) dcl 464 set ref 574* 581 584 try_to_optimize 001010 automatic bit(1) dcl 1488 set ref 1493* 1495 1511* tuple 10 based structure array level 2 dcl 404 set ref 6310 6678 7060 tx 000512 automatic float bin(27) dcl 465 set ref 580* 581 581 type parameter fixed bin(4,0) dcl 9-14 ref 9-10 9-25 u 004746 automatic pointer dcl 8266 set ref 8376* 8376* 8377* 8379 underflow 000226 stack reference condition dcl 5479 ref 5521 units 2 based fixed bin(3,0) level 2 packed packed unsigned unaligned dcl 2-844 ref 8241 8249 unlikely_to_fault_class constant fixed bin(18,0) initial dcl 276 ref 538 unspec builtin function dcl 9-17 in procedure "create_node" set ref 9-24* unspec builtin function dcl 470 in procedure "fort_optimizer" set ref 499 523 523 526 526 1673* 1674* 2571* 2603* 2603 5181 5181 5266 5266 5269* 5269 5675* 5776 5776 5778 5778 5870* 5947 5953 6610* 6627* 6628* 7409* 7647 7647 update_chain 004764 automatic pointer dcl 8271 set ref 8322* 8360* 8376 8407 8414 update_insert_operator 003627 automatic bit(1) dcl 6012 set ref 6171* 6179 updated_by 5 based pointer level 2 packed packed unaligned dcl 404 set ref 6300* 6863 upper_bound 004676 automatic fixed bin(35,0) dcl 8128 in procedure "calculate_range_by_subscripts" set ref 8140* 8141 8182* 8182 8194* 8194 8202* 8202 8209 8211 upper_bound 004753 automatic fixed bin(35,0) dcl 8268 in procedure "calculate_range_for_counter" set ref 8293* 8297* 8311* 8313 8317 8394* 8394 8418 8420 usage 0(30) based structure level 3 packed packed unaligned dcl 2-530 used 16 based pointer level 2 in structure "flow_unit" packed packed unaligned dcl 1-46 in procedure "fort_optimizer" set ref 1043 1245 1255 1255 1266 1286 1404 1404 2477 2681* 3528 3528 4004 5216 5230 5237 5405 6450 6644 6970 7080 7109 7110 7212 7217 7240 7253 7376 7567 used 20 based pointer level 2 in structure "loop" packed packed unaligned dcl 1-100 in procedure "fort_optimizer" set ref 1036 2477 2477 2486 2486 2486 2741* 2891 2891 3114 3114 3114 3284 3284 5404 6202 6207 6450 6967 7044 7134 7180 7576 used_across_loops 0(33) based bit(1) level 3 in structure "temporary" packed packed unaligned dcl 2-1005 in procedure "fort_optimizer" set ref 3149 3630 3661* 3957* 4300* 5247* 5385 5442* 6566* used_across_loops 002054 automatic bit(1) dcl 3449 in procedure "optimize_flow_unit" set ref 3557* 3579* 3579 3630* 3630 3643* 3643 3785 3793 4300* used_across_loops 0(33) based bit(1) level 3 in structure "array_ref" packed packed unaligned dcl 2-155 in procedure "fort_optimizer" ref 3579 3643 5374 5393 used_in 6 based pointer level 2 packed packed unaligned dcl 404 set ref 2855 6450 6450 6747 6760* used_invariant_symbol 001600 automatic bit(1) dcl 2774 set ref 3557* 3589* 3618* 3785 3793 4288* 5398 6473* useless 001275 automatic fixed bin(18,0) dcl 2243 set ref 2246* useless_ptr 001276 automatic pointer dcl 2244 set ref 2246* v_array based bit(36) array dcl 8-34 set ref 8-51 8-52* 8-54 8-54 v_length 6 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 2-844 ref 5956 value 1 based pointer level 2 in structure "chain" packed packed unaligned dcl 1-27 in procedure "fort_optimizer" set ref 1548* 1568* 1575* 1590 1598 1616 1838* 1851 1998* 2013 2505 3174 3178 3397 3599 4589 4705* 4779* 7481 7967* 7992 8045 8054 8100 8100 8100 8104 8104 8104 8372 8377 8638 value 4(18) based char level 2 in structure "char_constant" packed packed unaligned dcl 2-316 in procedure "fort_optimizer" ref 5943 5950 5960 5960 value based pointer level 3 in structure "edge" packed packed unaligned dcl 1-33 in procedure "fort_optimizer" set ref 1651* 1748 1774 1822 1872 2013 2076 2355 2418 8054 value 4 based bit(72) level 2 in structure "constant" dcl 2-256 in procedure "fort_optimizer" set ref 1673 1674 5508 5675 5714* 5725* 5737* 5749* 5756* 5763* 5770* 5928 6610 6627 6628 7785 8145 8187 8286 8308 8384 8482 8-65 8-85* value 3 based pointer level 3 in structure "edge" packed packed unaligned dcl 1-33 in procedure "fort_optimizer" set ref 1652* 1702 1991 2204 2212* 2356 2505 3174 3178 3229 7481 value 1 based fixed bin(18,0) level 2 in structure "lchain" dcl 1-94 in procedure "fort_optimizer" set ref 2837 4420* 5682* 6389* 7-193* value parameter fixed bin(18,0) dcl 7643 in procedure "create_integer_constant" ref 7640 7645 7647 7647 value 2 based fixed bin(18,0) level 2 in structure "initial" dcl 638 in procedure "assign_symbol_coordinates" ref 722 value 1 based pointer level 2 in structure "incr" packed packed unaligned dcl 418 in procedure "fort_optimizer" set ref 4397* 6063 6895 6987 value parameter bit(72) dcl 8-16 in procedure "create_constant" ref 8-13 8-41 var 004752 automatic fixed bin(18,0) dcl 8267 in procedure "calculate_range_for_counter" set ref 8373* 8377 8383 var 004675 automatic fixed bin(18,0) dcl 8127 in procedure "calculate_range_by_subscripts" set ref 8146* 8175 8185 8198 var 005050 automatic fixed bin(18,0) dcl 8502 in procedure "is_suitable_loop_exit" set ref 8517* 8535 var 005272 automatic fixed bin(18,0) dcl 7-287 in procedure "in_namelist" set ref 7-289* var parameter fixed bin(18,0) dcl 7270 in procedure "chain_dac" ref 7265 7278 var 003740 automatic fixed bin(18,0) dcl 6738 in procedure "create_var" set ref 6764* 6765 6766 6779 6780 var 004650 automatic fixed bin(18,0) dcl 8087 in procedure "try_to_calculate_range" set ref 8097* 8100 8104 var 005003 automatic fixed bin(18,0) dcl 8436 in procedure "get_starting_value" set ref 8447* 8461* 8468 8472 8477 var_chain 3 based pointer level 2 packed packed unaligned dcl 418 set ref 4399* 6291 6292* 6447 6458* 6678 6991 7043 var_p parameter pointer dcl 8495 ref 8492 8517 variable 004263 automatic fixed bin(18,0) dcl 7306 in procedure "remove_dead_assignments" set ref 7318* 7319 7342* 7353 7359 variable 6 based fixed bin(18,0) level 3 in structure "sr_frame" dcl 6014 in procedure "reduce_strength" set ref 6144 6339* 6356* 6585* variable 1 based fixed bin(18,0) level 2 in structure "sr_var" dcl 404 in procedure "fort_optimizer" set ref 2857 6160 6448 6449 6701 6765* 7044 7102 7110 variable 1 based fixed bin(18,0) level 2 in structure "dead_assign_cand" dcl 424 in procedure "fort_optimizer" set ref 7278* 7318 variable 1 based pointer level 2 in structure "range" packed packed unaligned dcl 1-243 in procedure "fort_optimizer" set ref 8589 8612* variable 003615 automatic fixed bin(18,0) dcl 6005 in procedure "reduce_strength" set ref 6151* 6156 6160* 6183 6196 6269 6337* 6339 variable parameter fixed bin(18,0) dcl 7-284 in procedure "in_namelist" ref 7-282 7-289 7-293 variable_extents 0(32) based bit(1) level 3 packed packed unaligned dcl 2-844 ref 8179 8241 8249 variable_type constant fixed bin(4,0) initial dcl 3-120 ref 6770 varp 003576 automatic pointer dcl 6003 in procedure "reduce_strength" set ref 6196* 6197 6302 6304 6305 6307 varp 004254 automatic pointer dcl 7305 in procedure "remove_dead_assignments" set ref 7319* 7320 7321 vcpu 4 000460 automatic fixed bin(18,0) array level 3 in structure "timing_info" dcl 455 in procedure "fort_optimizer" set ref 574 580 612* 619* 619 vcpu 000536 automatic fixed bin(71,0) dcl 602 in procedure "timer" set ref 617* 619 621 which 11 based fixed bin(18,0) array level 3 in structure "sr_var" dcl 404 in procedure "fort_optimizer" set ref 6317* 6688 7087 which 003720 automatic fixed bin(18,0) dcl 6674 in procedure "search_for_equivalent" set ref 6690* 6693 6693 which 003656 automatic fixed bin(18,0) dcl 6547 in procedure "reduce" set ref 6556* 6586 6591 6605 6637* 6638 6655 which 004103 automatic fixed bin(18,0) dcl 6984 in procedure "replace_tests" set ref 7012* 7014* 7016 7074 7101 7102 which 004634 automatic fixed bin(17,0) dcl 7981 in procedure "process_comparison_list" set ref 7996* 8002* 8017 8304 8308 which 2 based fixed bin(17,0) level 2 in structure "input_to" dcl 1-87 in procedure "fort_optimizer" set ref 4416 4416 4418 4615 5671 5673 5680 6136 6384 8546 7-77* which 003613 automatic fixed bin(18,0) dcl 6005 in procedure "reduce_strength" set ref 6047* 6048 6055 6124* 6136* 6138 6138* 6138* which 2 based fixed bin(18,0) level 2 in structure "sr_cand" dcl 398 in procedure "fort_optimizer" set ref 4369* 6047 6422* 6468 which parameter fixed bin(18,0) dcl 6508 in procedure "is_reducible" ref 6503 6512 which 11 based fixed bin(18,0) level 3 in structure "sr_frame" dcl 6014 in procedure "reduce_strength" set ref 6232 6317 6586* 6688 6690 which 005256 automatic fixed bin(18,0) dcl 7-211 in procedure "connect_expression" set ref 7-218* 7-221 7-229* write_namelist_op constant fixed bin(18,0) initial dcl 3-197 ref 7249 7342 x based fixed bin(35,0) array dcl 9-16 in procedure "create_node" set ref 9-24 9-25 x based fixed bin(35,0) array dcl 8-35 in procedure "create_constant" set ref 8-63 8-80 8-91 xop_class 000527 constant fixed bin(17,0) initial array dcl 350 ref 481 7756 xregs_used 31 based fixed bin(4,0) level 2 dcl 1-100 set ref 2732* zero 000416 automatic fixed bin(18,0) dcl 277 set ref 522* 523* 523 523 4033 zero_hash_mask parameter bit(1) dcl 4966 ref 4961 4977 zerodivide 000234 stack reference condition dcl 5479 ref 5522 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. EOS_token internal static bit(9) initial dcl 3-156 algol68_array_descriptor_dtype internal static fixed bin(17,0) initial dcl 6-25 algol68_bits_dtype internal static fixed bin(17,0) initial dcl 6-110 algol68_bool_dtype internal static fixed bin(17,0) initial dcl 6-110 algol68_byte_dtype internal static fixed bin(17,0) initial dcl 6-110 algol68_char_dtype internal static fixed bin(17,0) initial dcl 6-110 algol68_compl_dtype internal static fixed bin(17,0) initial dcl 6-110 algol68_format_dtype internal static fixed bin(17,0) initial dcl 6-25 algol68_int_dtype internal static fixed bin(17,0) initial dcl 6-110 algol68_long_compl_dtype internal static fixed bin(17,0) initial dcl 6-110 algol68_long_int_dtype internal static fixed bin(17,0) initial dcl 6-110 algol68_long_real_dtype internal static fixed bin(17,0) initial dcl 6-110 algol68_real_dtype internal static fixed bin(17,0) initial dcl 6-110 algol68_short_int_dtype internal static fixed bin(17,0) initial dcl 6-110 algol68_straight_dtype internal static fixed bin(17,0) initial dcl 6-25 algol68_struct_struct_bool_dtype internal static fixed bin(17,0) initial dcl 6-110 algol68_struct_struct_char_dtype internal static fixed bin(17,0) initial dcl 6-110 algol68_union_dtype internal static fixed bin(17,0) initial dcl 6-25 and internal static bit(9) initial dcl 3-156 and_op internal static fixed bin(18,0) initial dcl 3-197 apostrophe internal static bit(9) initial dcl 3-156 area_dtype internal static fixed bin(17,0) initial dcl 6-25 arg_desc based structure level 1 dcl 2-130 arg_desc_node internal static fixed bin(4,0) initial dcl 3-87 array_ref_type internal static fixed bin(4,0) initial dcl 3-120 assign internal static bit(9) initial dcl 3-156 assign_label_op internal static fixed bin(18,0) initial dcl 3-197 asterisk internal static bit(9) initial dcl 3-156 backspace_op internal static fixed bin(18,0) initial dcl 3-197 bif internal static fixed bin(4,0) initial dcl 3-120 bit_dtype internal static fixed bin(17,0) initial dcl 6-25 bit_units internal static fixed bin(3,0) initial dcl 3-136 bits_per_char internal static fixed bin(9,0) initial dcl 3-68 blank_common_name internal static char(8) initial dcl 3-79 block_data internal static fixed bin(9,0) initial dcl 3-68 block_data_op internal static fixed bin(18,0) initial dcl 3-197 block_if_op internal static fixed bin(18,0) initial dcl 3-197 builtin_op internal static fixed bin(18,0) initial dcl 3-197 c_enum_const_dtype internal static fixed bin(17,0) initial dcl 6-25 c_enum_dtype internal static fixed bin(17,0) initial dcl 6-25 c_typeref_dtype internal static fixed bin(17,0) initial dcl 6-25 c_union_dtype internal static fixed bin(17,0) initial dcl 6-25 chain_op internal static fixed bin(18,0) initial dcl 3-197 char_constant_length automatic fixed bin(18,0) unsigned dcl 2-378 char_constant_node internal static fixed bin(4,0) initial dcl 3-87 char_string internal static bit(9) initial dcl 3-156 chars_per_dw internal static fixed bin(9,0) initial dcl 3-68 close_op internal static fixed bin(18,0) initial dcl 3-197 closefile_op internal static fixed bin(18,0) initial dcl 3-197 cobol_char_string_dtype internal static fixed bin(17,0) initial dcl 6-25 cobol_comp_5_ts_dtype internal static fixed bin(17,0) initial dcl 6-25 cobol_comp_5_uns_dtype internal static fixed bin(17,0) initial dcl 6-25 cobol_comp_6_dtype internal static fixed bin(17,0) initial dcl 6-25 cobol_comp_7_dtype internal static fixed bin(17,0) initial dcl 6-25 cobol_comp_8_ls_dtype internal static fixed bin(17,0) initial dcl 6-25 cobol_comp_8_uns_dtype internal static fixed bin(17,0) initial dcl 6-25 cobol_display_ls_dtype internal static fixed bin(17,0) initial dcl 6-25 cobol_display_ls_overp_dtype internal static fixed bin(17,0) initial dcl 6-25 cobol_display_ts_dtype internal static fixed bin(17,0) initial dcl 6-25 cobol_display_ts_overp_dtype internal static fixed bin(17,0) initial dcl 6-25 cobol_display_uns_dtype internal static fixed bin(17,0) initial dcl 6-25 cobol_structure_dtype internal static fixed bin(17,0) initial dcl 6-25 colon internal static bit(9) initial dcl 3-156 comma internal static bit(9) initial dcl 3-156 complex_const internal static bit(9) initial dcl 3-156 concat internal static bit(9) initial dcl 3-156 count_type internal static fixed bin(4,0) initial dcl 3-120 cplx_fix_bin_1_dtype internal static fixed bin(17,0) initial dcl 6-25 cplx_fix_bin_2_dtype internal static fixed bin(17,0) initial dcl 6-25 cplx_fix_dec_4bit_bytealigned_ls_dtype internal static fixed bin(17,0) initial dcl 6-25 cplx_fix_dec_9bit_ls_dtype internal static fixed bin(17,0) initial dcl 6-25 cplx_flt_bin_1_dtype internal static fixed bin(17,0) initial dcl 6-25 cplx_flt_bin_2_dtype internal static fixed bin(17,0) initial dcl 6-25 cplx_flt_bin_generic_dtype internal static fixed bin(17,0) initial dcl 6-25 cplx_flt_dec_4bit_bytealigned_dtype internal static fixed bin(17,0) initial dcl 6-25 cplx_flt_dec_9bit_dtype internal static fixed bin(17,0) initial dcl 6-25 cplx_flt_dec_extended_dtype internal static fixed bin(17,0) initial dcl 6-25 cplx_flt_dec_generic_dtype internal static fixed bin(17,0) initial dcl 6-25 cplx_flt_hex_1_dtype internal static fixed bin(17,0) initial dcl 6-25 cplx_flt_hex_2_dtype internal static fixed bin(17,0) initial dcl 6-25 dec_int internal static bit(9) initial dcl 3-156 decode_string_op internal static fixed bin(18,0) initial dcl 3-197 default_main_entry_point_name internal static char(5) initial packed unaligned dcl 3-80 dfast_mask internal static bit(72) initial packed unaligned dcl 5-162 dimension_node internal static fixed bin(4,0) initial dcl 3-87 div_op internal static fixed bin(18,0) initial dcl 3-197 do_op internal static fixed bin(18,0) initial dcl 3-197 double_const internal static bit(9) initial dcl 3-156 dummy internal static fixed bin(4,0) initial dcl 3-120 else_if_op internal static fixed bin(18,0) initial dcl 3-197 else_op internal static fixed bin(18,0) initial dcl 3-197 encode_string_op internal static fixed bin(18,0) initial dcl 3-197 end_label_op internal static fixed bin(18,0) initial dcl 3-197 endfile_op internal static fixed bin(18,0) initial dcl 3-197 endunit_op internal static fixed bin(18,0) initial dcl 3-197 entry_dtype internal static fixed bin(17,0) initial dcl 6-25 entry_type internal static fixed bin(4,0) initial dcl 3-120 eol_op internal static fixed bin(18,0) initial dcl 3-197 eq internal static bit(9) initial dcl 3-156 equal_op internal static fixed bin(18,0) initial dcl 3-197 equiv_op internal static fixed bin(18,0) initial dcl 3-197 eqv internal static bit(9) initial dcl 3-156 error internal static fixed bin(4,0) initial dcl 3-120 error_label_op internal static fixed bin(18,0) initial dcl 3-197 exit_op internal static fixed bin(18,0) initial dcl 3-197 expon internal static bit(9) initial dcl 3-156 exponentiation_op internal static fixed bin(18,0) initial dcl 3-197 ext_entry_runtime_dtype internal static fixed bin(17,0) initial dcl 6-125 ext_procedure_runtime_dtype internal static fixed bin(17,0) initial dcl 6-125 external internal static fixed bin(4,0) initial dcl 3-120 false internal static bit(9) initial dcl 3-156 fast_mask internal static bit(72) initial packed unaligned dcl 5-168 file_dtype internal static fixed bin(17,0) initial dcl 6-25 fill_node internal static fixed bin(4,0) initial dcl 3-87 first_auto_loc internal static fixed bin(9,0) initial dcl 3-68 first_block_constant defined fixed bin(18,0) dcl 4-153 first_char_constant defined fixed bin(18,0) dcl 4-149 first_dw_constant defined fixed bin(18,0) dcl 4-145 first_word_constant defined fixed bin(18,0) dcl 4-141 form_VLA_packed_ptr_op internal static fixed bin(18,0) initial dcl 3-197 format_op internal static fixed bin(18,0) initial dcl 3-197 ft_char_dtype internal static fixed bin(17,0) initial dcl 6-96 ft_complex_double_dtype internal static fixed bin(17,0) initial dcl 6-96 ft_complex_dtype internal static fixed bin(17,0) initial dcl 6-96 ft_double_dtype internal static fixed bin(17,0) initial dcl 6-96 ft_external_dtype internal static fixed bin(17,0) initial dcl 6-96 ft_hex_complex_double_dtype internal static fixed bin(17,0) initial dcl 6-96 ft_hex_complex_dtype internal static fixed bin(17,0) initial dcl 6-96 ft_hex_double_dtype internal static fixed bin(17,0) initial dcl 6-96 ft_hex_real_dtype internal static fixed bin(17,0) initial dcl 6-96 ft_integer_dtype internal static fixed bin(17,0) initial dcl 6-96 ft_logical_dtype internal static fixed bin(17,0) initial dcl 6-96 ft_real_dtype internal static fixed bin(17,0) initial dcl 6-96 func_op internal static fixed bin(18,0) initial dcl 3-197 function internal static fixed bin(9,0) initial dcl 3-68 gap_value internal static fixed bin(17,0) initial dcl 3-57 ge internal static bit(9) initial dcl 3-156 greater_or_equal_op internal static fixed bin(18,0) initial dcl 3-197 gt internal static bit(9) initial dcl 3-156 halfword_units internal static fixed bin(3,0) initial dcl 3-136 header_node internal static fixed bin(4,0) initial dcl 3-87 ident internal static bit(9) initial dcl 3-156 imag builtin function dcl 5831 increment_polish_op internal static fixed bin(18,0) initial dcl 3-197 inquire_op internal static fixed bin(18,0) initial dcl 3-197 int_entry_runtime_dtype internal static fixed bin(17,0) initial dcl 6-125 iostat_op internal static fixed bin(18,0) initial dcl 3-197 is_arith_constant internal static bit(9) initial dcl 3-147 is_constant internal static bit(9) initial dcl 3-147 is_operand internal static bit(9) initial dcl 3-147 is_operator internal static bit(9) initial dcl 3-147 item_op internal static fixed bin(18,0) initial dcl 3-197 jump_assigned_op internal static fixed bin(18,0) initial dcl 3-197 jump_logical_op internal static fixed bin(18,0) initial dcl 3-197 label_const internal static bit(9) initial dcl 3-156 label_constant_runtime_dtype internal static fixed bin(17,0) initial dcl 6-125 label_dtype internal static fixed bin(17,0) initial dcl 6-25 label_op internal static fixed bin(18,0) initial dcl 3-197 last_block_constant defined fixed bin(18,0) dcl 4-154 last_char_constant defined fixed bin(18,0) dcl 4-150 last_dw_constant defined fixed bin(18,0) dcl 4-146 last_word_constant defined fixed bin(18,0) dcl 4-142 le internal static bit(9) initial dcl 3-156 left_parn internal static bit(9) initial dcl 3-156 left_shift_op internal static fixed bin(18,0) initial dcl 3-197 less_or_equal_op internal static fixed bin(18,0) initial dcl 3-197 lhs_fld_op internal static fixed bin(18,0) initial dcl 3-197 library based structure level 1 dcl 2-605 library_node internal static fixed bin(4,0) initial dcl 3-87 load_preg_op internal static fixed bin(18,0) initial dcl 3-197 load_xreg_op internal static fixed bin(18,0) initial dcl 3-197 logical_const internal static bit(9) initial dcl 3-156 logical_mode internal static fixed bin(4,0) initial dcl 3-106 lt internal static bit(9) initial dcl 3-156 machine_state based structure level 1 dcl 2-620 machine_state_node internal static fixed bin(4,0) initial dcl 3-87 main_op internal static fixed bin(18,0) initial dcl 3-197 main_program internal static fixed bin(9,0) initial dcl 3-68 margin_op internal static fixed bin(18,0) initial dcl 3-197 max_error_level internal static fixed bin(17,0) initial dcl 3-64 max_fixed_bin_18 internal static fixed bin(18,0) initial dcl 3-58 max_num_of_rands internal static fixed bin(17,0) initial dcl 3-60 max_prec_single internal static fixed bin(9,0) initial dcl 3-68 minus internal static bit(9) initial dcl 3-156 namelist_op internal static fixed bin(18,0) initial dcl 3-197 ne internal static bit(9) initial dcl 3-156 neqv internal static bit(9) initial dcl 3-156 no_token internal static bit(9) initial dcl 3-156 not internal static bit(9) initial dcl 3-156 not_equal_op internal static fixed bin(18,0) initial dcl 3-197 not_equiv_op internal static fixed bin(18,0) initial dcl 3-197 not_op internal static fixed bin(18,0) initial dcl 3-197 num_args automatic fixed bin(17,0) dcl 2-150 num_dims automatic fixed bin(3,0) dcl 2-431 num_of_block_constants defined fixed bin(17,0) dcl 4-152 num_of_char_constants defined fixed bin(17,0) dcl 4-148 num_of_dw_constants defined fixed bin(17,0) dcl 4-144 num_of_word_constants defined fixed bin(17,0) dcl 4-140 octal_const internal static bit(9) initial dcl 3-156 offset_dtype internal static fixed bin(17,0) initial dcl 6-25 open_op internal static fixed bin(18,0) initial dcl 3-197 openfile_op internal static fixed bin(18,0) initial dcl 3-197 or internal static bit(9) initial dcl 3-156 or_op internal static fixed bin(18,0) initial dcl 3-197 pascal_boolean_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_char_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_entry_formal_parameter_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_enumerated_type_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_enumerated_type_element_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_enumerated_type_instance_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_exportable_procedure_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_imported_procedure_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_integer_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_internal_procedure_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_label_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_parameter_procedure_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_procedure_type_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_real_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_record_file_type_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_record_type_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_set_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_string_type_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_text_file_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_typed_pointer_type_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_user_defined_type_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_user_defined_type_instance_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_value_formal_parameter_dtype internal static fixed bin(17,0) initial dcl 6-132 pascal_variable_formal_parameter_dtype internal static fixed bin(17,0) initial dcl 6-132 pause_op internal static fixed bin(18,0) initial dcl 3-197 picture_runtime_dtype internal static fixed bin(17,0) initial dcl 6-125 plus internal static bit(9) initial dcl 3-156 pointer based structure level 1 dcl 2-672 pointer_dtype internal static fixed bin(17,0) initial dcl 6-25 pointer_node internal static fixed bin(4,0) initial dcl 3-87 proc_frame_node internal static fixed bin(4,0) initial dcl 3-87 process_param_list_op internal static fixed bin(18,0) initial dcl 3-197 rc_a internal static bit(6) initial packed unaligned dcl 10-6 rc_dp internal static bit(6) initial packed unaligned dcl 10-6 rc_e internal static bit(6) initial packed unaligned dcl 10-6 rc_is15 internal static bit(6) initial packed unaligned dcl 10-6 rc_is18 internal static bit(6) initial packed unaligned dcl 10-6 rc_lb internal static bit(6) initial packed unaligned dcl 10-6 rc_lp15 internal static bit(6) initial packed unaligned dcl 10-6 rc_lp18 internal static bit(6) initial packed unaligned dcl 10-6 rc_nlb internal static bit(6) initial packed unaligned dcl 10-6 rc_nlp18 internal static bit(6) initial packed unaligned dcl 10-6 rc_ns internal static bit(6) initial packed unaligned dcl 10-6 rc_nt internal static bit(6) initial packed unaligned dcl 10-6 rc_s internal static bit(6) initial packed unaligned dcl 10-6 rc_sr internal static bit(6) initial packed unaligned dcl 10-6 read_array_op internal static fixed bin(18,0) initial dcl 3-197 read_internal_file_op internal static fixed bin(18,0) initial dcl 3-197 read_op internal static fixed bin(18,0) initial dcl 3-197 read_scalar_op internal static fixed bin(18,0) initial dcl 3-197 read_vector_op internal static fixed bin(18,0) initial dcl 3-197 real builtin function dcl 5831 real_const internal static bit(9) initial dcl 3-156 real_fix_bin_1_dtype internal static fixed bin(17,0) initial dcl 6-25 real_fix_bin_1_uns_dtype internal static fixed bin(17,0) initial dcl 6-25 real_fix_bin_2_dtype internal static fixed bin(17,0) initial dcl 6-25 real_fix_bin_2_uns_dtype internal static fixed bin(17,0) initial dcl 6-25 real_fix_dec_4bit_bytealigned_ls_dtype internal static fixed bin(17,0) initial dcl 6-25 real_fix_dec_4bit_bytealigned_uns_dtype internal static fixed bin(17,0) initial dcl 6-25 real_fix_dec_4bit_ls_dtype internal static fixed bin(17,0) initial dcl 6-25 real_fix_dec_4bit_ts_dtype internal static fixed bin(17,0) initial dcl 6-25 real_fix_dec_4bit_uns_dtype internal static fixed bin(17,0) initial dcl 6-25 real_fix_dec_9bit_ls_dtype internal static fixed bin(17,0) initial dcl 6-25 real_fix_dec_9bit_ls_overp_dtype internal static fixed bin(17,0) initial dcl 6-25 real_fix_dec_9bit_ts_dtype internal static fixed bin(17,0) initial dcl 6-25 real_fix_dec_9bit_ts_overp_dtype internal static fixed bin(17,0) initial dcl 6-25 real_fix_dec_9bit_uns_dtype internal static fixed bin(17,0) initial dcl 6-25 real_flt_bin_generic_dtype internal static fixed bin(17,0) initial dcl 6-25 real_flt_dec_4bit_bytealigned_dtype internal static fixed bin(17,0) initial dcl 6-25 real_flt_dec_4bit_dtype internal static fixed bin(17,0) initial dcl 6-25 real_flt_dec_9bit_dtype internal static fixed bin(17,0) initial dcl 6-25 real_flt_dec_extended_dtype internal static fixed bin(17,0) initial dcl 6-25 real_flt_dec_generic_dtype internal static fixed bin(17,0) initial dcl 6-25 record_number_op internal static fixed bin(18,0) initial dcl 3-197 return_op internal static fixed bin(18,0) initial dcl 3-197 rewind_op internal static fixed bin(18,0) initial dcl 3-197 right_parn internal static bit(9) initial dcl 3-156 right_shift_op internal static fixed bin(18,0) initial dcl 3-197 round builtin function dcl 470 sf_def_op internal static fixed bin(18,0) initial dcl 3-197 sf_op internal static fixed bin(18,0) initial dcl 3-197 slash internal static bit(9) initial dcl 3-156 source based structure level 1 dcl 2-693 source_node internal static fixed bin(4,0) initial dcl 3-87 statement based structure level 1 dcl 2-721 statement_function internal static fixed bin(4,0) initial dcl 3-120 stop_op internal static fixed bin(18,0) initial dcl 3-197 store_zero_op internal static fixed bin(18,0) initial dcl 3-197 string_length_op internal static fixed bin(18,0) initial dcl 3-197 string_op internal static fixed bin(18,0) initial dcl 3-197 structure_dtype internal static fixed bin(17,0) initial dcl 6-25 subprogram_node internal static fixed bin(4,0) initial dcl 3-87 subr_op internal static fixed bin(18,0) initial dcl 3-197 subroutine internal static fixed bin(9,0) initial dcl 3-68 subscript_op internal static fixed bin(18,0) initial dcl 3-197 substr_left_parn internal static bit(9) initial dcl 3-156 substr_op internal static fixed bin(18,0) initial dcl 3-197 sys_info$max_seg_size external static fixed bin(18,0) dcl 3-61 terminate_op internal static fixed bin(18,0) initial dcl 3-197 true internal static bit(9) initial dcl 3-156 typeless_mode internal static fixed bin(4,0) initial dcl 3-106 units_per_word internal static fixed bin(6,0) initial array dcl 3-142 unnamed_block_data_subprg_name internal static char(29) initial packed unaligned dcl 3-82 unrecoverable_error internal static fixed bin(17,0) initial dcl 3-64 varying_bit_dtype internal static fixed bin(17,0) initial dcl 6-25 varying_char_dtype internal static fixed bin(17,0) initial dcl 6-25 word_units internal static fixed bin(3,0) initial dcl 3-136 write_array_op internal static fixed bin(18,0) initial dcl 3-197 write_internal_file_op internal static fixed bin(18,0) initial dcl 3-197 write_op internal static fixed bin(18,0) initial dcl 3-197 write_scalar_op internal static fixed bin(18,0) initial dcl 3-197 write_vector_op internal static fixed bin(18,0) initial dcl 3-197 xmit_array_op internal static fixed bin(18,0) initial dcl 3-197 xmit_scalar_op internal static fixed bin(18,0) initial dcl 3-197 xmit_vector_op internal static fixed bin(18,0) initial dcl 3-197 NAMES DECLARED BY EXPLICIT CONTEXT. action 000000 constant label array(0:22) dcl 828 ref 826 add_new_induction_var 030367 constant entry internal dcl 6841 ref 6342 add_to_jump_assigned_list 005535 constant entry internal dcl 1541 ref 888 add_to_jump_assigned_target_list 005547 constant entry internal dcl 1554 ref 925 analyze_data_flow 010524 constant entry internal dcl 2372 ref 1149 2026 analyze_loop_index_values 033174 constant entry internal dcl 7675 ref 7670 arithmetic_error_detected 023636 constant label dcl 5711 ref 5786 5790 5794 5798 5802 5806 assign_symbol_coordinates 002260 constant entry internal dcl 629 ref 546 build_flow_units 003027 constant entry internal dcl 777 ref 550 calculate_range_by_subscripts 034725 constant entry internal dcl 8120 ref 8093 8100 8104 calculate_range_for_counter 035350 constant entry internal dcl 8259 ref 8113 case 000326 constant label array(8) dcl 7758 in procedure "analyze_loop_index_values" ref 7756 case 000106 constant label array(108) dcl 5530 in procedure "constant_expression" ref 5528 case 000104 constant label array(2:3) dcl 4852 in procedure "intersection" ref 4850 case 000056 constant label array(22) dcl 3803 in procedure "optimize_flow_unit" ref 3801 case_end 034034 constant label dcl 7858 ref 7765 7801 7818 7828 7844 7852 7856 chain_dac 031673 constant entry internal dcl 7265 ref 3768 chain_incr 017330 constant entry internal dcl 4381 ref 4145 4147 4250 6863 6864 chain_input 037123 constant entry internal dcl 7-62 ref 1206 1211 1321 4212 6187 7-203 7-229 chain_it 034303 constant entry internal dcl 7958 ref 7777 7812 7823 7838 7912 8017 8351 8360 chain_sr_cand 017264 constant entry internal dcl 4350 ref 4111 6245 change_constant 025605 constant label dcl 5967 ref 5941 5948 5954 change_cur_unit 005304 constant entry internal dcl 1420 ref 817 931 change_test 031007 constant entry internal dcl 7027 ref 7018 check_busy_on_exit 034150 constant entry internal dcl 7903 ref 7778 7791 7798 7839 check_increment 016417 constant entry internal dcl 4117 ref 3782 3803 check_str_reducibility 016235 constant entry internal dcl 4058 ref 3779 clear 021324 constant entry internal dcl 4961 ref 2910 2939 2994 3076 3816 4811 common 015705 constant entry internal dcl 3926 ref 3674 3687 compare_expression 015575 constant entry internal dcl 3879 ref 3672 3685 compute_busy_on_exit 010531 constant entry internal dcl 2385 ref 2379 connect_expression 037462 constant entry internal dcl 7-209 ref 6238 6239 6273 6637 6638 7095 7096 7101 connect_jump_assigneds 005625 constant entry internal dcl 1581 ref 997 consolidate_subprogram 012474 constant entry internal dcl 2943 ref 2796 constant_assign 025434 constant entry internal dcl 5893 ref 3653 constant_expression 022756 constant entry internal dcl 5448 ref 3695 conv 000262 constant label array(36) dcl 5928 ref 5926 create_chain 037000 constant entry internal dcl 7-28 ref 1546 1566 1573 1835 1997 4704 4778 7966 7-191 create_constant 040051 constant entry internal dcl 8-13 ref 523 526 5687 5967 7647 create_da_node 031712 constant entry internal dcl 7283 ref 7275 create_flow_unit 011501 constant entry internal dcl 2661 ref 800 803 1431 1465 1530 2158 create_input_to 037164 constant entry internal dcl 7-90 ref 660 7-73 create_integer_constant 033111 constant entry internal dcl 7640 ref 1675 5657 5676 6613 6629 7785 create_integer_temporary 032171 constant entry internal dcl 7389 ref 6242 6634 7098 create_label 011162 constant entry internal dcl 2513 ref 2186 7529 create_loop 011633 constant entry internal dcl 2693 ref 799 1856 create_lp_frame 014105 constant entry internal dcl 3408 ref 3009 3276 create_new_back_target 007410 constant entry internal dcl 2030 ref 1969 create_node 037725 constant entry internal dcl 9-10 ref 2523 6764 7401 8-74 create_o_node 021541 constant entry internal dcl 5057 ref 3202 3213 4697 4751 4763 4905 4921 create_primary 021652 constant entry internal dcl 5110 ref 3325 3344 3734 3752 4309 4863 create_range 036506 constant entry internal dcl 8603 ref 8595 8664 create_sr_frame 030037 constant entry internal dcl 6710 ref 6102 6582 create_sr_var_node 030302 constant entry internal dcl 6802 ref 6759 create_var 030063 constant entry internal dcl 6731 ref 6158 decrement_input_ref_counts 017220 constant entry internal dcl 4328 ref 4013 6332 6375 6411 derive_insert_for_bt 037312 constant entry internal dcl 7-130 ref 2885 3264 7330 8059 8452 detach_flow_unit 010421 constant entry internal dcl 2320 ref 2312 7573 detach_flow_units 010266 constant entry internal dcl 2272 ref 1717 detach_secondaries 021373 constant entry internal dcl 4984 ref 3258 4980 disconnect_temporary 037524 constant entry internal dcl 7-236 ref 4205 5337 7077 7124 disqualify 034256 constant entry internal dcl 7945 ref 7761 7772 7781 7810 7826 7833 7849 7939 8015 8022 8068 disqualify_inputs 034230 constant entry internal dcl 7932 ref 7854 done 023611 constant label dcl 5694 ref 5685 eligible 034177 constant entry internal dcl 7917 ref 7775 7783 7795 7812 7823 7833 7836 7997 8003 8047 8642 8645 eliminate_increment 031306 constant entry internal dcl 7114 ref 6996 7019 end_case 021057 constant label dcl 4869 ref 4855 error_condition_detected 024550 constant label dcl 5784 ref 5517 fail 015702 constant label dcl 3921 ref 3894 3897 3900 3904 3912 3914 find_new_induction_vars_on_ass_chain 030447 constant entry internal dcl 6872 ref 6040 find_range 036440 constant entry internal dcl 8574 ref 8012 8049 8657 8660 finish 027061 constant label dcl 6433 finish_loop 013030 constant entry internal dcl 3102 ref 2937 3073 fixedoverflow_condition_detected 024554 constant label dcl 5788 ref 5518 flow_analysis 006110 constant entry internal dcl 1680 ref 554 force_loop 030630 constant entry internal dcl 6962 ref 6936 6946 force_used_in_loop 030556 constant entry internal dcl 6922 ref 6858 fort_optimizer 001350 constant entry external dcl 20 free_operator 022431 constant entry internal dcl 5301 ref 4015 4049 4201 4320 5700 6333 6357 6412 7504 7610 free_secondary 017762 constant entry internal dcl 4548 ref 4457 4475 4511 4538 4569 free_statement 033055 constant entry internal dcl 7618 ref 7563 free_them 020040 constant entry internal dcl 4576 ref 4444 4555 6304 get_final_target 005417 constant entry internal dcl 1479 ref 1461 get_flow_unit_label 032504 constant entry internal dcl 7520 ref 7492 7502 get_max_size 035243 constant entry internal dcl 8218 ref 8192 8388 get_opt_space 036746 constant entry internal dcl 7-5 ref 741 744 746 1009 1018 1019 1020 1646 1692 1846 1847 1902 1908 1920 2022 2670 2680 2681 2682 2683 2684 2685 2686 2700 2714 2715 2716 2717 2718 2719 2741 2742 2743 2744 3417 4361 4390 4743 4896 5063 5118 6720 6760 6807 7288 8611 7-34 get_polish_space 037207 constant entry internal dcl 7-106 ref 7-94 get_quad_space 037025 constant entry internal dcl 7-44 ref 2566 2623 get_starting_value 036077 constant entry internal dcl 8429 ref 8287 hash 021707 constant entry internal dcl 5135 ref 3324 3343 3666 4308 4862 have_identity 016117 constant entry internal dcl 4019 ref 3573 3605 ignore_this_procedure 025440 constant label dcl 5916 in_namelist 037664 constant entry internal dcl 7-282 ref 7249 7342 8461 index_value_analysis 033150 constant entry internal dcl 7651 ref 562 insert_flow_unit_before 007745 constant entry internal dcl 2146 ref 2047 2246 insert_operator_after 011377 constant entry internal dcl 2610 ref 2230 2833 6094 6175 6234 6265 6632 7089 7490 insert_statement_after 011260 constant entry internal dcl 2552 ref 2133 2179 2229 2823 5263 insert_stm_in_back_target 022266 constant entry internal dcl 5252 ref 3268 5181 6090 intersection 020675 constant entry internal dcl 4794 ref 3468 3469 3498 3504 3505 4736 invariant 034067 constant entry internal dcl 7879 ref 7772 7808 7812 7823 is_invariant 027325 constant entry internal dcl 6519 ref 6512 7016 is_reducible 027273 constant entry internal dcl 6503 ref 6138 is_suitable_loop_exit 036246 constant entry internal dcl 8492 ref 8304 join 015552 constant label dcl 3855 in procedure "optimize_flow_unit" ref 3806 3814 3819 3824 3831 3837 3842 3846 3853 join 020451 constant label dcl 4733 in procedure "process_jump_label" set ref 4724 join 023554 constant label dcl 5687 in procedure "constant_expression" ref 5635 5639 5648 5655 link 006011 constant entry internal dcl 1637 ref 844 901 1442 1472 1537 1598 2142 2266 7507 link_entry_to_target 005502 constant entry internal dcl 1518 ref 908 924 link_to_target 005353 constant entry internal dcl 1451 ref 853 872 881 895 906 literal_value 024601 constant entry internal dcl 5808 ref 5714 5725 5737 5749 5756 5763 5770 5776 5778 5849 5851 make_constant_opt_subscript 006056 constant entry internal dcl 1666 ref 1198 3571 3603 make_jump_to 010131 constant entry internal dcl 2221 ref 2069 2134 2260 move 021760 constant entry internal dcl 5165 ref 3730 6564 next 021057 constant label dcl 4869 ref 4845 optimize_flow_unit 014133 constant entry internal dcl 3429 ref 2913 2988 3036 3382 optimize_loop 012330 constant entry internal dcl 2867 ref 2793 optimize_subprogram 012071 constant entry internal dcl 2752 ref 558 output_is_new_induction_var 030325 constant entry internal dcl 6818 ref 6342 overflow_condition_detected 024560 constant label dcl 5792 ref 5519 pop_loop 013532 constant entry internal dcl 3288 ref 3080 print_hash_bucket_meters 040322 constant entry internal dcl 8713 ref 2991 3132 process 006404 constant entry internal dcl 1785 ref 1770 1774 process_assignment_list 036530 constant entry internal dcl 8620 ref 7867 7873 process_busy_on_exit_list 034467 constant entry internal dcl 8036 ref 7871 process_call 005163 constant entry internal dcl 1389 ref 840 1083 process_comparison_list 034321 constant entry internal dcl 7973 ref 7869 process_flow_units 031504 constant entry internal dcl 7203 ref 7170 7184 process_frozen_for_do 017046 constant entry internal dcl 4254 ref 3625 process_jump_label 020433 constant entry internal dcl 4715 ref 3821 3828 3835 3844 process_jump_target 020443 constant entry internal dcl 4726 ref 2928 3061 process_loops_top_down 012630 constant entry internal dcl 3000 ref 2799 process_moved_descendants 022536 constant entry internal dcl 5352 ref 3785 3793 6474 push_loop 013255 constant entry internal dcl 3188 ref 3043 put_in_a_loop_end 022676 constant entry internal dcl 5412 ref 5374 5385 5393 put_in_loop_end 037413 constant entry internal dcl 7-177 ref 3149 5439 6280 7107 reaction 000027 constant label array(0:22) dcl 1063 ref 1061 recompute_usage 003742 constant entry internal dcl 1024 ref 2805 record 020336 constant entry internal dcl 4678 ref 4664 4675 record_secondaries 020254 constant entry internal dcl 4646 ref 3328 3347 3742 3756 3772 4866 redirect_edge 010065 constant entry internal dcl 2195 ref 2090 2264 reduce 027372 constant entry internal dcl 6541 ref 6124 6138 reduce_strength 025631 constant entry internal dcl 5996 ref 3126 release_node 021471 constant entry internal dcl 5027 ref 2967 3331 3351 4445 4556 4854 4952 5011 6305 release_primary 021600 constant entry internal dcl 5079 ref 3155 3491 4597 4630 4828 4973 5319 remove 036722 constant entry internal dcl 8688 ref 8642 8647 remove_dead_assignments 031735 constant entry internal dcl 7299 ref 2812 remove_loop 032256 constant entry internal dcl 7425 ref 3182 remove_operator 032745 constant entry internal dcl 7578 ref 7558 remove_units_from_loop 032526 constant entry internal dcl 7536 ref 7452 7462 replace_inputs 017367 constant entry internal dcl 4405 ref 3986 4040 4319 5692 6337 6356 7606 replace_lhs_with_rhs 017171 constant entry internal dcl 4316 ref 4277 4286 replace_tests 030663 constant entry internal dcl 6977 ref 6437 restep 004405 constant label dcl 1138 ref 1070 1081 1085 1093 1097 1104 1111 1117 1133 retry 010542 constant label dcl 2400 in procedure "compute_busy_on_exit" ref 2454 retry 025642 constant label dcl 6034 in procedure "reduce_strength" ref 6429 retry 036750 constant label dcl 7-13 in procedure "get_opt_space" ref 7-23 search_for_equivalent 027722 constant entry internal dcl 6667 ref 6151 set 004737 constant entry internal dcl 1295 in procedure "build_flow_units" ref 837 917 920 939 959 976 1069 1080 1095 1102 1115 1130 1399 1414 set 017432 constant entry internal dcl 4425 in procedure "optimize_subprogram" ref 3760 3796 3810 3851 set_equivalences 017653 constant entry internal dcl 4518 ref 4487 4492 4495 set_externals 017626 constant entry internal dcl 4503 ref 3813 set_loop_variants 020000 constant entry internal dcl 4560 ref 2925 3058 3230 3393 3474 size_condition_detected 024564 constant label dcl 5796 ref 5520 splice_in_another_fu 010162 constant entry internal dcl 2235 ref 2108 2125 start_loop 012776 constant entry internal dcl 3087 ref 3014 3044 step 015562 constant label dcl 3872 in procedure "optimize_flow_unit" ref 3573 3605 3675 3688 3695 3745 step 003613 constant label dcl 984 in procedure "build_flow_units" ref 838 842 851 867 876 884 891 897 904 911 918 927 932 941 950 952 961 979 step 032155 constant label dcl 7379 in procedure "remove_dead_assignments" ref 7342 7346 7353 7361 7369 step 027054 constant label dcl 6425 in procedure "reduce_strength" ref 6048 6050 summarize_loop_busy_on_exit 011121 constant entry internal dcl 2493 ref 2381 summarize_loop_usage 010741 constant entry internal dcl 2460 ref 2377 timer 002153 constant entry internal dcl 595 ref 544 548 552 556 560 570 2803 2811 2815 2950 3124 3128 6436 trim_operator_list 021256 constant entry internal dcl 4934 ref 3508 try_to_calculate_range 034615 constant entry internal dcl 8081 ref 8008 8062 underflow_condition_detected 024570 constant label dcl 5800 ref 5521 union 021071 constant entry internal dcl 4879 ref 3119 3397 unlink 010454 constant entry internal dcl 2346 ref 2333 2337 unthread 037354 constant entry internal dcl 7-156 ref 5185 5348 6575 7130 7364 7634 unthread_flow_unit 011240 constant entry internal dcl 2537 ref 2342 use_inputs 004420 constant entry internal dcl 1153 ref 836 869 878 886 893 899 916 958 1063 1072 1087 1113 1394 use_one_input 004440 constant entry internal dcl 1167 ref 967 971 1121 1125 1162 use_symbol 004571 constant entry internal dcl 1235 ref 948 1079 1109 1202 1223 1229 used_in_loop 031366 constant entry internal dcl 7147 ref 6994 zerodivide_condition_detected 024574 constant label dcl 5804 ref 5522 NAMES DECLARED BY CONTEXT OR IMPLICATION. index builtin function ref 5861 5880 lbound builtin function ref 5722 rtrim builtin function ref 5862 5862 5881 5881 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 44376 44420 44121 44406 Length 45074 44121 22 440 255 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME fort_optimizer 3632 external procedure is an external procedure. timer internal procedure shares stack frame of external procedure fort_optimizer. assign_symbol_coordinates internal procedure shares stack frame of external procedure fort_optimizer. build_flow_units internal procedure shares stack frame of external procedure fort_optimizer. use_inputs internal procedure shares stack frame of external procedure fort_optimizer. use_one_input internal procedure shares stack frame of external procedure fort_optimizer. use_symbol internal procedure shares stack frame of external procedure fort_optimizer. set internal procedure shares stack frame of external procedure fort_optimizer. process_call internal procedure shares stack frame of external procedure fort_optimizer. change_cur_unit internal procedure shares stack frame of external procedure fort_optimizer. link_to_target internal procedure shares stack frame of external procedure fort_optimizer. get_final_target internal procedure shares stack frame of external procedure fort_optimizer. link_entry_to_target internal procedure shares stack frame of external procedure fort_optimizer. add_to_jump_assigned_list internal procedure shares stack frame of external procedure fort_optimizer. add_to_jump_assigned_target_list internal procedure shares stack frame of external procedure fort_optimizer. connect_jump_assigneds internal procedure shares stack frame of external procedure fort_optimizer. link internal procedure shares stack frame of external procedure fort_optimizer. make_constant_opt_subscript internal procedure shares stack frame of external procedure fort_optimizer. flow_analysis internal procedure shares stack frame of external procedure fort_optimizer. begin block on line 1724 99 begin block uses auto adjustable storage. process internal procedure shares stack frame of begin block on line 1724. create_new_back_target internal procedure shares stack frame of external procedure fort_optimizer. insert_flow_unit_before internal procedure shares stack frame of external procedure fort_optimizer. redirect_edge internal procedure shares stack frame of external procedure fort_optimizer. make_jump_to internal procedure shares stack frame of external procedure fort_optimizer. splice_in_another_fu internal procedure shares stack frame of external procedure fort_optimizer. detach_flow_units internal procedure shares stack frame of external procedure fort_optimizer. detach_flow_unit internal procedure shares stack frame of external procedure fort_optimizer. unlink internal procedure shares stack frame of external procedure fort_optimizer. analyze_data_flow internal procedure shares stack frame of external procedure fort_optimizer. compute_busy_on_exit internal procedure shares stack frame of external procedure fort_optimizer. summarize_loop_usage internal procedure shares stack frame of external procedure fort_optimizer. summarize_loop_busy_on_exit internal procedure shares stack frame of external procedure fort_optimizer. create_label internal procedure shares stack frame of external procedure fort_optimizer. unthread_flow_unit internal procedure shares stack frame of external procedure fort_optimizer. insert_statement_after internal procedure shares stack frame of external procedure fort_optimizer. insert_operator_after internal procedure shares stack frame of external procedure fort_optimizer. create_flow_unit internal procedure shares stack frame of external procedure fort_optimizer. create_loop internal procedure shares stack frame of external procedure fort_optimizer. optimize_subprogram internal procedure shares stack frame of external procedure fort_optimizer. optimize_loop internal procedure shares stack frame of external procedure fort_optimizer. consolidate_subprogram internal procedure shares stack frame of external procedure fort_optimizer. process_loops_top_down internal procedure shares stack frame of external procedure fort_optimizer. start_loop internal procedure shares stack frame of external procedure fort_optimizer. finish_loop internal procedure shares stack frame of external procedure fort_optimizer. push_loop internal procedure shares stack frame of external procedure fort_optimizer. pop_loop internal procedure shares stack frame of external procedure fort_optimizer. create_lp_frame internal procedure shares stack frame of external procedure fort_optimizer. optimize_flow_unit internal procedure shares stack frame of external procedure fort_optimizer. compare_expression internal procedure shares stack frame of external procedure fort_optimizer. common internal procedure shares stack frame of external procedure fort_optimizer. have_identity internal procedure shares stack frame of external procedure fort_optimizer. check_str_reducibility internal procedure shares stack frame of external procedure fort_optimizer. check_increment internal procedure shares stack frame of external procedure fort_optimizer. process_frozen_for_do internal procedure shares stack frame of external procedure fort_optimizer. replace_lhs_with_rhs internal procedure shares stack frame of external procedure fort_optimizer. decrement_input_ref_counts internal procedure shares stack frame of external procedure fort_optimizer. chain_sr_cand internal procedure shares stack frame of external procedure fort_optimizer. chain_incr internal procedure shares stack frame of external procedure fort_optimizer. replace_inputs 68 internal procedure is called by several nonquick procedures. set internal procedure shares stack frame of external procedure fort_optimizer. set_externals internal procedure shares stack frame of external procedure fort_optimizer. set_equivalences internal procedure shares stack frame of external procedure fort_optimizer. free_secondary internal procedure shares stack frame of external procedure fort_optimizer. set_loop_variants internal procedure shares stack frame of external procedure fort_optimizer. free_them internal procedure shares stack frame of external procedure fort_optimizer. record_secondaries internal procedure shares stack frame of external procedure fort_optimizer. record internal procedure shares stack frame of external procedure fort_optimizer. process_jump_label internal procedure shares stack frame of external procedure fort_optimizer. intersection internal procedure shares stack frame of external procedure fort_optimizer. union internal procedure shares stack frame of external procedure fort_optimizer. trim_operator_list internal procedure shares stack frame of external procedure fort_optimizer. clear internal procedure shares stack frame of external procedure fort_optimizer. detach_secondaries internal procedure shares stack frame of external procedure fort_optimizer. release_node internal procedure shares stack frame of external procedure fort_optimizer. create_o_node internal procedure shares stack frame of external procedure fort_optimizer. release_primary 68 internal procedure is called by several nonquick procedures. create_primary internal procedure shares stack frame of external procedure fort_optimizer. hash internal procedure shares stack frame of external procedure fort_optimizer. move internal procedure shares stack frame of external procedure fort_optimizer. insert_stm_in_back_target internal procedure shares stack frame of external procedure fort_optimizer. free_operator 86 internal procedure is called by several nonquick procedures. process_moved_descendants internal procedure shares stack frame of external procedure fort_optimizer. put_in_a_loop_end internal procedure shares stack frame of external procedure fort_optimizer. constant_expression 218 internal procedure enables or reverts conditions. on unit on line 5517 64 on unit on unit on line 5518 64 on unit on unit on line 5519 64 on unit on unit on line 5520 64 on unit on unit on line 5521 64 on unit on unit on line 5522 64 on unit literal_value 132 internal procedure calls itself recursively. constant_assign internal procedure shares stack frame of external procedure fort_optimizer. reduce_strength internal procedure shares stack frame of external procedure fort_optimizer. is_reducible internal procedure shares stack frame of external procedure fort_optimizer. is_invariant internal procedure shares stack frame of external procedure fort_optimizer. reduce internal procedure shares stack frame of external procedure fort_optimizer. search_for_equivalent internal procedure shares stack frame of external procedure fort_optimizer. create_sr_frame internal procedure shares stack frame of external procedure fort_optimizer. create_var internal procedure shares stack frame of external procedure fort_optimizer. create_sr_var_node internal procedure shares stack frame of external procedure fort_optimizer. output_is_new_induction_var internal procedure shares stack frame of external procedure fort_optimizer. add_new_induction_var internal procedure shares stack frame of external procedure fort_optimizer. find_new_induction_vars_on_ass_chain internal procedure shares stack frame of external procedure fort_optimizer. force_used_in_loop internal procedure shares stack frame of external procedure fort_optimizer. force_loop internal procedure shares stack frame of external procedure fort_optimizer. replace_tests internal procedure shares stack frame of external procedure fort_optimizer. change_test internal procedure shares stack frame of external procedure fort_optimizer. eliminate_increment internal procedure shares stack frame of external procedure fort_optimizer. used_in_loop internal procedure shares stack frame of external procedure fort_optimizer. process_flow_units internal procedure shares stack frame of external procedure fort_optimizer. chain_dac internal procedure shares stack frame of external procedure fort_optimizer. create_da_node internal procedure shares stack frame of external procedure fort_optimizer. remove_dead_assignments internal procedure shares stack frame of external procedure fort_optimizer. create_integer_temporary internal procedure shares stack frame of external procedure fort_optimizer. remove_loop internal procedure shares stack frame of external procedure fort_optimizer. get_flow_unit_label internal procedure shares stack frame of external procedure fort_optimizer. remove_units_from_loop internal procedure shares stack frame of external procedure fort_optimizer. remove_operator internal procedure shares stack frame of external procedure fort_optimizer. free_statement internal procedure shares stack frame of external procedure fort_optimizer. create_integer_constant 78 internal procedure is called by several nonquick procedures. index_value_analysis internal procedure shares stack frame of external procedure fort_optimizer. analyze_loop_index_values internal procedure shares stack frame of external procedure fort_optimizer. invariant internal procedure shares stack frame of external procedure fort_optimizer. check_busy_on_exit internal procedure shares stack frame of external procedure fort_optimizer. eligible internal procedure shares stack frame of external procedure fort_optimizer. disqualify_inputs internal procedure shares stack frame of external procedure fort_optimizer. disqualify internal procedure shares stack frame of external procedure fort_optimizer. chain_it internal procedure shares stack frame of external procedure fort_optimizer. process_comparison_list internal procedure shares stack frame of external procedure fort_optimizer. try_to_calculate_range internal procedure shares stack frame of external procedure fort_optimizer. calculate_range_by_subscripts internal procedure shares stack frame of external procedure fort_optimizer. get_max_size internal procedure shares stack frame of external procedure fort_optimizer. calculate_range_for_counter internal procedure shares stack frame of external procedure fort_optimizer. get_starting_value internal procedure shares stack frame of external procedure fort_optimizer. is_suitable_loop_exit internal procedure shares stack frame of external procedure fort_optimizer. find_range internal procedure shares stack frame of external procedure fort_optimizer. create_range internal procedure shares stack frame of external procedure fort_optimizer. process_assignment_list internal procedure shares stack frame of external procedure fort_optimizer. remove internal procedure shares stack frame of external procedure fort_optimizer. get_opt_space internal procedure shares stack frame of external procedure fort_optimizer. create_chain internal procedure shares stack frame of external procedure fort_optimizer. get_quad_space internal procedure shares stack frame of external procedure fort_optimizer. chain_input internal procedure shares stack frame of external procedure fort_optimizer. create_input_to internal procedure shares stack frame of external procedure fort_optimizer. get_polish_space internal procedure shares stack frame of external procedure fort_optimizer. derive_insert_for_bt internal procedure shares stack frame of external procedure fort_optimizer. unthread 69 internal procedure is called by several nonquick procedures. put_in_loop_end internal procedure shares stack frame of external procedure fort_optimizer. connect_expression internal procedure shares stack frame of external procedure fort_optimizer. disconnect_temporary 82 internal procedure is called by several nonquick procedures. in_namelist internal procedure shares stack frame of external procedure fort_optimizer. create_node 94 internal procedure is called by several nonquick procedures. create_constant 100 internal procedure is called by several nonquick procedures. print_hash_bucket_meters internal procedure shares stack frame of external procedure fort_optimizer. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME begin block on line 1724 000100 scan_bits begin block on line 1724 000100 scan_vector begin block on line 1724 000100 i begin block on line 1724 000101 j begin block on line 1724 000102 lvec begin block on line 1724 000103 lowest_level begin block on line 1724 000104 our_level begin block on line 1724 000106 e begin block on line 1724 000110 p begin block on line 1724 000112 q begin block on line 1724 000114 bd begin block on line 1724 000116 lowest_fu begin block on line 1724 constant_expression 000100 o constant_expression 000102 p constant_expression 000106 inp constant_expression 000110 outp constant_expression 000112 q constant_expression 000114 start_inp constant_expression 000116 opnd constant_expression 000117 i constant_expression 000120 op_code constant_expression 000122 data_type constant_expression 000124 max_data_type constant_expression 000126 result constant_expression 000130 source constant_expression 000134 error_condition constant_expression 000140 literal_expression constant_expression 000163 literal_operand constant_expression create_constant 000100 a_data_type create_constant 000102 a_value create_constant 000104 data_size create_constant 000105 hash_index create_constant 000106 mod_2_sum create_constant 000107 node_offset create_constant 000110 node_ptr create_constant create_node 000100 offset create_node disconnect_temporary 000100 p disconnect_temporary 000102 o disconnect_temporary 000104 inp disconnect_temporary 000106 last disconnect_temporary 000110 found disconnect_temporary fort_optimizer 000100 adam_loop fort_optimizer 000102 aliasable_mask_p fort_optimizer 000104 always_safe_to_move_class fort_optimizer 000106 cs fort_optimizer 000110 consolidating fort_optimizer 000111 do_timings fort_optimizer 000112 entry_unit fort_optimizer 000114 exit_unit fort_optimizer 000116 flow_unit_vector_p fort_optimizer 000120 free fort_optimizer 000126 freefu fort_optimizer 000130 freei fort_optimizer 000132 freep fort_optimizer 000134 freep_tail fort_optimizer 000136 freesrv fort_optimizer 000140 full_strength_reduction fort_optimizer 000141 hash_mask fort_optimizer 000331 i fort_optimizer 000332 init_frame fort_optimizer 000334 init_lp_frame fort_optimizer 000336 integer_scalar_mask_p fort_optimizer 000340 loop_entry_list fort_optimizer 000342 loop_vector_p fort_optimizer 000344 max_flow_units fort_optimizer 000345 max_operands fort_optimizer 000346 max_operators fort_optimizer 000347 max_sym fort_optimizer 000350 meter_hash_buckets fort_optimizer 000351 n_flow_units fort_optimizer 000352 n_loops fort_optimizer 000353 n_operators fort_optimizer 000354 n_sym fort_optimizer 000355 need_consolidation_pass fort_optimizer 000356 non_auto_mask_p fort_optimizer 000360 one fort_optimizer 000362 onep fort_optimizer 000364 operand_base fort_optimizer 000366 operand_max_len fort_optimizer 000370 opt_base fort_optimizer 000372 opt_max_len fort_optimizer 000374 polish_base fort_optimizer 000376 polish_max_len fort_optimizer 000377 quad_max_len fort_optimizer 000400 quadruple_base fort_optimizer 000402 s_list fort_optimizer 000404 scan_bits_p fort_optimizer 000406 scan_vector_p fort_optimizer 000410 shared_struc_ptr fort_optimizer 000412 state_discarded fort_optimizer 000414 temp_bits_p fort_optimizer 000416 zero fort_optimizer 000417 bt_list_st fort_optimizer 000432 p_list_st fort_optimizer 000445 hash_counter fort_optimizer 000460 timing_info fort_optimizer 000510 total_pf fort_optimizer 000511 total_vcpu fort_optimizer 000512 tx fort_optimizer 000513 max_n_sym fort_optimizer 000514 max_n_loops fort_optimizer 000515 max_n_flow_units fort_optimizer 000516 n_operands fort_optimizer 000517 allocate_symbol_name fort_optimizer 000536 vcpu timer 000540 pf timer 000541 last timer 000542 dummy timer 000552 s assign_symbol_coordinates 000554 h assign_symbol_coordinates 000556 ea assign_symbol_coordinates 000560 equiv_array_chain assign_symbol_coordinates 000562 equiv_array_tail assign_symbol_coordinates 000564 i assign_symbol_coordinates 000565 hdr assign_symbol_coordinates 000566 sym assign_symbol_coordinates 000567 has_parameters assign_symbol_coordinates 000576 need_new_unit build_flow_units 000600 lp build_flow_units 000602 o build_flow_units 000604 p build_flow_units 000606 st build_flow_units 000610 cur_unit build_flow_units 000612 op build_flow_units 000613 next_statement build_flow_units 000614 op_code build_flow_units 000615 ipol build_flow_units 000616 i build_flow_units 000617 chaining_input build_flow_units 000620 jump_assigned_list build_flow_units 000622 jump_assigned_target_list build_flow_units 000664 i use_inputs 000702 i use_one_input 000703 opnd use_one_input 000704 p use_one_input 000706 s use_one_input 000710 q use_one_input 000720 c use_symbol 000721 dt use_symbol 000722 other_dt use_symbol 000732 i set 000733 dt set 000734 other_dt set 000735 always_completely_sets set 000736 p set 000746 i process_call 000764 next_unit change_cur_unit 000774 target_statement link_to_target 000776 target link_to_target 001000 target_unit link_to_target 001010 try_to_optimize get_final_target 001011 i get_final_target 001012 o get_final_target 001022 target link_entry_to_target 001024 target_st link_entry_to_target 001034 c add_to_jump_assigned_list 001044 target add_to_jump_assigned_target_list 001046 target_st add_to_jump_assigned_target_list 001050 c add_to_jump_assigned_target_list 001052 sym add_to_jump_assigned_target_list 001062 c_source connect_jump_assigneds 001064 c_target connect_jump_assigneds 001066 source connect_jump_assigneds 001070 st connect_jump_assigneds 001072 o connect_jump_assigneds 001074 sym connect_jump_assigneds 001076 last connect_jump_assigneds 001100 last_c connect_jump_assigneds 001110 e link 001112 q link 001122 o make_constant_opt_subscript 001124 c2 make_constant_opt_subscript 001125 c3 make_constant_opt_subscript 001134 c flow_analysis 001136 e flow_analysis 001140 exit flow_analysis 001142 lastc flow_analysis 001144 lp flow_analysis 001146 p flow_analysis 001150 q flow_analysis 001152 i flow_analysis 001153 lvec flow_analysis 001154 pnum flow_analysis 001155 qnum flow_analysis 001156 found flow_analysis 001170 p create_new_back_target 001172 ins create_new_back_target 001174 e create_new_back_target 001176 q create_new_back_target 001200 fu create_new_back_target 001202 next_edge create_new_back_target 001204 pr create_new_back_target 001206 qst create_new_back_target 001210 o create_new_back_target 001212 j create_new_back_target 001213 qlabel create_new_back_target 001214 pnum create_new_back_target 001215 old_label create_new_back_target 001216 qpos create_new_back_target 001226 ins insert_flow_unit_before 001230 fu insert_flow_unit_before 001232 q insert_flow_unit_before 001234 qst insert_flow_unit_before 001236 q_statement insert_flow_unit_before 001237 qlabel insert_flow_unit_before 001246 e1 redirect_edge 001250 next_edge redirect_edge 001252 old_target redirect_edge 001262 j_operator make_jump_to 001263 j_statement make_jump_to 001272 q splice_in_another_fu 001274 j splice_in_another_fu 001275 useless splice_in_another_fu 001276 useless_ptr splice_in_another_fu 001306 lst detach_flow_units 001310 nst detach_flow_units 001312 p detach_flow_units 001314 qst detach_flow_units 001316 st detach_flow_units 001320 last_o detach_flow_units 001322 next_fu detach_flow_units 001324 q_statement detach_flow_units 001325 last_statement detach_flow_units 001326 next_statement detach_flow_units 001327 last_operator detach_flow_units 001336 p detach_flow_unit 001346 from_unit unlink 001350 to_unit unlink 001366 i compute_busy_on_exit 001367 j compute_busy_on_exit 001370 lvec compute_busy_on_exit 001372 bd compute_busy_on_exit 001374 e compute_busy_on_exit 001376 fu compute_busy_on_exit 001400 p compute_busy_on_exit 001402 q compute_busy_on_exit 001412 i summarize_loop_usage 001414 lp summarize_loop_usage 001416 p summarize_loop_usage 001430 i summarize_loop_busy_on_exit 001432 c summarize_loop_busy_on_exit 001434 lp summarize_loop_busy_on_exit 001446 qlabel create_label 001450 qlab create_label 001466 our_statement insert_statement_after 001467 next_statement insert_statement_after 001470 next_operator insert_statement_after 001471 last_operator insert_statement_after 001472 lastp insert_statement_after 001474 ourp insert_statement_after 001476 nextp insert_statement_after 001500 nextop insert_statement_after 001502 lastop insert_statement_after 001512 o insert_operator_after 001514 next_o insert_operator_after 001516 last_o insert_operator_after 001520 op insert_operator_after 001530 p create_flow_unit 001540 p create_loop 001542 prev create_loop 001552 our_depth optimize_subprogram 001554 fu optimize_subprogram 001556 lp optimize_subprogram 001560 bt optimize_subprogram 001562 lpf optimize_subprogram 001564 sr_chain optimize_subprogram 001566 sr_tail optimize_subprogram 001570 incr_chain optimize_subprogram 001572 ass_chain optimize_subprogram 001574 da_chain optimize_subprogram 001576 free_var_list optimize_subprogram 001600 used_invariant_symbol optimize_subprogram 001601 doing_loop optimize_subprogram 001602 i optimize_subprogram 001603 j optimize_subprogram 001604 k optimize_subprogram 001605 new_statement optimize_subprogram 001606 op optimize_subprogram 001607 opt_mode optimize_subprogram 001610 stm optimize_subprogram 001612 q optimize_subprogram 001614 t optimize_subprogram 001616 o optimize_subprogram 001620 c optimize_subprogram 001622 lastc optimize_subprogram 001624 srvp optimize_subprogram 001636 lp optimize_loop 001640 last_fu optimize_loop 001642 next_lp optimize_loop 001674 c finish_loop 001676 o finish_loop 001700 p finish_loop 001702 q finish_loop 001704 outp finish_loop 001706 i finish_loop 001707 exit_target finish_loop 001710 has_multiple_exits finish_loop 001720 i push_loop 001722 o push_loop 001724 p push_loop 001726 q push_loop 001730 hold_list push_loop 001732 outp push_loop 001734 next_lp push_loop 001736 last_p push_loop 001746 hold_has_label pop_loop 001747 hold_has_operator_list pop_loop 001750 hold_entry_pt pop_loop 001751 possibly_found pop_loop 001752 p pop_loop 001754 q pop_loop 001756 hold_list pop_loop 001760 new pop_loop 001762 stm pop_loop 001764 o pop_loop 001766 outp pop_loop 001770 c pop_loop 001772 last_c pop_loop 001774 old_lp pop_loop 001776 hash_index pop_loop 001777 hold_first_statement pop_loop 002006 p create_lp_frame 002016 fu optimize_flow_unit 002020 our_depth optimize_flow_unit 002021 ipol optimize_flow_unit 002022 bt optimize_flow_unit 002024 o optimize_flow_unit 002026 outp optimize_flow_unit 002030 p optimize_flow_unit 002032 q optimize_flow_unit 002034 stm optimize_flow_unit 002036 lp optimize_flow_unit 002040 bd_level_number optimize_flow_unit 002041 coord optimize_flow_unit 002042 i optimize_flow_unit 002043 next_op optimize_flow_unit 002044 next_statement optimize_flow_unit 002045 next_unit_statement optimize_flow_unit 002046 op_code optimize_flow_unit 002047 opnd optimize_flow_unit 002050 outp_node_type optimize_flow_unit 002051 hash_index optimize_flow_unit 002052 invariant optimize_flow_unit 002053 is_articulation_block optimize_flow_unit 002054 used_across_loops optimize_flow_unit 002055 reducible optimize_flow_unit 002056 all_constant optimize_flow_unit 002057 have_sr_candidate optimize_flow_unit 002060 doing_full_optimization optimize_flow_unit 002061 succeeded optimize_flow_unit 002062 optimizing_loop optimize_flow_unit 002063 possibly_found optimize_flow_unit 002064 constant_assignment optimize_flow_unit 002116 a compare_expression 002120 b compare_expression 002122 r1 compare_expression 002124 r2 compare_expression 002126 i compare_expression 002144 old common 002146 new common 002150 old_outp common 002152 new_outp common 002154 old_startp common 002156 new_fu common 002160 new_out common 002161 old_out common 002162 i common 002172 other have_identity 002174 otherp have_identity 002176 inp have_identity 002206 p check_str_reducibility 002210 next_op check_str_reducibility 002212 i check_str_reducibility 002214 is_loop_invariant check_str_reducibility 002224 oexpr check_increment 002226 inp check_increment 002230 incrp check_increment 002232 target check_increment 002233 i check_increment 002234 op_code check_increment 002235 input check_increment 002236 is_temp_or_array_ref check_increment 002246 p process_frozen_for_do 002250 assp process_frozen_for_do 002252 s process_frozen_for_do 002254 hash_index process_frozen_for_do 002255 possibly_found process_frozen_for_do 002272 i decrement_input_ref_counts 002273 opnd decrement_input_ref_counts 002274 o decrement_input_ref_counts 002276 p decrement_input_ref_counts 002316 src chain_sr_cand 002326 c chain_incr 002336 p set 002340 q set 002342 secp set 002344 dt set 002354 s set_externals 002356 secp set_externals 002366 p set_equivalences 002370 dt set_equivalences 002372 q set_equivalences 002374 secp set_equivalences 002376 head set_equivalences 002377 off set_equivalences 002400 delta set_equivalences 002410 secp free_secondary 002420 lp set_loop_variants 002422 secp set_loop_variants 002424 s set_loop_variants 002434 secp free_them 002436 o free_them 002440 outp free_them 002442 p free_them 002444 c free_them 002446 inp free_them 002450 lastc free_them 002452 j free_them 002453 lvec free_them 002454 queue free_them 003062 o record_secondaries 003064 code record_secondaries 003065 i record_secondaries 003066 have_opt_subscript record_secondaries 003104 s record 003106 secp record 003110 c record 003120 stm process_jump_label 003122 q process_jump_label 003124 t process_jump_label 003126 new process_jump_label 003130 target_fu process_jump_label 003132 target_lp process_jump_label 003134 c process_jump_label 003136 last process_jump_label 003140 p process_jump_label 003142 pf process_jump_label 003144 target_optr process_jump_label 003146 i process_jump_label 003156 state intersection 003160 o intersection 003162 p intersection 003164 st_list intersection 003166 t intersection 003170 next_p intersection 003172 obptr intersection 003174 i intersection 003175 j intersection 003176 possibly_found intersection 003206 stm union 003210 st_list union 003212 p union 003214 q union 003216 t union 003220 obptr union 003222 i union 003232 p trim_operator_list 003234 q trim_operator_list 003236 st_list trim_operator_list 003240 our_depth trim_operator_list 003250 p clear 003252 q clear 003254 i clear 003264 detach_constant_assignments detach_secondaries 003266 p detach_secondaries 003270 q detach_secondaries 003272 c detach_secondaries 003274 lastc detach_secondaries 003304 p release_node 003314 p create_o_node 003324 p create_primary 003334 o hash 003336 mod_2_sum hash 003337 i hash 003340 hash_mask_index hash 003356 o move 003360 stm move 003362 fu move 003364 bt move 003366 c move 003367 i move 003370 opnd move 003371 op move 003372 outp_node_type move 003373 op_code move 003374 o_before move 003376 o_after move 003400 p move 003402 outp move 003422 new_statement insert_stm_in_back_target 003424 new_stm insert_stm_in_back_target 003426 first_stm insert_stm_in_back_target 003436 o process_moved_descendants 003440 i process_moved_descendants 003441 c process_moved_descendants 003442 opnd process_moved_descendants 003443 op_code process_moved_descendants 003444 outp process_moved_descendants 003446 p process_moved_descendants 003466 p put_in_a_loop_end 003470 lp_evaluated put_in_a_loop_end 003472 lp_to_put put_in_a_loop_end 003474 q put_in_a_loop_end 003476 max_fu_pos put_in_a_loop_end 003506 o constant_assign 003510 inp constant_assign 003512 outp constant_assign 003514 in_dt constant_assign 003515 out_dt constant_assign 003516 target constant_assign 003520 char4_target constant_assign 003522 char8_target constant_assign 003532 lp reduce_strength 003534 srp reduce_strength 003536 incrp reduce_strength 003540 src reduce_strength 003542 incrc reduce_strength 003544 cur_frame reduce_strength 003546 cur_o reduce_strength 003550 inp reduce_strength 003552 o reduce_strength 003554 bt reduce_strength 003556 assp reduce_strength 003560 outp reduce_strength 003562 deltap reduce_strength 003564 stm reduce_strength 003566 fu reduce_strength 003570 srvp reduce_strength 003572 p reduce_strength 003574 last reduce_strength 003576 varp reduce_strength 003600 new_incrp reduce_strength 003602 q reduce_strength 003604 i reduce_strength 003605 induction_var reduce_strength 003606 coord reduce_strength 003607 op_code reduce_strength 003610 number reduce_strength 003611 new_increment reduce_strength 003612 delta reduce_strength 003613 which reduce_strength 003614 insert_delta reduce_strength 003615 variable reduce_strength 003616 assignment reduce_strength 003617 j reduce_strength 003620 insert_new reduce_strength 003621 inc_found reduce_strength 003622 inc_found_before reduce_strength 003623 induction_busy_on_exit reduce_strength 003624 have_test_replacement_candidate reduce_strength 003625 found_new_induction_variable reduce_strength 003626 induction_boe_from_bt reduce_strength 003627 update_insert_operator reduce_strength 003644 p is_invariant 003654 o reduce 003656 which reduce 003660 next_frame reduce 003662 outp reduce 003664 deltap reduce 003666 p reduce 003670 p1 reduce 003672 p2 reduce 003674 i reduce 003675 factor reduce 003676 cvalue1 reduce 003677 cvalue2 reduce 003706 srvp search_for_equivalent 003710 p search_for_equivalent 003712 o1 search_for_equivalent 003714 o2 search_for_equivalent 003716 i search_for_equivalent 003717 ninst search_for_equivalent 003720 which search_for_equivalent 003721 inequality_found search_for_equivalent 003730 new_frame create_sr_frame 003740 var create_var 003741 lp_num create_var 003742 p create_var 003744 last create_var 003746 srvp create_var 003756 srvp create_sr_var_node 003766 s output_is_new_induction_var 003776 o add_new_induction_var 004000 left add_new_induction_var 004002 right add_new_induction_var 004004 srvp add_new_induction_var 004014 lp find_new_induction_vars_on_ass_chain 004016 c find_new_induction_vars_on_ass_chain 004020 next find_new_induction_vars_on_ass_chain 004022 prev find_new_induction_vars_on_ass_chain 004024 o find_new_induction_vars_on_ass_chain 004026 left find_new_induction_vars_on_ass_chain 004030 right find_new_induction_vars_on_ass_chain 004032 changed find_new_induction_vars_on_ass_chain 004042 adam force_used_in_loop 004044 p force_used_in_loop 004046 c force_used_in_loop 004056 fu force_loop 004066 incrc replace_tests 004070 incrp replace_tests 004072 indp replace_tests 004074 o replace_tests 004076 fu replace_tests 004100 induction_var replace_tests 004101 n_uses replace_tests 004102 st_found replace_tests 004103 which replace_tests 004104 code replace_tests 004114 srvp change_test 004116 p change_test 004120 invp change_test 004122 q change_test 004124 min_ninst change_test 004125 invariant_opnd change_test 004126 i change_test 004127 last_temp change_test 004130 input change_test 004131 j change_test 004132 found_all_constant change_test 004142 p eliminate_increment 004152 induction_var used_in_loop 004154 adam used_in_loop 004156 coord used_in_loop 004157 n_uses used_in_loop 004160 p used_in_loop 004162 ind_used used_in_loop 004172 o process_flow_units 004174 stm process_flow_units 004176 fu process_flow_units 004200 next_statement process_flow_units 004201 next_unit_statement process_flow_units 004202 op process_flow_units 004203 i process_flow_units 004224 p chain_dac 004234 p create_da_node 004244 dac remove_dead_assignments 004246 fu remove_dead_assignments 004250 last remove_dead_assignments 004252 o remove_dead_assignments 004254 varp remove_dead_assignments 004256 back remove_dead_assignments 004257 c remove_dead_assignments 004260 first_statement remove_dead_assignments 004261 i remove_dead_assignments 004262 op remove_dead_assignments 004263 variable remove_dead_assignments 004264 in_common remove_dead_assignments 004302 t create_integer_temporary 004304 temp create_integer_temporary 004314 adam remove_loop 004316 p remove_loop 004320 bt remove_loop 004322 bd remove_loop 004324 bdl remove_loop 004326 exit_target remove_loop 004330 jop remove_loop 004332 jst remove_loop 004334 finished remove_loop 004335 j_operator remove_loop 004336 j_statement remove_loop 004346 f_label get_flow_unit_label 004347 f_statement get_flow_unit_label 004356 fu remove_units_from_loop 004360 first_fu remove_units_from_loop 004362 o remove_units_from_loop 004364 stm remove_units_from_loop 004366 op remove_units_from_loop 004367 next_op remove_units_from_loop 004370 next_statement remove_units_from_loop 004371 next_unit_statement remove_units_from_loop 004402 o remove_operator 004404 p remove_operator 004406 outp remove_operator 004410 i remove_operator 004411 opnd remove_operator 004430 next_statement free_statement 004431 last_statement free_statement 004432 nst free_statement 004434 lst free_statement 004444 i index_value_analysis 004454 lp analyze_loop_index_values 004456 do_analysis analyze_loop_index_values 004460 fu analyze_loop_index_values 004462 o analyze_loop_index_values 004464 opnd analyze_loop_index_values 004470 outp analyze_loop_index_values 004472 p analyze_loop_index_values 004474 stm analyze_loop_index_values 004476 i analyze_loop_index_values 004477 op_code analyze_loop_index_values 004500 ipol analyze_loop_index_values 004501 next_statement analyze_loop_index_values 004502 op analyze_loop_index_values 004503 next_unit_statement analyze_loop_index_values 004504 assignment_list analyze_loop_index_values 004506 comparison_list analyze_loop_index_values 004510 eligible_ind_var_op_var_list analyze_loop_index_values 004512 busy_on_exit_list analyze_loop_index_values 004526 o invariant 004552 i disqualify_inputs 004553 opnd disqualify_inputs 004600 c chain_it 004610 bt process_comparison_list 004612 c process_comparison_list 004614 exit_c process_comparison_list 004616 exit_fu process_comparison_list 004620 last_c process_comparison_list 004622 orig_o process_comparison_list 004624 p process_comparison_list 004626 prev_fu process_comparison_list 004630 r process_comparison_list 004632 op_code process_comparison_list 004633 have_eligible_variable process_comparison_list 004634 which process_comparison_list 004635 range_bits process_comparison_list 004644 p try_to_calculate_range 004646 ac try_to_calculate_range 004650 var try_to_calculate_range 004651 range_bits try_to_calculate_range 004660 p calculate_range_by_subscripts 004662 range_bits calculate_range_by_subscripts 004664 fu calculate_range_by_subscripts 004666 o calculate_range_by_subscripts 004670 s calculate_range_by_subscripts 004672 first_statement calculate_range_by_subscripts 004673 op calculate_range_by_subscripts 004674 n calculate_range_by_subscripts 004675 var calculate_range_by_subscripts 004676 upper_bound calculate_range_by_subscripts 004677 lower_bound calculate_range_by_subscripts 004700 increment calculate_range_by_subscripts 004701 constant_offset calculate_range_by_subscripts 004702 max_size calculate_range_by_subscripts 004712 d get_max_size 004714 max_chars get_max_size 004715 max_words get_max_size 004716 max_size get_max_size 004726 p calculate_range_for_counter 004730 range_bits calculate_range_for_counter 004732 c calculate_range_for_counter 004734 const_p calculate_range_for_counter 004736 fu calculate_range_for_counter 004740 last_c calculate_range_for_counter 004742 o calculate_range_for_counter 004744 s calculate_range_for_counter 004746 u calculate_range_for_counter 004750 first_statement calculate_range_for_counter 004751 op calculate_range_for_counter 004752 var calculate_range_for_counter 004753 upper_bound calculate_range_for_counter 004754 lower_bound calculate_range_for_counter 004755 bound calculate_range_for_counter 004756 starting_value calculate_range_for_counter 004757 other_value calculate_range_for_counter 004760 found calculate_range_for_counter 004762 opt_subscript_chain calculate_range_for_counter 004764 update_chain calculate_range_for_counter 004766 increment calculate_range_for_counter 004767 other_increment calculate_range_for_counter 004776 p get_starting_value 005000 first_statement get_starting_value 005001 i get_starting_value 005002 op get_starting_value 005003 var get_starting_value 005004 o get_starting_value 005006 in_common get_starting_value 005024 orig_o is_suitable_loop_exit 005026 lp is_suitable_loop_exit 005030 fu is_suitable_loop_exit 005032 inp is_suitable_loop_exit 005034 jop is_suitable_loop_exit 005036 lab is_suitable_loop_exit 005040 o is_suitable_loop_exit 005042 outp is_suitable_loop_exit 005044 stm is_suitable_loop_exit 005046 first_statement is_suitable_loop_exit 005047 op is_suitable_loop_exit 005050 var is_suitable_loop_exit 005051 found is_suitable_loop_exit 005060 p find_range 005062 lp find_range 005064 r find_range 005074 r create_range 005104 c process_assignment_list 005106 inp process_assignment_list 005110 last_c process_assignment_list 005112 next_c process_assignment_list 005114 o process_assignment_list 005116 outp process_assignment_list 005120 rin process_assignment_list 005122 rout process_assignment_list 005124 change_occurred process_assignment_list 005142 p get_opt_space 005152 p create_chain 005162 place get_quad_space 005172 qoff chain_input 005174 q chain_input 005176 last chain_input 005206 q create_input_to 005216 p get_polish_space 005226 bt_statement derive_insert_for_bt 005227 next_statement derive_insert_for_bt 005230 o derive_insert_for_bt 005232 btst derive_insert_for_bt 005242 p put_in_loop_end 005244 fu_to_put put_in_loop_end 005246 c put_in_loop_end 005256 which connect_expression 005260 o connect_expression 005262 p connect_expression 005272 var in_namelist 005273 i in_namelist 005274 ipol in_namelist 005304 i print_hash_bucket_meters 005306 p print_hash_bucket_meters free_operator 000100 o free_operator 000102 t free_operator 000104 pr free_operator 000106 temp free_operator literal_value 000100 descriptor_type literal_value 000101 dp_picture literal_value 000110 idx_of_e literal_value 000111 int_value literal_value 000112 real_picture literal_value 000116 result literal_value release_primary 000100 p release_primary 000102 o release_primary replace_inputs 000100 new_out replace_inputs 000102 inp replace_inputs unthread 000100 nextp unthread 000102 backp unthread THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. fx1_to_fl2 r_e_as r_ne_as alloc_char_temp alloc_bit_temp unpk_to_pk enter_begin_block leave_begin_block call_ent_var_desc call_ent_var call_ext_out_desc call_ext_out call_int_this call_int_other return_mac fl2_to_fx1 tra_ext_1 alloc_auto_adj mdfx1 signal_op enable_op shorten_stack ext_entry int_entry size_check_fx1 stop THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. assign_ cpu_time_and_paging_ ioa_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. fort_node_templates_$flow_unit_template sys_info$max_seg_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 20 001345 481 001355 483 001363 484 001415 487 001416 489 001422 490 001424 491 001426 492 001430 494 001432 495 001434 496 001436 497 001440 499 001442 501 001453 503 001454 505 001455 506 001467 508 001501 510 001504 512 001517 515 001534 517 001535 518 001536 520 001541 522 001542 523 001543 525 001560 526 001562 527 001577 529 001602 533 001604 534 001615 536 001617 538 001623 540 001631 542 001633 544 001637 546 001643 548 001644 550 001650 552 001651 554 001655 556 001656 558 001662 560 001663 562 001667 564 001670 565 001675 566 001702 568 001707 570 001715 572 001720 574 001722 575 001744 577 001764 579 002000 580 002005 581 002012 582 002062 584 002064 585 002113 590 002141 591 002150 593 002152 595 002153 606 002155 609 002160 611 002162 612 002175 613 002207 614 002221 617 002222 618 002235 619 002237 620 002245 621 002250 622 002252 625 002254 627 002257 629 002260 643 002261 644 002265 652 002270 653 002276 655 002300 656 002306 658 002310 660 002316 662 002320 663 002322 664 002324 667 002331 668 002334 671 002347 673 002353 675 002357 676 002366 678 002370 681 002402 684 002412 685 002415 687 002421 688 002423 689 002425 691 002430 696 002435 698 002442 699 002475 702 002476 703 002477 704 002506 706 002510 708 002517 711 002530 714 002542 720 002564 721 002570 722 002572 723 002601 725 002602 727 002605 728 002606 729 002615 730 002616 732 002627 737 002633 741 002645 742 002652 744 002657 746 002665 747 002674 749 002702 750 002707 751 002723 753 002725 754 002734 756 002736 758 002745 760 002746 763 002755 766 002773 768 002776 769 003015 773 003022 775 003026 777 003027 792 003030 793 003032 795 003035 797 003040 798 003041 799 003042 800 003046 801 003053 802 003056 803 003062 807 003064 808 003077 809 003101 811 003104 817 003123 823 003131 824 003141 825 003143 826 003146 828 003150 834 003151 836 003153 837 003154 838 003164 840 003165 842 003166 844 003167 850 003171 851 003174 853 003175 855 003203 856 003205 858 003206 863 003215 864 003217 867 003223 869 003224 871 003225 872 003233 873 003242 874 003244 875 003246 876 003247 878 003250 880 003251 881 003263 882 003272 883 003274 884 003276 886 003277 888 003300 889 003301 890 003303 891 003304 893 003305 895 003306 896 003315 897 003317 899 003320 901 003321 902 003323 903 003325 904 003326 906 003327 908 003335 909 003336 910 003343 911 003345 913 003346 916 003351 917 003352 918 003362 920 003363 922 003372 924 003400 925 003401 927 003402 929 003403 931 003406 932 003407 934 003410 937 003413 938 003421 939 003431 940 003441 941 003443 943 003444 946 003447 947 003455 948 003465 949 003473 950 003475 952 003476 955 003477 958 003502 959 003503 961 003513 963 003514 966 003517 967 003525 968 003527 970 003531 971 003543 976 003556 977 003565 979 003570 981 003571 984 003613 987 003620 988 003623 989 003626 997 003632 1002 003643 1006 003647 1008 003653 1009 003662 1010 003673 1014 003676 1018 003706 1019 003717 1020 003730 1022 003741 1024 003742 1030 003743 1034 003744 1035 003753 1036 003756 1038 004012 1042 004014 1043 004022 1047 004101 1051 004104 1052 004117 1053 004121 1054 004124 1058 004126 1059 004135 1060 004137 1061 004142 1063 004144 1069 004145 1070 004155 1072 004156 1075 004157 1076 004163 1079 004172 1080 004174 1081 004204 1083 004205 1085 004206 1087 004207 1093 004210 1095 004211 1097 004220 1099 004221 1101 004227 1102 004237 1103 004247 1104 004251 1106 004252 1108 004260 1109 004267 1110 004275 1111 004277 1113 004300 1115 004301 1117 004311 1119 004312 1121 004317 1122 004321 1124 004323 1125 004335 1130 004350 1131 004357 1133 004362 1135 004363 1138 004405 1145 004412 1149 004416 1151 004417 1153 004420 1161 004421 1162 004433 1163 004435 1165 004437 1167 004440 1177 004442 1178 004444 1180 004447 1182 004450 1184 004452 1186 004457 1191 004462 1193 004501 1198 004506 1200 004515 1202 004516 1204 004526 1206 004527 1209 004536 1211 004540 1215 004544 1218 004550 1220 004552 1223 004554 1228 004562 1229 004566 1233 004570 1235 004571 1241 004573 1243 004603 1245 004604 1246 004611 1249 004626 1251 004631 1253 004635 1255 004640 1256 004651 1259 004671 1261 004673 1266 004676 1267 004702 1268 004707 1276 004710 1279 004716 1282 004723 1284 004724 1286 004726 1287 004731 1293 004736 1295 004737 1310 004741 1312 004743 1314 004746 1316 004751 1318 004755 1320 004760 1321 004761 1323 004770 1327 004774 1329 005000 1330 005006 1332 005007 1334 005024 1336 005027 1338 005032 1340 005036 1342 005041 1345 005065 1347 005072 1349 005073 1351 005074 1354 005112 1360 005116 1366 005117 1369 005125 1372 005132 1374 005133 1377 005147 1381 005152 1387 005162 1389 005163 1394 005164 1398 005165 1399 005177 1400 005206 1404 005210 1405 005220 1408 005242 1410 005263 1414 005270 1416 005300 1418 005303 1420 005304 1427 005305 1429 005306 1431 005315 1433 005317 1434 005327 1436 005333 1437 005334 1439 005335 1441 005337 1442 005341 1443 005343 1444 005344 1446 005345 1447 005347 1449 005352 1451 005353 1461 005355 1463 005367 1465 005373 1466 005375 1467 005400 1468 005401 1470 005403 1472 005406 1474 005410 1477 005416 1479 005417 1492 005421 1493 005423 1495 005425 1496 005430 1497 005436 1499 005440 1501 005453 1503 005460 1505 005465 1509 005471 1510 005475 1511 005476 1513 005477 1514 005500 1516 005501 1518 005502 1525 005503 1527 005511 1530 005517 1531 005521 1534 005524 1535 005527 1537 005532 1539 005534 1541 005535 1546 005536 1548 005540 1549 005543 1550 005545 1552 005546 1554 005547 1559 005550 1560 005556 1562 005560 1564 005563 1566 005571 1568 005573 1569 005576 1570 005600 1573 005601 1575 005603 1576 005606 1577 005614 1579 005624 1581 005625 1586 005626 1588 005630 1590 005636 1592 005641 1593 005644 1594 005647 1595 005652 1597 005655 1598 005670 1599 005675 1601 005700 1602 005702 1604 005705 1606 005711 1607 005713 1608 005715 1611 005717 1613 005721 1615 005730 1616 005732 1618 005734 1619 005747 1621 005752 1622 005754 1623 005764 1624 005773 1626 005776 1628 006002 1629 006004 1630 006006 1633 006010 1637 006011 1646 006013 1648 006017 1649 006022 1651 006023 1652 006027 1654 006032 1655 006036 1656 006037 1659 006044 1660 006047 1661 006050 1664 006055 1666 006056 1672 006060 1673 006063 1674 006067 1675 006072 1676 006105 1678 006107 1680 006110 1692 006111 1693 006115 1694 006117 1695 006120 1697 006122 1698 006127 1699 006132 1701 006135 1702 006144 1703 006147 1705 006151 1706 006153 1707 006154 1708 006157 1712 006165 1713 006171 1715 006173 1717 006176 1718 006177 1724 006201 1726 006204 1727 006211 1732 006220 1733 006227 1735 006233 1743 006241 1744 006243 1745 006246 1747 006250 1748 006256 1749 006260 1751 006263 1752 006264 1754 006265 1756 006271 1757 006302 1762 006307 1763 006311 1764 006313 1765 006315 1767 006317 1768 006323 1770 006326 1773 006336 1774 006344 1775 006350 1776 006354 1778 006356 1781 006362 1782 006373 1783 006400 1806 006402 1785 006404 1790 006406 1792 006417 1794 006422 1795 006423 1797 006424 1799 006425 1800 006430 1801 006431 1804 006434 1810 006435 1814 006437 1815 006445 1816 006450 1817 006453 1821 006454 1822 006464 1823 006466 1825 006502 1827 006506 1830 006510 1835 006516 1836 006522 1837 006524 1838 006526 1839 006530 1842 006532 1846 006535 1847 006541 1848 006547 1850 006551 1851 006560 1852 006563 1856 006566 1857 006572 1858 006575 1859 006576 1865 006600 1866 006607 1867 006611 1868 006615 1870 006616 1871 006623 1872 006634 1874 006636 1878 006665 1879 006666 1880 006671 1881 006674 1883 006676 1884 006702 1886 006704 1887 006706 1889 006711 1894 006715 1895 006717 1896 006721 1901 006723 1902 006727 1903 006737 1905 006741 1907 006744 1908 006745 1909 006755 1911 006762 1912 006767 1914 006772 1915 007000 1917 007002 1919 007006 1920 007010 1921 007021 1922 007030 1923 007034 1925 007037 1931 007042 1932 007052 1933 007056 1937 007061 1938 007070 1939 007074 1943 007077 1944 007107 1946 007112 1947 007120 1950 007133 1952 007146 1954 007152 1964 007154 1965 007163 1966 007166 1967 007170 1969 007172 1973 007206 1974 007211 1975 007213 1980 007216 1981 007224 1982 007230 1983 007232 1984 007237 1985 007241 1989 007242 1991 007252 1995 007256 1997 007270 1998 007272 1999 007275 2000 007300 2001 007301 2002 007306 2003 007311 2004 007315 2008 007321 2009 007331 2010 007334 2012 007342 2013 007350 2014 007354 2015 007362 2016 007366 2017 007373 2018 007376 2022 007400 2026 007406 2028 007407 2030 007410 2043 007412 2044 007415 2045 007420 2047 007423 2049 007425 2050 007431 2051 007433 2052 007441 2053 007442 2055 007445 2056 007461 2057 007464 2059 007477 2061 007502 2063 007506 2065 007510 2067 007516 2069 007526 2074 007535 2075 007544 2076 007547 2078 007551 2085 007563 2090 007571 2094 007573 2096 007575 2097 007602 2098 007605 2100 007610 2103 007621 2105 007625 2108 007632 2110 007640 2112 007641 2114 007651 2116 007660 2118 007663 2120 007665 2121 007675 2123 007704 2125 007706 2127 007714 2129 007715 2132 007721 2133 007723 2134 007732 2138 007734 2142 007737 2144 007741 2146 007745 2156 007747 2158 007752 2160 007754 2162 007757 2163 007765 2164 007777 2167 010000 2168 010001 2169 010005 2170 010010 2171 010012 2172 010013 2173 010014 2175 010016 2176 010024 2177 010026 2179 010031 2180 010040 2181 010044 2183 010046 2184 010050 2186 010051 2187 010053 2189 010056 2190 010061 2191 010063 2195 010065 2203 010067 2204 010073 2206 010075 2208 010102 2209 010104 2212 010112 2213 010115 2214 010120 2215 010122 2216 010123 2219 010130 2221 010131 2229 010133 2230 010150 2231 010154 2233 010161 2235 010162 2246 010164 2248 010171 2249 010177 2250 010202 2251 010210 2252 010214 2254 010217 2255 010234 2256 010236 2258 010241 2260 010245 2264 010252 2266 010254 2268 010265 2272 010266 2280 010267 2281 010276 2283 010300 2285 010303 2286 010307 2290 010311 2291 010314 2292 010316 2293 010321 2294 010323 2295 010326 2296 010330 2297 010333 2301 010335 2305 010375 2306 010401 2307 010405 2308 010411 2312 010413 2314 010415 2316 010420 2320 010421 2328 010423 2332 010426 2333 010432 2334 010436 2336 010437 2337 010444 2338 010450 2342 010451 2344 010453 2346 010454 2355 010456 2356 010461 2358 010464 2360 010473 2361 010475 2364 010503 2366 010512 2367 010515 2370 010523 2372 010524 2377 010525 2379 010526 2381 010527 2383 010530 2385 010531 2395 010532 2400 010542 2402 010547 2403 010552 2405 010554 2406 010555 2407 010556 2409 010560 2410 010563 2411 010564 2414 010571 2415 010574 2417 010576 2418 010604 2419 010606 2422 010615 2426 010636 2428 010645 2429 010650 2431 010657 2432 010660 2434 010665 2435 010667 2438 010671 2439 010675 2440 010676 2447 010701 2451 010725 2453 010734 2454 010737 2458 010740 2460 010741 2469 010742 2470 010751 2472 010754 2473 010762 2476 011011 2477 011017 2478 011026 2479 011032 2481 011035 2482 011044 2485 011073 2486 011101 2487 011110 2488 011113 2489 011116 2491 011120 2493 011121 2501 011122 2502 011131 2504 011134 2505 011142 2508 011154 2509 011157 2511 011161 2513 011162 2523 011164 2524 011200 2526 011203 2527 011210 2528 011214 2529 011220 2530 011224 2531 011233 2533 011236 2537 011240 2542 011242 2543 011247 2545 011252 2546 011254 2548 011255 2550 011257 2552 011260 2566 011262 2567 011266 2571 011271 2572 011274 2573 011276 2574 011300 2575 011302 2579 011304 2580 011310 2581 011313 2585 011315 2586 011316 2587 011317 2588 011322 2592 011324 2593 011331 2594 011337 2595 011345 2596 011353 2597 011356 2598 011360 2599 011363 2603 011366 2604 011372 2606 011374 2610 011377 2622 011401 2623 011403 2624 011407 2628 011412 2629 011416 2630 011423 2631 011425 2632 011427 2636 011431 2638 011435 2640 011436 2643 011443 2644 011456 2650 011457 2651 011462 2652 011466 2653 011470 2654 011472 2655 011475 2657 011477 2661 011501 2670 011503 2673 011514 2674 011516 2677 011520 2679 011526 2680 011530 2681 011541 2682 011552 2683 011563 2684 011574 2685 011605 2686 011616 2689 011630 2693 011633 2700 011635 2702 011641 2707 011646 2708 011652 2709 011655 2710 011656 2712 011664 2713 011665 2714 011670 2715 011701 2716 011712 2717 011723 2718 011734 2719 011745 2720 011756 2726 011757 2729 011771 2732 011772 2734 011776 2736 012000 2741 012021 2742 012032 2743 012043 2744 012054 2746 012065 2748 012066 2752 012071 2785 012072 2787 012075 2789 012077 2791 012104 2792 012115 2793 012120 2794 012122 2796 012124 2797 012125 2799 012126 2803 012127 2805 012133 2809 012134 2811 012140 2812 012144 2815 012145 2819 012151 2820 012161 2821 012164 2823 012170 2824 012175 2826 012201 2827 012206 2829 012207 2830 012216 2832 012220 2833 012225 2834 012227 2836 012232 2837 012234 2838 012240 2839 012242 2840 012244 2842 012247 2843 012251 2845 012254 2847 012257 2848 012261 2850 012263 2854 012265 2855 012274 2857 012303 2858 012307 2860 012315 2861 012317 2862 012321 2863 012323 2865 012325 7638 012327 2867 012330 2878 012332 2880 012335 2881 012337 2882 012341 2883 012343 2885 012344 2891 012346 2895 012356 2897 012361 2898 012370 2903 012375 2905 012405 2910 012415 2913 012424 2915 012426 2920 012432 2923 012440 2925 012443 2928 012452 2929 012457 2934 012461 2935 012463 2937 012466 2939 012467 2941 012473 2943 012474 2950 012475 2952 012501 2956 012503 2957 012512 2958 012516 2960 012521 2965 012524 2966 012526 2967 012534 2968 012537 2969 012542 2972 012545 2973 012555 2976 012560 2977 012563 2981 012566 2982 012574 2983 012577 2985 012606 2986 012610 2988 012612 2989 012614 2991 012617 2994 012622 2996 012626 2998 012627 3000 012630 3009 012631 3011 012645 3013 012647 3014 012651 3018 012652 3020 012656 3021 012662 3022 012664 3024 012667 3029 012672 3031 012702 3036 012711 3038 012713 3043 012717 3044 012720 3045 012721 3048 012722 3053 012725 3056 012733 3058 012737 3061 012750 3062 012756 3067 012760 3069 012763 3073 012764 3076 012767 3080 012773 3082 012774 3085 012775 3087 012776 3092 012777 3093 013001 3094 013004 3095 013006 3096 013013 3097 013020 3098 013024 3100 013027 3102 013030 3113 013031 3114 013040 3115 013050 3119 013054 3124 013063 3126 013067 3128 013071 3132 013075 3142 013100 3144 013105 3145 013114 3147 013116 3148 013121 3149 013124 3155 013151 3156 013157 3158 013162 3162 013164 3168 013177 3170 013203 3171 013216 3174 013217 3175 013223 3177 013224 3178 013236 3180 013245 3182 013250 3186 013254 3188 013255 3198 013256 3200 013260 3201 013265 3202 013274 3203 013277 3204 013305 3205 013310 3207 013312 3209 013315 3211 013317 3212 013323 3213 013332 3214 013335 3215 013343 3216 013346 3218 013350 3222 013353 3223 013355 3224 013357 3225 013361 3229 013363 3230 013370 3234 013372 3235 013377 3237 013401 3238 013410 3239 013413 3240 013416 3242 013430 3243 013432 3245 013435 3247 013441 3248 013444 3250 013452 3251 013454 3252 013457 3253 013461 3254 013462 3258 013464 3262 013470 3264 013472 3268 013474 3270 013502 3274 013507 3276 013511 3278 013517 3284 013521 3286 013531 3288 013532 3298 013533 3302 013536 3303 013540 3304 013542 3306 013545 3311 013552 3312 013554 3314 013556 3315 013564 3316 013566 3318 013571 3320 013574 3321 013577 3324 013611 3325 013613 3326 013624 3327 013632 3328 013634 3331 013637 3332 013642 3334 013645 3335 013650 3337 013653 3338 013660 3339 013662 3341 013665 3343 013670 3344 013672 3345 013703 3346 013711 3347 013713 3351 013722 3352 013725 3354 013730 3358 013731 3359 013734 3360 013737 3361 013742 3365 013745 3366 013750 3367 013752 3372 013757 3373 013763 3374 013767 3375 013772 3376 013776 3377 014000 3378 014004 3379 014006 3380 014012 3382 014014 3384 014016 3385 014024 3386 014031 3387 014037 3391 014042 3393 014046 3395 014050 3396 014052 3397 014062 3398 014067 3399 014071 3401 014074 3402 014076 3403 014101 3406 014104 3408 014105 3417 014107 3419 014113 3420 014115 3421 014122 3423 014127 3425 014131 3429 014133 3452 014135 3453 014140 3454 014144 3456 014146 3459 014153 3463 014156 3466 014164 3468 014166 3469 014172 3472 014176 3474 014205 3478 014212 3479 014222 3481 014225 3485 014227 3486 014233 3487 014235 3488 014242 3490 014247 3491 014251 3492 014257 3493 014261 3494 014262 3495 014264 3496 014265 3498 014267 3502 014275 3504 014277 3505 014303 3508 014307 3511 014315 3517 014316 3518 014321 3519 014330 3520 014332 3522 014342 3526 014343 3528 014351 3530 014364 3531 014366 3532 014367 3536 014370 3538 014402 3539 014404 3541 014407 3542 014415 3543 014417 3544 014422 3545 014425 3547 014427 3548 014431 3549 014434 3551 014435 3552 014437 3557 014440 3558 014444 3559 014446 3560 014447 3562 014451 3563 014463 3565 014466 3567 014467 3569 014471 3571 014476 3573 014507 3575 014514 3577 014515 3579 014517 3580 014523 3582 014527 3583 014533 3584 014536 3585 014537 3586 014544 3589 014555 3590 014557 3592 014561 3594 014562 3596 014564 3599 014607 3603 014623 3605 014634 3607 014641 3610 014642 3612 014643 3614 014647 3615 014654 3618 014665 3621 014667 3623 014670 3625 014672 3629 014700 3630 014701 3631 014705 3633 014711 3637 014715 3639 014717 3641 014722 3643 014726 3644 014732 3646 014733 3651 014747 3653 014750 3656 014757 3661 014765 3666 014777 3668 015001 3670 015004 3671 015014 3672 015017 3674 015024 3675 015026 3678 015031 3682 015034 3684 015046 3685 015051 3687 015056 3688 015060 3690 015061 3695 015064 3701 015105 3703 015115 3707 015117 3709 015122 3711 015127 3712 015133 3716 015141 3718 015145 3719 015153 3725 015170 3730 015172 3734 015174 3735 015205 3736 015210 3737 015212 3739 015213 3741 015216 3742 015220 3745 015224 3752 015225 3753 015236 3754 015241 3755 015243 3756 015244 3758 015250 3760 015256 3762 015260 3765 015264 3767 015267 3768 015271 3772 015303 3779 015307 3782 015332 3785 015335 3787 015346 3793 015347 3796 015355 3801 015366 3803 015371 3806 015404 3808 015405 3810 015417 3811 015425 3813 015427 3814 015430 3816 015431 3818 015435 3819 015436 3821 015437 3823 015444 3824 015446 3826 015447 3828 015455 3829 015462 3830 015464 3831 015466 3833 015467 3835 015501 3836 015506 3837 015510 3839 015511 3842 015513 3844 015514 3846 015521 3848 015522 3850 015531 3851 015541 3852 015547 3853 015551 3855 015552 3872 015562 3875 015565 3877 015571 4326 015574 3879 015575 3887 015577 3888 015602 3894 015605 3897 015610 3900 015617 3903 015630 3904 015637 3906 015645 3908 015647 3910 015654 3911 015656 3912 015661 3914 015670 3919 015676 3921 015702 3926 015705 3938 015707 3939 015712 3943 015715 3944 015717 3945 015721 3946 015723 3950 015726 3952 015731 3955 015742 3957 015746 3958 015750 3964 015751 3967 015762 3968 015763 3971 015764 3974 015765 3978 015767 3980 016000 3982 016004 3983 016013 3984 016015 3986 016020 3988 016030 3989 016034 3991 016037 3994 016040 3996 016043 4001 016047 4003 016053 4004 016061 4013 016106 4015 016110 4017 016116 4019 016117 4033 016121 4036 016145 4037 016151 4038 016153 4040 016157 4042 016167 4044 016176 4045 016211 4046 016214 4047 016216 4049 016220 4051 016227 4054 016233 4058 016235 4068 016237 4070 016242 4071 016247 4076 016265 4078 016267 4079 016275 4081 016301 4084 016311 4087 016317 4090 016330 4092 016334 4094 016353 4098 016372 4102 016374 4105 016402 4107 016407 4111 016411 4113 016413 4117 016417 4127 016420 4128 016423 4130 016425 4132 016432 4141 016446 4144 016502 4145 016506 4146 016510 4147 016511 4152 016530 4157 016531 4158 016534 4160 016537 4163 016544 4165 016546 4166 016557 4168 016561 4173 016565 4174 016573 4176 016605 4179 016614 4180 016617 4181 016623 4183 016624 4184 016627 4185 016634 4188 016635 4189 016642 4191 016650 4196 016652 4198 016657 4201 016670 4202 016676 4205 016677 4206 016707 4212 016717 4217 016725 4222 016736 4225 016742 4230 016762 4233 016770 4236 017011 4238 017012 4243 017033 4244 017034 4248 017035 4250 017043 4252 017045 4254 017046 4265 017050 4269 017053 4273 017056 4275 017061 4277 017066 4278 017067 4281 017070 4286 017120 4288 017121 4289 017123 4291 017124 4294 017125 4298 017132 4300 017136 4306 017144 4308 017147 4309 017151 4310 017162 4311 017165 4312 017167 4324 017170 4316 017171 4319 017172 4320 017211 4322 017217 4328 017220 4336 017222 4338 017225 4339 017237 4340 017242 4342 017243 4343 017245 4346 017261 4348 017263 4350 017264 4361 017266 4364 017277 4365 017301 4368 017303 4369 017310 4370 017312 4371 017315 4373 017317 4375 017325 4377 017326 4379 017327 4381 017330 4390 017332 4393 017343 4394 017345 4397 017347 4398 017354 4399 017357 4400 017361 4401 017364 4403 017365 4405 017366 4413 017374 4415 017377 4416 017406 4418 017416 4420 017423 4421 017426 4423 017431 4425 017432 4433 017434 4434 017437 4437 017446 4439 017452 4441 017456 4442 017465 4444 017471 4445 017473 4447 017477 4450 017500 4452 017503 4454 017507 4455 017511 4456 017516 4457 017521 4459 017534 4460 017536 4462 017537 4465 017540 4470 017543 4472 017547 4473 017551 4474 017556 4475 017561 4477 017600 4478 017602 4480 017603 4485 017604 4487 017610 4492 017612 4495 017620 4498 017624 4501 017625 4503 017626 4508 017627 4509 017631 4510 017636 4511 017641 4513 017647 4514 017651 4516 017652 4518 017653 4528 017655 4529 017660 4530 017662 4531 017665 4533 017667 4535 017676 4536 017700 4537 017704 4538 017707 4543 017756 4544 017760 4546 017761 4548 017762 4553 017764 4554 017767 4555 017771 4556 017773 4558 017777 4560 020000 4565 020002 4566 020005 4567 020007 4568 020014 4569 020017 4571 020034 4572 020036 4574 020037 4576 020040 4585 020042 4586 020044 4588 020047 4589 020056 4590 020061 4592 020064 4593 020066 4594 020070 4595 020071 4596 020072 4597 020074 4601 020102 4602 020105 4603 020106 4606 020113 4607 020115 4609 020120 4613 020142 4615 020145 4619 020153 4620 020155 4622 020157 4623 020160 4625 020165 4627 020171 4630 020223 4632 020231 4633 020234 4635 020235 4636 020237 4638 020242 4640 020246 4641 020250 4644 020253 4646 020254 4658 020256 4659 020261 4660 020266 4662 020270 4664 020303 4666 020314 4668 020316 4671 020322 4672 020325 4675 020333 4713 020335 4678 020336 4685 020340 4687 020342 4689 020344 4692 020353 4695 020365 4697 020374 4698 020400 4699 020403 4700 020405 4701 020415 4702 020416 4704 020420 4705 020422 4706 020426 4707 020431 4711 020432 4715 020433 4723 020435 4724 020442 4726 020443 4731 020445 4733 020451 4736 020454 4743 020474 4745 020510 4747 020513 4749 020515 4750 020521 4751 020530 4752 020533 4753 020541 4754 020547 4755 020552 4759 020554 4761 020563 4762 020567 4763 020576 4764 020601 4765 020607 4767 020615 4768 020620 4773 020622 4774 020625 4775 020627 4777 020632 4778 020642 4779 020644 4780 020647 4781 020652 4782 020653 4783 020655 4784 020657 4787 020662 4789 020671 4792 020674 4794 020675 4806 020677 4807 020702 4809 020704 4811 020711 4812 020715 4815 020716 4818 020722 4820 020724 4822 020727 4824 020731 4825 020735 4826 020744 4828 020746 4831 020764 4832 020767 4834 020771 4837 020772 4839 020773 4840 021000 4845 021002 4850 021007 4852 021012 4854 021017 4855 021022 4857 021023 4860 021026 4862 021031 4863 021033 4864 021044 4865 021052 4866 021054 4869 021057 4872 021061 4874 021062 4877 021070 4879 021071 4892 021073 4893 021100 4896 021104 4898 021122 4900 021127 4902 021133 4903 021135 4904 021141 4905 021150 4906 021153 4907 021161 4908 021167 4909 021172 4910 021174 4911 021177 4914 021200 4916 021202 4917 021207 4918 021216 4920 021227 4921 021232 4922 021235 4924 021243 4925 021246 4927 021250 4930 021253 4932 021255 4934 021256 4945 021260 4947 021265 4948 021270 4950 021272 4951 021300 4952 021302 4954 021313 4956 021316 4959 021323 4961 021324 4970 021326 4971 021333 4972 021342 4973 021344 4974 021352 4975 021355 4977 021357 4980 021366 4982 021372 4984 021373 4993 021375 4995 021400 4996 021406 4998 021410 5000 021417 5001 021421 5002 021430 5003 021432 5005 021435 5007 021441 5008 021443 5011 021446 5013 021452 5018 021455 5020 021461 5021 021463 5022 021465 5025 021470 5027 021471 5036 021473 5038 021476 5040 021504 5042 021512 5044 021515 5046 021520 5047 021530 5050 021533 5051 021535 5053 021536 5055 021540 5057 021541 5063 021543 5066 021554 5067 021556 5070 021560 5071 021563 5072 021567 5074 021574 5075 021575 5079 021577 5088 021605 5090 021611 5092 021617 5094 021622 5097 021630 5098 021632 5099 021634 5102 021643 5103 021645 5104 021647 5106 021650 5108 021651 5110 021652 5118 021654 5121 021665 5122 021667 5125 021671 5126 021675 5127 021677 5129 021704 5131 021705 5135 021707 5149 021711 5151 021714 5152 021717 5153 021731 5154 021734 5156 021736 5158 021742 5159 021750 5161 021753 5165 021760 5176 021762 5177 021765 5178 021770 5179 021773 5181 021776 5185 022013 5189 022021 5190 022026 5191 022031 5192 022033 5193 022035 5194 022040 5195 022042 5196 022044 5200 022045 5201 022050 5202 022055 5204 022060 5208 022071 5210 022075 5211 022103 5213 022116 5214 022123 5215 022130 5216 022135 5220 022157 5221 022171 5222 022174 5224 022175 5226 022177 5229 022222 5230 022223 5231 022230 5233 022231 5235 022234 5236 022237 5237 022244 5240 022251 5244 022253 5246 022261 5247 022263 5250 022265 5252 022266 5263 022270 5264 022277 5266 022302 5268 022314 5269 022316 5270 022320 5271 022321 5273 022325 5275 022335 5277 022344 5278 022347 5279 022352 5280 022353 5281 022357 5282 022361 5283 022363 5284 022365 5286 022370 5287 022371 5288 022377 5289 022402 5290 022410 5291 022412 5292 022416 5293 022420 5296 022422 5297 022425 5299 022427 5301 022430 5312 022436 5316 022442 5318 022445 5319 022447 5326 022456 5327 022461 5329 022462 5331 022465 5333 022476 5334 022503 5335 022505 5337 022506 5343 022522 5344 022524 5348 022526 5350 022535 5352 022536 5367 022540 5368 022543 5370 022546 5371 022550 5373 022551 5374 022553 5379 022567 5380 022601 5381 022604 5383 022605 5385 022607 5388 022621 5391 022622 5393 022624 5395 022631 5398 022635 5401 022651 5402 022656 5404 022657 5405 022664 5410 022673 5446 022675 5412 022676 5418 022700 5424 022703 5426 022711 5428 022712 5430 022725 5432 022733 5433 022734 5435 022736 5439 022742 5442 022752 5444 022754 5448 022755 5488 022763 5492 022767 5495 022777 5499 023003 5500 023011 5501 023014 5503 023015 5505 023023 5507 023030 5508 023035 5509 023042 5511 023043 5513 023046 5517 023050 5518 023067 5519 023106 5520 023125 5521 023144 5522 023163 5524 023202 5528 023205 5530 023206 5624 023211 5630 023216 5632 023244 5634 023271 5635 023326 5637 023327 5639 023362 5641 023363 5648 023417 5650 023420 5655 023446 5657 023447 5667 023460 5669 023465 5670 023472 5671 023475 5673 023500 5675 023507 5676 023514 5678 023537 5679 023540 5680 023541 5681 023544 5682 023545 5683 023550 5685 023553 5687 023554 5690 023573 5692 023600 5694 023611 5696 023617 5700 023621 5702 023632 5711 023636 5714 023643 5715 023670 5717 023674 5718 023700 5719 023712 5720 023721 5721 023722 5722 023727 5724 023752 5725 023761 5726 024006 5728 024012 5729 024021 5730 024033 5731 024042 5732 024043 5733 024055 5734 024056 5736 024061 5737 024065 5738 024112 5740 024116 5741 024125 5742 024137 5743 024146 5744 024147 5745 024161 5746 024162 5748 024164 5749 024170 5751 024217 5752 024226 5753 024227 5755 024231 5756 024236 5758 024265 5759 024274 5760 024275 5762 024277 5763 024304 5765 024333 5766 024342 5767 024343 5769 024345 5770 024352 5772 024401 5773 024410 5774 024411 5776 024413 5777 024441 5778 024450 5779 024476 5780 024477 5781 024503 5782 024544 5784 024550 5786 024553 5788 024554 5790 024557 5792 024560 5794 024563 5796 024564 5798 024567 5800 024570 5802 024573 5804 024574 5806 024577 5808 024600 5846 024606 5848 024620 5849 024624 5850 024660 5851 024667 5852 024725 5853 024734 5854 024735 5856 024737 5858 024750 5859 024752 5861 025007 5862 025020 5863 025067 5864 025076 5865 025106 5866 025137 5867 025147 5868 025150 5870 025152 5871 025154 5872 025204 5873 025205 5875 025207 5877 025220 5878 025222 5880 025257 5881 025270 5882 025337 5883 025346 5884 025356 5885 025407 5886 025417 5887 025420 5888 025424 5893 025434 5915 025436 5916 025440 5918 025444 5919 025447