COMPILATION LISTING OF SEGMENT optimizer Compiled by: Multics PL/I Compiler, Release 32c, of June 16, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 07/31/89 1402.5 mst Mon Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 /* Modified: 15 Feb 1978 by PCK to implement options(main) and the stop statement */ 12 /* Modified 790807 by PG to remove jump_three_way */ 13 14 optimizer: proc(root); 15 16 dcl root ptr; /* points at root block node */ 17 dcl (blk,stm,p,q) ptr; 18 dcl set_level fixed bin; 19 dcl (doing_loop,inhibit_walk,state_is_discarded) bit(1) aligned; 20 dcl statement_type bit(9) aligned; 21 dcl pl1_stat_$cur_statement ptr ext static; 22 dcl pl1_stat_$stop_id bit(27) ext static; 23 dcl (ioa_,ioa_$nnl) entry options(variable), debug entry(); 24 dcl (s_list,p_list,free,freec,p_tail,freep,freep_tail,l_list) ptr int static; 25 26 dcl n fixed bin(15); 27 28 dcl 1 primary based aligned, 29 2 node_type bit(9) unaligned, 30 2 reserved bit(12) unaligned, 31 2 number fixed binary(14) unaligned, 32 2 computation ptr unaligned, 33 2 statement ptr unaligned, 34 2 last ptr unaligned, 35 2 next ptr unaligned; 36 37 dcl 1 secondary based aligned, 38 2 node_type bit(9) unaligned, 39 2 reserved bit(12) unaligned, 40 2 number fixed binary(14) unaligned, 41 2 operation ptr unaligned, 42 2 primary ptr unaligned, 43 2 last ptr unaligned, 44 2 next ptr unaligned; 45 46 dcl 1 chain based aligned, 47 2 node_type bit(9) unaligned, 48 2 reserved bit(12) unaligned, 49 2 number fixed binary(14) unaligned, 50 2 value ptr unaligned, 51 2 next ptr unaligned initial(null); 52 53 dcl (null,string,substr) builtin; 54 1 1 /****^ ********************************************************* 1 2* * * 1 3* * Copyright, (C) BULL HN Information Systems Inc., 1989 * 1 4* * * 1 5* ********************************************************* */ 1 6 1 7 /* BEGIN INCLUDE FILE ... language_utility.incl.pl1 */ 1 8 1 9 1 10 /****^ HISTORY COMMENTS: 1 11* 1) change(89-07-10,RWaters), approve(89-07-10,MCR8118), audit(89-07-19,Vu), 1 12* install(89-07-31,MR12.3-1066): 1 13* Removed the obsolete parameter source_line from the dcl of error_(). 1 14* END HISTORY COMMENTS */ 1 15 1 16 /* Modified: 6 Jun 1979 by PG to add rank and byte 1 17* * Modified: 9 Jul 1989 by RW updated the declaration of error_ 1 18* */ 1 19 1 20 declare adjust_count entry(pointer); 1 21 /* parameter 1: (input) any node pointer */ 1 22 1 23 declare bindec entry(fixed bin(31)) reducible 1 24 returns(character(12) aligned); 1 25 /* parameter 1: (input) bin value */ 1 26 /* return: (output) character value with blanks */ 1 27 1 28 declare bindec$vs entry(fixed bin(31)) reducible 1 29 returns(character(12) aligned varying); 1 30 /* parameter 1: (input) binary value */ 1 31 /* return: (output) char value without blanks */ 1 32 1 33 declare binoct entry(fixed bin(31)) reducible 1 34 returns(char(12) aligned); 1 35 /* parameter 1: (input) binary value */ 1 36 /* return: (output) char value with blanks */ 1 37 1 38 declare binary_to_octal_string entry(fixed bin(31)) reducible 1 39 returns(char(12) aligned); 1 40 /* parameter 1: (input) binary value */ 1 41 /* return: (output) right-aligned char value */ 1 42 1 43 declare binary_to_octal_var_string entry(fixed bin(31)) reducible 1 44 returns(char(12) varying aligned); 1 45 /* parameter 1: (input) binary value */ 1 46 /* returns: (output) char value without blanks */ 1 47 1 48 declare compare_expression entry(pointer,pointer) reducible 1 49 returns(bit(1) aligned); 1 50 /* parameter 1: (input) any node pointer */ 1 51 /* parameter 2: (input) any node pointer */ 1 52 /* return: (output) compare bit */ 1 53 1 54 declare constant_length entry (pointer, fixed bin (71)) 1 55 returns (bit (1) aligned); 1 56 /* parameter 1: (input) reference node pointer */ 1 57 /* parameter 2: (input) value of constant length */ 1 58 /* return: (output) "1"b if constant length */ 1 59 1 60 declare convert entry(pointer,bit(36) aligned) 1 61 returns(pointer); 1 62 /* parameter 1: (input) any node pointer */ 1 63 /* parameter 2: (input) target type */ 1 64 /* return: (output) target value tree pointer */ 1 65 1 66 declare convert$to_integer entry(pointer,bit(36)aligned) 1 67 returns(pointer); 1 68 /* parameter 1: (input) any node pointer */ 1 69 /* parameter 2: (input) target type */ 1 70 /* return: (output) target value tree pointer */ 1 71 1 72 declare convert$from_builtin entry(pointer,bit(36) aligned) 1 73 returns(pointer); 1 74 /* parameter 1: (input) any node pointer */ 1 75 /* parameter 2: (input) target type */ 1 76 /* return: (output) target value tree pointer */ 1 77 1 78 declare convert$validate entry(pointer,pointer); 1 79 /* parameter 1: (input) source value tree pointer */ 1 80 /* parameter 2: (input) target reference node pointer */ 1 81 1 82 declare convert$to_target_fb entry(pointer,pointer) 1 83 returns(pointer); 1 84 /* parameter 1: (input) source value tree pointer */ 1 85 /* parameter 2: (input) target reference node pointer */ 1 86 /* return: (output) target value tree pointer */ 1 87 1 88 declare convert$to_target entry(pointer,pointer) 1 89 returns(pointer); 1 90 /* parameter 1: (input) source value tree pointer */ 1 91 /* parameter 2: (input) target reference node pointer */ 1 92 /* return: (output) target value tree pointer */ 1 93 1 94 declare copy_expression entry(pointer unaligned) 1 95 returns(pointer); 1 96 /* parameter 1: (input) any node pointer */ 1 97 /* return: (output) any node pointer */ 1 98 1 99 declare copy_expression$copy_sons entry(pointer,pointer); 1 100 /* parameter 1: (input) father symbol node pointer */ 1 101 /* parameter 2: (input) stepfather symbol node ptr */ 1 102 1 103 declare copy_unique_expression entry(pointer) 1 104 returns(pointer); 1 105 /* parameter 1: (input) any node pointer */ 1 106 /* return: (output) any node pointer */ 1 107 1 108 declare create_array entry() 1 109 returns(pointer); 1 110 /* return: (output) array node pointer */ 1 111 1 112 declare create_block entry(bit(9) aligned,pointer) 1 113 returns(pointer); 1 114 /* parameter 1: (input) block type */ 1 115 /* parameter 2: (input) father block node pointer */ 1 116 /* return: (output) block node pointer */ 1 117 1 118 declare create_bound entry() 1 119 returns(pointer); 1 120 /* return: (output) bound node pointer */ 1 121 1 122 declare create_context entry(pointer,pointer) 1 123 returns(pointer); 1 124 /* parameter 1: (input) block node pointer */ 1 125 /* parameter 2: (input) token pointer */ 1 126 /* return: (output) context node pointer */ 1 127 1 128 declare create_cross_reference entry() 1 129 returns(pointer); 1 130 /* return: (output) cross reference node pointer */ 1 131 1 132 declare create_default entry 1 133 returns(pointer); 1 134 /* return: (output) default node pointer */ 1 135 1 136 declare create_identifier entry() 1 137 returns(pointer); 1 138 /* return: (output) token node pointer */ 1 139 1 140 declare create_label entry(pointer,pointer,bit(3) aligned) 1 141 returns(pointer); 1 142 /* parameter 1: (input) block node pointer */ 1 143 /* parameter 2: (input) token node pointer */ 1 144 /* parameter 3: (input) declare type */ 1 145 /* return: (output) label node pointer */ 1 146 1 147 declare create_list entry(fixed bin(15)) 1 148 returns(pointer); 1 149 /* parameter 1: (input) number of list elements */ 1 150 /* return: (output) list node pointer */ 1 151 1 152 declare create_operator entry(bit(9) aligned,fixed bin(15)) 1 153 returns(pointer); 1 154 /* parameter 1: (input) operator type */ 1 155 /* parameter 2: (input) number of operands */ 1 156 /* return: (output) operator node pointer */ 1 157 1 158 declare create_reference entry(pointer) 1 159 returns(pointer); 1 160 /* parameter 1: (input) symbol node pointer */ 1 161 /* return: (output) reference node pointer */ 1 162 1 163 declare create_statement entry(bit(9) aligned,pointer,pointer,bit(12) aligned) 1 164 returns(pointer); 1 165 /* parameter 1: (input) statement type */ 1 166 /* parameter 2: (input) block node pointer */ 1 167 /* parameter 3: (input) label node pointer */ 1 168 /* parameter 4: (input) conditions */ 1 169 /* return: (output) statement node pointer */ 1 170 1 171 declare create_statement$prologue entry(bit(9) aligned,pointer,pointer,bit(12) aligned) 1 172 returns(pointer); 1 173 /* parameter 1: (input) statement type */ 1 174 /* parameter 2: (input) block node pointer */ 1 175 /* parameter 3: (input) label node pointer */ 1 176 /* parameter 4: (input) conditions */ 1 177 /* return: (output) statement node pointer */ 1 178 1 179 declare create_storage entry(fixed bin(15)) 1 180 returns(pointer); 1 181 /* parameter 1: (input) number of words */ 1 182 /* return: (output) storage block pointer */ 1 183 1 184 declare create_symbol entry(pointer,pointer,bit(3) aligned) 1 185 returns(pointer); 1 186 /* parameter 1: (input) block node pointer */ 1 187 /* parameter 2: (input) token node pointer */ 1 188 /* parameter 3: (input) declare type */ 1 189 /* return: (output) symbol node pointer */ 1 190 1 191 declare create_token entry (character (*), bit (9) aligned) 1 192 returns (ptr); 1 193 /* parameter 1: (input) token string */ 1 194 /* parameter 2: (input) token type */ 1 195 /* return: (output) token node ptr */ 1 196 1 197 declare create_token$init_hash_table entry (); 1 198 1 199 declare create_token$protected entry (char (*), bit (9) aligned, bit (18) aligned) 1 200 returns (ptr); 1 201 /* parameter 1: (input) token string */ 1 202 /* parameter 2: (input) token type */ 1 203 /* parameter 3: (input) protected flag */ 1 204 /* return: (output) token node ptr */ 1 205 1 206 declare decbin entry(character(*) aligned) reducible 1 207 returns(fixed bin(31)); 1 208 /* parameter 1: (input) decimal character string */ 1 209 /* return: (output) binary value */ 1 210 1 211 declare declare_constant entry(bit(*) aligned,bit(36) aligned,fixed bin(31),fixed bin(15)) 1 212 returns(pointer); 1 213 /* parameter 1: (input) value */ 1 214 /* parameter 2: (input) type */ 1 215 /* parameter 3: (input) size */ 1 216 /* parameter 4: (input) scale */ 1 217 /* return: (output) reference node pointer */ 1 218 1 219 declare declare_constant$bit entry(bit(*) aligned) 1 220 returns(pointer); 1 221 /* parameter 1: (input) bit */ 1 222 /* return: (output) reference node pointer */ 1 223 1 224 declare declare_constant$char entry(character(*) aligned) 1 225 returns(pointer); 1 226 /* parameter 1: (input) character */ 1 227 /* return: (output) reference node pointer */ 1 228 1 229 declare declare_constant$desc entry(bit(*) aligned) 1 230 returns(pointer); 1 231 /* parameter 1: (input) descriptor bit value */ 1 232 /* return: (output) reference node pointer */ 1 233 1 234 declare declare_constant$integer entry(fixed bin(31)) /* note...should really be fixed bin(24) */ 1 235 returns(pointer); 1 236 /* parameter 1: (input) integer */ 1 237 /* return: (output) reference node pointer */ 1 238 1 239 declare declare_descriptor entry(pointer,pointer,pointer,pointer,bit(2) aligned) 1 240 returns(pointer); 1 241 /* parameter 1: (input) block node pointer */ 1 242 /* parameter 2: (input) statement node pointer */ 1 243 /* parameter 3: (input) symbol node pointer */ 1 244 /* parameter 4: (input) loc pointer */ 1 245 /* parameter 5: (input) array descriptor bit 1 246* cross_section bit */ 1 247 /* return: (output) reference node pointer */ 1 248 1 249 declare declare_descriptor$ctl entry(pointer,pointer,pointer,pointer,bit(2) aligned) 1 250 returns(pointer); 1 251 /* parameter 1: (input) block node pointer */ 1 252 /* parameter 2: (input) statement node pointer */ 1 253 /* parameter 3: (input) symbol node pointer */ 1 254 /* parameter 4: (input) loc pointer */ 1 255 /* parameter 5: (input) array descriptor bit 1 256* cross_section bit */ 1 257 /* return: (output) reference node pointer */ 1 258 1 259 declare declare_descriptor$param entry(pointer,pointer,pointer,pointer,bit(2) aligned) 1 260 returns(pointer); 1 261 /* parameter 1: (input) block node pointer */ 1 262 /* parameter 2: (input) statement node pointer */ 1 263 /* parameter 3: (input) symbol node pointer */ 1 264 /* parameter 4: (input) loc pointer */ 1 265 /* parameter 5: (input) array descriptor bit 1 266* cross_section bit */ 1 267 /* return: (output) reference node pointer */ 1 268 1 269 declare declare_integer entry(pointer) 1 270 returns(pointer); 1 271 /* parameter 1: (input) block node pointer */ 1 272 /* return: (output) reference node pointer */ 1 273 1 274 declare declare_picture entry(char(*)aligned,pointer,fixed bin(15)); 1 275 /* parameter 1: (input) picture string */ 1 276 /* parameter 2: (input) symbol node pointer */ 1 277 /* parameter 3: (output) error code, if any */ 1 278 1 279 declare declare_picture_temp entry(char(*) aligned,fixed bin(31),bit(1) aligned,bit(1) aligned) 1 280 returns(pointer); 1 281 /* parameter 1: (input) picture string */ 1 282 /* parameter 2: (input) scalefactor of picture */ 1 283 /* parameter 3: (input) ="1"b => complex picture */ 1 284 /* parameter 4: (input) ="1"b => unaligned temp */ 1 285 /* return: (output) reference node pointer */ 1 286 1 287 declare declare_pointer entry(pointer) 1 288 returns(pointer); 1 289 /* parameter 1: (input) block node pointer */ 1 290 /* return: (output) reference node pointer */ 1 291 1 292 declare declare_temporary entry(bit(36) aligned,fixed bin(31),fixed bin(15),pointer) 1 293 returns(pointer); 1 294 /* parameter 1: (input) type */ 1 295 /* parameter 2: (input) precision */ 1 296 /* parameter 3: (input) scale */ 1 297 /* parameter 4: (input) length */ 1 298 /* return: (output) reference node pointer */ 1 299 1 300 declare decode_node_id entry(pointer,bit(1) aligned) 1 301 returns(char(120) varying); 1 302 /* parameter 1: (input) node pointer */ 1 303 /* parameter 2: (input) ="1"b => capitals */ 1 304 /* return: (output) source line id */ 1 305 1 306 declare decode_source_id entry( 2 1 1 structure unaligned, 2 2 2 /* file_number */ bit(8), 2 3 2 /* line_number */ bit(14), 2 4 2 /* stmt_number */ bit(5), 1 307 1 308 bit(1) aligned) 1 309 returns(char(120) varying); 1 310 /* parameter 1: (input) source id */ 1 311 /* parameter 2: (input) ="1"b => capitals */ 1 312 /* return: (output) source line id */ 1 313 1 314 declare error entry(fixed bin(15),pointer,pointer); 1 315 /* parameter 1: (input) error number */ 1 316 /* parameter 2: (input) statement node pointer or null*/ 1 317 /* parameter 3: (input) token node pointer */ 1 318 1 319 declare error$omit_text entry(fixed bin(15),pointer,pointer); 1 320 /* parameter 1: (input) error number */ 1 321 /* parameter 2: (input) statement node pointer or null*/ 1 322 /* parameter 3: (input) token node pointer */ 1 323 1 324 declare error_ entry(fixed bin(15), 3 1 1 structure unaligned, 3 2 2 /* file_number */ bit(8), 3 3 2 /* line_number */ bit(14), 3 4 2 /* stmt_number */ bit(5), 1 325 1 326 pointer,fixed bin(8),fixed bin(23),fixed bin(11)); 1 327 /* parameter 1: (input) error number */ 1 328 /* parameter 2: (input) statement id */ 1 329 /* parameter 3: (input) any node pointer */ 1 330 /* parameter 4: (input) source segment */ 1 331 /* parameter 5: (input) source starting character */ 1 332 /* parameter 6: (input) source length */ 1 333 1 334 declare error_$no_text entry(fixed bin(15), 4 1 1 structure unaligned, 4 2 2 /* file_number */ bit(8), 4 3 2 /* line_number */ bit(14), 4 4 2 /* stmt_number */ bit(5), 1 335 1 336 pointer); 1 337 /* parameter 1: (input) error number */ 1 338 /* parameter 2: (input) statement id */ 1 339 /* parameter 3: (input) any node pointer */ 1 340 1 341 declare error_$initialize_error entry(); 1 342 1 343 declare error_$finish entry(); 1 344 1 345 declare free_node entry(pointer); 1 346 /* parameter 1: any node pointer */ 1 347 1 348 declare get_array_size entry(pointer,fixed bin(3)); 1 349 /* parameter 1: (input) symbol node pointer */ 1 350 /* parameter 2: (input) units */ 1 351 1 352 declare get_size entry(pointer); 1 353 /* parameter 1: (input) symbol node pointer */ 1 354 1 355 declare merge_attributes external entry(pointer,pointer) 1 356 returns(bit(1) aligned); 1 357 /* parameter 1: (input) target symbol node pointer */ 1 358 /* parameter 2: (input) source symbol node pointer */ 1 359 /* return: (output) "1"b if merge was unsuccessful */ 1 360 1 361 declare optimizer entry(pointer); 1 362 /* parameter 1: (input) root pointer */ 1 363 1 364 declare parse_error entry(fixed bin(15),pointer); 1 365 /* parameter 1: (input) error number */ 1 366 /* parameter 2: (input) any node pointer */ 1 367 1 368 declare parse_error$no_text entry(fixed bin(15),pointer); 1 369 /* parameter 1: (input) error number */ 1 370 /* parameter 2: (input) any node pointer */ 1 371 1 372 declare pl1_error_print$write_out 1 373 entry(fixed bin(15), 5 1 1 structure unaligned, 5 2 2 /* file_number */ bit(8), 5 3 2 /* line_number */ bit(14), 5 4 2 /* stmt_number */ bit(5), 1 374 1 375 pointer,fixed bin(11),fixed bin(31),fixed bin(31),fixed bin(15)); 1 376 /* parameter 1: (input) error number */ 1 377 /* parameter 2: (input) statement identification */ 1 378 /* parameter 3: (input) any node pointer */ 1 379 /* parameter 4: (input) source segment */ 1 380 /* parameter 5: (input) source character index */ 1 381 /* parameter 6: (input) source length */ 1 382 /* parameter 7: (input) source line */ 1 383 1 384 declare pl1_error_print$listing_segment 1 385 entry(fixed bin(15), 6 1 1 structure unaligned, 6 2 2 /* file_number */ bit(8), 6 3 2 /* line_number */ bit(14), 6 4 2 /* stmt_number */ bit(5), 1 386 1 387 pointer); 1 388 /* parameter 1: (input) error number */ 1 389 /* parameter 2: (input) statement identification */ 1 390 /* parameter 3: (input) token node pointer */ 1 391 1 392 declare pl1_print$varying entry(character(*) aligned varying); 1 393 /* parameter 1: (input) string */ 1 394 1 395 declare pl1_print$varying_nl entry(character(*) aligned varying); 1 396 /* parameter 1: (input) string */ 1 397 1 398 declare pl1_print$non_varying entry(character(*) aligned,fixed bin(31)); 1 399 /* parameter 1: (input) string */ 1 400 /* parameter 2: (input) string length or 0 */ 1 401 1 402 declare pl1_print$non_varying_nl entry(character(*) aligned,fixed bin(31)); 1 403 /* parameter 1: (input) string */ 1 404 /* parameter 2: (input) string length or 0 */ 1 405 1 406 declare pl1_print$string_pointer entry(pointer,fixed bin(31)); 1 407 /* parameter 1: (input) string pointer */ 1 408 /* parameter 2: (input) string size */ 1 409 1 410 declare pl1_print$string_pointer_nl entry(pointer,fixed bin(31)); 1 411 /* parameter 1: (input) string pointer */ 1 412 /* parameter 2: (input) string length or 0 */ 1 413 1 414 declare pl1_print$unaligned_nl entry(character(*) unaligned,fixed bin(31)); 1 415 /* parameter 1: (input) string */ 1 416 /* parameter 2: (input) length */ 1 417 1 418 declare pl1_print$for_lex entry (ptr, fixed bin (14), fixed bin (21), fixed bin (21), bit (1) aligned, bit (1) aligned); 1 419 /* parameter 1: (input) ptr to base of source segment */ 1 420 /* parameter 2: (input) line number */ 1 421 /* parameter 3: (input) starting offset in source seg */ 1 422 /* parameter 4: (input) number of chars to copy */ 1 423 /* parameter 5: (input) ON iff shd print line number */ 1 424 /* parameter 6: (input) ON iff line begins in comment */ 1 425 1 426 declare refer_extent entry(pointer,pointer); 1 427 /* parameter 1: (input/output) null,ref node,op node pointer */ 1 428 /* parameter 2: (input) null,ref node,op node pointer */ 1 429 1 430 declare reserve$clear entry() 1 431 returns(pointer); 1 432 /* return: (output) pointer */ 1 433 1 434 declare reserve$declare_lib entry(fixed bin(15)) 1 435 returns(pointer); 1 436 /* parameter 1: (input) builtin function number */ 1 437 /* return: (output) pointer */ 1 438 1 439 declare reserve$read_lib entry(fixed bin(15)) 1 440 returns(pointer); 1 441 /* parameter 1: (input) builtin function number */ 1 442 /* return: (output) pointer */ 1 443 1 444 declare semantic_translator entry(); 1 445 1 446 declare semantic_translator$abort entry(fixed bin(15),pointer); 1 447 /* parameter 1: (input) error number */ 1 448 /* parameter 2: (input) any node pointer */ 1 449 1 450 declare semantic_translator$error entry(fixed bin(15),pointer); 1 451 /* parameter 1: (input) error number */ 1 452 /* parameter 2: (input) any node pointer */ 1 453 1 454 declare share_expression entry(ptr) 1 455 returns(ptr); 1 456 /* parameter 1: (input) usually operator node pointer */ 1 457 /* return: (output) tree pointer or null */ 1 458 1 459 declare token_to_binary entry(ptr) reducible 1 460 returns(fixed bin(31)); 1 461 /* parameter 1: (input) token node pointer */ 1 462 /* return: (output) converted binary value */ 1 463 1 464 /* END INCLUDE FILE ... language_utility.incl.pl1 */ 55 7 1 /* BEGIN INCLUDE FILE ... block.incl.pl1 */ 7 2 /* Modified 22 Ocober 1980 by M. N. Davidoff to increase max block.number to 511 */ 7 3 /* format: style3,idind30 */ 7 4 7 5 declare 1 block aligned based, 7 6 2 node_type bit (9) unaligned, 7 7 2 source_id structure unaligned, 7 8 3 file_number bit (8), 7 9 3 line_number bit (14), 7 10 3 statement_number bit (5), 7 11 2 father ptr unaligned, 7 12 2 brother ptr unaligned, 7 13 2 son ptr unaligned, 7 14 2 declaration ptr unaligned, 7 15 2 end_declaration ptr unaligned, 7 16 2 default ptr unaligned, 7 17 2 end_default ptr unaligned, 7 18 2 context ptr unaligned, 7 19 2 prologue ptr unaligned, 7 20 2 end_prologue ptr unaligned, 7 21 2 main ptr unaligned, 7 22 2 end_main ptr unaligned, 7 23 2 return_values ptr unaligned, 7 24 2 return_count ptr unaligned, 7 25 2 plio_ps ptr unaligned, 7 26 2 plio_fa ptr unaligned, 7 27 2 plio_ffsb ptr unaligned, 7 28 2 plio_ssl ptr unaligned, 7 29 2 plio_fab2 ptr unaligned, 7 30 2 block_type bit (9) unaligned, 7 31 2 prefix bit (12) unaligned, 7 32 2 like_attribute bit (1) unaligned, 7 33 2 no_stack bit (1) unaligned, 7 34 2 get_data bit (1) unaligned, 7 35 2 flush_at_call bit (1) unaligned, 7 36 2 processed bit (1) unaligned, 7 37 2 text_displayed bit (1) unaligned, 7 38 2 number fixed bin (9) unsigned unaligned, 7 39 2 free_temps dimension (3) ptr, /* these fields are used by the code generator */ 7 40 2 temp_list ptr, 7 41 2 entry_list ptr, 7 42 2 o_and_s ptr, 7 43 2 why_nonquick aligned, 7 44 3 auto_adjustable_storage bit (1) unaligned, 7 45 3 returns_star_extents bit (1) unaligned, 7 46 3 stack_extended_by_args bit (1) unaligned, 7 47 3 invoked_by_format bit (1) unaligned, 7 48 3 format_statement bit (1) unaligned, 7 49 3 io_statements bit (1) unaligned, 7 50 3 assigned_to_entry_var bit (1) unaligned, 7 51 3 condition_statements bit (1) unaligned, 7 52 3 no_owner bit (1) unaligned, 7 53 3 recursive_call bit (1) unaligned, 7 54 3 options_non_quick bit (1) unaligned, 7 55 3 options_variable bit (1) unaligned, 7 56 3 never_referenced bit (1) unaligned, 7 57 3 pad_nonquick bit (5) unaligned, 7 58 2 prologue_flag bit (1) unaligned, 7 59 2 options_main bit (1) unaligned, 7 60 2 pad bit (16) unaligned, 7 61 2 number_of_entries fixed bin (17), 7 62 2 level fixed bin (17), 7 63 2 last_auto_loc fixed bin (17), 7 64 2 symbol_block fixed bin (17), 7 65 2 entry_info fixed bin (18), 7 66 2 enter structure unaligned, 7 67 3 start fixed bin (17), 7 68 3 end fixed bin (17), 7 69 2 leave structure unaligned, 7 70 3 start fixed bin (17), 7 71 3 end fixed bin (17), 7 72 2 owner ptr; 7 73 7 74 declare max_block_number fixed bin internal static options (constant) initial (511); 7 75 7 76 /* END INCLUDE FILE ... block.incl.pl1 */ 56 8 1 /* *********************************************************** 8 2* * * 8 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 8 4* * * 8 5* *********************************************************** */ 8 6 /* BEGIN INCLUDE FILE ... statement.incl.pl1 */ 8 7 /* Internal interface of the PL/I compiler */ 8 8 8 9 dcl 1 statement based aligned, 8 10 2 node_type bit(9) unaligned, 8 11 2 source_id structure unaligned, 8 12 3 file_number bit(8), 8 13 3 line_number bit(14), 8 14 3 statement_number bit(5), 8 15 2 next ptr unaligned, 8 16 2 back ptr unaligned, 8 17 2 root ptr unaligned, 8 18 2 labels ptr unaligned, 8 19 2 reference_list ptr unaligned, 8 20 2 state_list ptr unaligned, 8 21 2 reference_count fixed(17) unaligned, 8 22 2 ref_count_copy fixed(17) unaligned, 8 23 2 object structure unaligned, 8 24 3 start fixed(17), 8 25 3 finish fixed(17), 8 26 2 source structure unaligned, 8 27 3 segment fixed(11), 8 28 3 start fixed(23), 8 29 3 length fixed(11), 8 30 2 prefix bit(12) unaligned, 8 31 2 optimized bit(1) unaligned, 8 32 2 free_temps bit(1) unaligned, 8 33 2 LHS_in_RHS bit(1) unaligned, 8 34 2 statement_type bit(9) unaligned, 8 35 2 bits structure unaligned, 8 36 3 processed bit(1) unaligned, 8 37 3 put_in_profile bit(1) unaligned, 8 38 3 generated bit(1) unaligned, 8 39 3 snap bit(1) unaligned, 8 40 3 system bit(1) unaligned, 8 41 3 irreducible bit(1) unaligned, 8 42 3 checked bit(1) unaligned, 8 43 3 save_temps bit(1) unaligned, 8 44 3 suppress_warnings bit(1) unaligned, 8 45 3 force_nonquick bit(1) unaligned, 8 46 3 expanded_by_name bit(1) unaligned, 8 47 3 begins_loop bit(1) unaligned, 8 48 3 pad bit(24) unaligned; 8 49 8 50 /* END INCLUDE FILE ... statement.incl.pl1 */ 57 9 1 /* BEGIN INCLUDE FILE ... operator.incl.pl1 */ 9 2 9 3 /* Modified: 2 Apr 1980 by PCK to add max_number_of_operands */ 9 4 9 5 /* format: style3 */ 9 6 dcl 1 operator based aligned, 9 7 2 node_type bit (9) unaligned, 9 8 2 op_code bit (9) unaligned, 9 9 2 shared bit (1) unaligned, 9 10 2 processed bit (1) unaligned, 9 11 2 optimized bit (1) unaligned, 9 12 2 number fixed (14) unaligned, 9 13 2 operand dimension (n refer (operator.number)) ptr unaligned; 9 14 9 15 dcl max_number_of_operands 9 16 fixed bin (15) int static options (constant) initial (32767); 9 17 9 18 /* END INCLUDE FILE ... operator.incl.pl1 */ 58 10 1 /* BEGIN INCLUDE FILE ... symbol.incl.pl1 */ 10 2 10 3 dcl 1 symbol based aligned, 10 4 2 node_type bit(9) unal, 10 5 2 source_id structure unal, 10 6 3 file_number bit(8), 10 7 3 line_number bit(14), 10 8 3 statement_number bit(5), 10 9 2 location fixed(18) unal unsigned, 10 10 2 allocated bit(1) unal, 10 11 2 dcl_type bit(3) unal, 10 12 2 reserved bit(6) unal, 10 13 2 pix unal, 10 14 3 pic_fixed bit(1) unal, 10 15 3 pic_float bit(1) unal, 10 16 3 pic_char bit(1) unal, 10 17 3 pic_scale fixed(7) unal, 10 18 3 pic_size fixed(7) unal, 10 19 2 level fixed(8) unal, 10 20 2 boundary fixed(3) unal, 10 21 2 size_units fixed(3) unal, 10 22 2 scale fixed(7) unal, 10 23 2 runtime bit(18) unal, 10 24 2 runtime_offset bit(18) unal, 10 25 2 block_node ptr unal, 10 26 2 token ptr unal, 10 27 2 next ptr unal, 10 28 2 multi_use ptr unal, 10 29 2 cross_references ptr unal, 10 30 2 initial ptr unal, 10 31 2 array ptr unal, 10 32 2 descriptor ptr unal, 10 33 2 equivalence ptr unal, 10 34 2 reference ptr unal, 10 35 2 general ptr unal, 10 36 2 father ptr unal, 10 37 2 brother ptr unal, 10 38 2 son ptr unal, 10 39 2 word_size ptr unal, 10 40 2 bit_size ptr unal, 10 41 2 dcl_size ptr unal, 10 42 2 symtab_size ptr unal, 10 43 2 c_word_size fixed(24), 10 44 2 c_bit_size fixed(24), 10 45 2 c_dcl_size fixed(24), 10 46 10 47 2 attributes structure aligned, 10 48 3 data_type structure unal, 10 49 4 structure bit(1) , 10 50 4 fixed bit(1), 10 51 4 float bit(1), 10 52 4 bit bit(1), 10 53 4 char bit(1), 10 54 4 ptr bit(1), 10 55 4 offset bit(1), 10 56 4 area bit(1), 10 57 4 label bit(1), 10 58 4 entry bit(1), 10 59 4 file bit(1), 10 60 4 arg_descriptor bit(1), 10 61 4 storage_block bit(1), 10 62 4 explicit_packed bit(1), /* options(packed) */ 10 63 4 condition bit(1), 10 64 4 format bit(1), 10 65 4 builtin bit(1), 10 66 4 generic bit(1), 10 67 4 picture bit(1), 10 68 10 69 3 misc_attributes structure unal, 10 70 4 dimensioned bit(1), 10 71 4 initialed bit(1), 10 72 4 aligned bit(1), 10 73 4 unaligned bit(1), 10 74 4 signed bit(1), 10 75 4 unsigned bit(1), 10 76 4 precision bit(1), 10 77 4 varying bit(1), 10 78 4 local bit(1), 10 79 4 decimal bit(1), 10 80 4 binary bit(1), 10 81 4 real bit(1), 10 82 4 complex bit(1), 10 83 4 variable bit(1), 10 84 4 reducible bit(1), 10 85 4 irreducible bit(1), 10 86 4 returns bit(1), 10 87 4 position bit(1), 10 88 4 internal bit(1), 10 89 4 external bit(1), 10 90 4 like bit(1), 10 91 4 member bit(1), 10 92 4 non_varying bit(1), 10 93 4 options bit(1), 10 94 4 variable_arg_list bit(1), /* options(variable) */ 10 95 4 alloc_in_text bit(1), /* options(constant) */ 10 96 10 97 3 storage_class structure unal, 10 98 4 auto bit(1), 10 99 4 based bit(1), 10 100 4 static bit(1), 10 101 4 controlled bit(1), 10 102 4 defined bit(1), 10 103 4 parameter bit(1), 10 104 4 param_desc bit(1), 10 105 4 constant bit(1), 10 106 4 temporary bit(1), 10 107 4 return_value bit(1), 10 108 10 109 3 file_attributes structure unal, 10 110 4 print bit(1), 10 111 4 input bit(1), 10 112 4 output bit(1), 10 113 4 update bit(1), 10 114 4 stream bit(1), 10 115 4 reserved_1 bit(1), 10 116 4 record bit(1), 10 117 4 sequential bit(1), 10 118 4 direct bit(1), 10 119 4 interactive bit(1), /* env(interactive) */ 10 120 4 reserved_2 bit(1), 10 121 4 reserved_3 bit(1), 10 122 4 stringvalue bit(1), /* env(stringvalue) */ 10 123 4 keyed bit(1), 10 124 4 reserved_4 bit(1), 10 125 4 environment bit(1), 10 126 10 127 3 compiler_developed structure unal, 10 128 4 aliasable bit(1), 10 129 4 packed bit(1), 10 130 4 passed_as_arg bit(1), 10 131 4 allocate bit(1), 10 132 4 set bit(1), 10 133 4 exp_extents bit(1), 10 134 4 refer_extents bit(1), 10 135 4 star_extents bit(1), 10 136 4 isub bit(1), 10 137 4 put_in_symtab bit(1), 10 138 4 contiguous bit(1), 10 139 4 put_data bit(1), 10 140 4 overlayed bit(1), 10 141 4 error bit(1), 10 142 4 symtab_processed bit(1), 10 143 4 overlayed_by_builtin bit(1), 10 144 4 defaulted bit(1), 10 145 4 connected bit(1); 10 146 10 147 /* END INCLUDE FILE ... symbol.incl.pl1 */ 59 11 1 /* BEGIN INCLUDE FILE ... boundary.incl.pl1 */ 11 2 11 3 /* Modified: 26 Apr 1979 by PCK to implement 4-bit decimal */ 11 4 11 5 dcl ( bit_ init(1), 11 6 digit_ init(2), 11 7 character_ init(3), 11 8 half_ init(4), 11 9 word_ init(5), 11 10 mod2_ init(6), 11 11 mod4_ init(7)) fixed bin(3) int static options(constant); 11 12 11 13 /* END INCLUDE FILE ... boundary.incl.pl1 */ 60 12 1 dcl 1 label based aligned, 12 2 2 node_type bit(9) unaligned, 12 3 2 source_id structure unaligned, 12 4 3 file_number bit(8), 12 5 3 line_number bit(14), 12 6 3 statement_number bit(5), 12 7 2 location fixed(17) unaligned, 12 8 2 allocated bit(1) unaligned, 12 9 2 dcl_type bit(3) unaligned, 12 10 2 reserved bit(29) unaligned, 12 11 2 array bit(1) unaligned, 12 12 2 used_as_format bit(1) unaligned, 12 13 2 used_in_goto bit(1) unaligned, 12 14 2 symbol_table bit(18) unaligned, 12 15 2 low_bound fixed(17) unaligned, 12 16 2 high_bound fixed(17) unaligned, 12 17 2 block_node ptr unaligned, 12 18 2 token ptr unaligned, 12 19 2 next ptr unaligned, 12 20 2 multi_use ptr unaligned, 12 21 2 cross_reference ptr unaligned, 12 22 2 statement ptr unaligned; 61 13 1 /* BEGIN INCLUDE FILE ... list.incl.pl1 */ 13 2 13 3 /* Modified 26 June 81 by EBush to add max_list_elements */ 13 4 13 5 13 6 dcl 1 list based aligned, 13 7 2 node_type bit(9) unaligned, 13 8 2 reserved bit(12) unaligned, 13 9 2 number fixed(14) unaligned, 13 10 2 element dimension(n refer(list.number)) ptr unaligned; 13 11 13 12 dcl max_list_elements fixed bin(17) internal static options (constant) 13 13 init(16383); 13 14 13 15 /* END INCLUDE FILE ... list.incl.pl1 */ 62 14 1 /* BEGIN INCLUDE FILE ... reference.incl.pl1 */ 14 2 14 3 dcl 1 reference based aligned, 14 4 2 node_type bit(9) unaligned, 14 5 2 array_ref bit(1) unaligned, 14 6 2 varying_ref bit(1) unaligned, 14 7 2 shared bit(1) unaligned, 14 8 2 put_data_sw bit(1) unaligned, 14 9 2 processed bit(1) unaligned, 14 10 2 units fixed(3) unaligned, 14 11 2 ref_count fixed(17) unaligned, 14 12 2 c_offset fixed(24), 14 13 2 c_length fixed(24), 14 14 2 symbol ptr unaligned, 14 15 2 qualifier ptr unaligned, 14 16 2 offset ptr unaligned, 14 17 2 length ptr unaligned, 14 18 2 subscript_list ptr unaligned, 14 19 /* these fields are used by the 645 code generator */ 14 20 2 address structure unaligned, 14 21 3 base bit(3), 14 22 3 offset bit(15), 14 23 3 op bit(9), 14 24 3 no_address bit(1), 14 25 3 inhibit bit(1), 14 26 3 ext_base bit(1), 14 27 3 tag bit(6), 14 28 2 info structure unaligned, 14 29 3 address_in structure, 14 30 4 b dimension(0:7) bit(1), 14 31 4 storage bit(1), 14 32 3 value_in structure, 14 33 4 a bit(1), 14 34 4 q bit(1), 14 35 4 aq bit(1), 14 36 4 string_aq bit(1), 14 37 4 complex_aq bit(1), 14 38 4 decimal_aq bit(1), 14 39 4 b dimension(0:7) bit(1), 14 40 4 storage bit(1), 14 41 4 indicators bit(1), 14 42 4 x dimension(0:7) bit(1), 14 43 3 other structure, 14 44 4 big_offset bit(1), 14 45 4 big_length bit(1), 14 46 4 modword_in_offset bit(1), 14 47 2 data_type fixed(5) unaligned, 14 48 2 bits structure unaligned, 14 49 3 padded_ref bit(1), 14 50 3 aligned_ref bit(1), 14 51 3 long_ref bit(1), 14 52 3 forward_ref bit(1), 14 53 3 ic_ref bit(1), 14 54 3 temp_ref bit(1), 14 55 3 defined_ref bit(1), 14 56 3 evaluated bit(1), 14 57 3 allocate bit(1), 14 58 3 allocated bit(1), 14 59 3 aliasable bit(1), 14 60 3 even bit(1), 14 61 3 perm_address bit(1), 14 62 3 aggregate bit(1), 14 63 3 hit_zero bit(1), 14 64 3 dont_save bit(1), 14 65 3 fo_in_qual bit(1), 14 66 3 hard_to_load bit(1), 14 67 2 relocation bit(12) unaligned, 14 68 2 more_bits structure unaligned, 14 69 3 substr bit(1), 14 70 3 padded_for_store_ref bit(1), 14 71 3 aligned_for_store_ref bit(1), 14 72 3 mbz bit(15), 14 73 2 store_ins bit(18) unaligned; 14 74 14 75 /* END INCLUDE FILE ... reference.incl.pl1 */ 63 15 1 /* BEGIN INCLUDE FILE ... op_codes.incl.pl1 */ 15 2 15 3 /* Modified: 25 Apr 1979 by PCK 4-bit decimal */ 15 4 /* Modified: 6 Jun 1979 by PG to add rank and byte */ 15 5 /* Modified: 26 Dec 1979 by PCK to add assign_by_name */ 15 6 /* Modified: 26 July 82 BIM wordno, segno */ 15 7 15 8 dcl ( add initial("000010001"b), /* opnd(1) <- opnd(2)+opnd(3) */ 15 9 sub initial("000010010"b), /* opnd(1) <- opnd(2)-opnd(3) */ 15 10 mult initial("000010011"b), /* opnd(1) <- opnd(2)*opnd(3) */ 15 11 div initial("000010100"b), /* opnd(1) <- opnd(2)/opnd(3) */ 15 12 negate initial("000010101"b), /* opnd(1) <- -opnd(2) */ 15 13 exp initial("000010110"b), /* opnd(1) <- opnd(2) ** opnd(3) */ 15 14 15 15 and_bits initial("000100001"b), /* opnd(1) <- opnd(2) & opnd(3) */ 15 16 or_bits initial("000100010"b), /* opnd(1) <- opnd(2)|opnd(3) */ 15 17 xor_bits initial("000100011"b), /* opnd(1) <- opnd(2) xor opnd(3) */ 15 18 not_bits initial("000100100"b), /* opnd(1) <- ^opnd(2) */ 15 19 cat_string initial("000100101"b), /* opnd(1) <- opnd(2)||opnd(3) */ 15 20 bool_fun initial("000100110"b), /* opnd(1) <- bool(opnd(2),opnd(3),opnd(4)) */ 15 21 15 22 assign initial("000110001"b), /* opnd(1) <- opnd(2) */ 15 23 assign_size_ck initial("000110010"b), /* opnd(1) <- opnd(2) */ 15 24 assign_zero initial("000110011"b), /* opnd(1) <- 0 */ 15 25 copy_words initial("000110100"b), /* move opnd(2) to opnd(1) by opnd(3) words */ 15 26 copy_string initial("000110101"b), /* move opnd(2) to opnd(1) by opnd(3) units */ 15 27 make_desc initial("000110110"b), /* opnd(1) <- descriptor(opnd(2),opnd(3)) */ 15 28 assign_round initial("000110111"b), /* opnd(1) <- opnd(2) rounded */ 15 29 pack initial("000111000"b), /* opnd(1) <- encode to picture opnd(2) */ 15 30 unpack initial("000111001"b), /* opnd(1) <- decode from picture opnd(2) */ 15 31 15 32 less_than initial("001000100"b), /* opnd(1) <- opnd(2) < opnd(3) */ 15 33 greater_than initial("001000101"b), /* opnd(1) <- opnd(2) > opnd(3) */ 15 34 equal initial("001000110"b), /* opnd(1) <- opnd(2) = opnd(3) */ 15 35 not_equal initial("001000111"b), /* opnd(1) <- opnd(2) ^= opnd(3) */ 15 36 less_or_equal initial("001001000"b), /* opnd(1) <- opnd(2) <= opnd(3) */ 15 37 greater_or_equal initial("001001001"b), /* opnd(1) <- opnd(2) >= opnd(3) */ 15 38 15 39 jump initial("001010001"b), /* go to opnd(1) unconditionally */ 15 40 jump_true initial("001010010"b), /* go to opnd(1) if opnd(2) is not 0 */ 15 41 jump_false initial("001010011"b), /* go to opnd(1) if opnd(2) is all 0 */ 15 42 jump_if_lt initial("001010100"b), /* go to opnd(1) if opnd(2) < opnd(3) */ 15 43 jump_if_gt initial("001010101"b), /* go to opnd(1) if opnd(2) > opnd(3) */ 15 44 jump_if_eq initial("001010110"b), /* go to opnd(1) if opnd(2) = opnd(3) */ 15 45 jump_if_ne initial("001010111"b), /* go to opnd(1) if opnd(2) ^= opnd(3) */ 15 46 jump_if_le initial("001011000"b), /* go to opnd(1) if opnd(2) <= opnd(3) */ 15 47 jump_if_ge initial("001011001"b), /* go to opnd(1) if opnd(2) >= opnd(3) */ 15 48 15 49 std_arg_list initial("001100001"b), /* opnd(1) <- arglist(opnd(2) desclist(opnd(3))) */ 15 50 return_words initial("001100010"b), /* return aggregate opnd(1), opnd(2) is length in words */ 15 51 std_call initial("001100011"b), /* opnd(1) <- call opnd(2) with opnd(3) */ 15 52 return_bits initial("001100100"b), /* return aggregate opnd(1), opnd(2) is length in bits */ 15 53 std_entry initial("001100101"b), /* entry(opnd(1)... opnd(n)) */ 15 54 return_string initial("001100110"b), /* return string opnd(1) */ 15 55 ex_prologue initial("001100111"b), /* execute the prologue -no operands- */ 15 56 allot_auto initial("001101000"b), /* opnd(1) <- addrel(stack,opnd(2)) */ 15 57 param_ptr initial("001101001"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 15 58 param_desc_ptr initial("001101010"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 15 59 std_return initial("001101011"b), /* return -no arguments- */ 15 60 allot_ctl initial("001101100"b), /* allocate opnd(1) , length in words is opnd(2) */ 15 61 free_ctl initial("001101101"b), /* free opnd(1) */ 15 62 stop initial("001101110"b), /* stop - terminate run unit */ 15 63 15 64 mod_bit initial("001110000"b), /* opnd(1) <- mod(opnd(3),36), 15 65* opnd(2) <- opnd(3) / 36 */ 15 66 mod_byte initial("001110001"b), /* opnd(1) <- mod(opnd(3),4), 15 67* opnd(2) <- opnd(3) / 4 */ 15 68 mod_half initial("001110010"b), /* opnd(1) <- mod(opnd(3),2), 15 69* opnd(2) <- opnd(3) / 2 */ 15 70 mod_word initial("001110011"b), /* TO BE DEFINED BY BLW */ 15 71 15 72 bit_to_char initial("010000000"b), /* opnd(1) <- (opnd(2)+8)/9 */ 15 73 bit_to_word initial("010000001"b), /* opnd(1) <- (opnd(2)+35)/36 */ 15 74 char_to_word initial("010000010"b), /* opnd(1) <- (opnd(2)+3)/4 */ 15 75 half_to_word initial("010000011"b), /* opnd(1) <- (opnd(2)+1)/2 */ 15 76 word_to_mod2 initial("010000100"b), /* opnd(1) <- (opnd(2)+1)/2*2 */ 15 77 word_to_mod4 initial("010000101"b), /* opnd(1) <- (opnd(2)+3)/4*4 */ 15 78 word_to_mod8 initial("010000110"b), /* opnd(1) <- (opnd(2)+7)/8*8 */ 15 79 rel_fun initial("010000111"b), /* opnd(1) <- rel(opnd(2)) */ 15 80 baseno_fun initial("010001000"b), /* opnd(1) <- baseno(opnd(2)) */ 15 81 desc_size initial("010001001"b), /* opnd(1) <- substr(opnd(2),13,24) */ 15 82 bit_pointer initial("010001010"b), /* opnd(1) <- bit offset of opnd(2) */ 15 83 index_before_fun initial("010001011"b), /* opnd(1) <- length of before(opnd(2),opnd(3)) */ 15 84 index_after_fun initial("010001100"b), /* opnd(1) <- offset of after(opnd(2),opnd(3)) in opnd(2) */ 15 85 verify_ltrim_fun initial("010001101"b), /* opnd(1) <- offset of ltrim(opnd(2),opnd(3)) in opnd(2) */ 15 86 verify_rtrim_fun initial("010001110"b), /* opnd(1) <- length(opnd(2))-length(rtrim(opnd(2),opnd(3))) */ 15 87 digit_to_bit initial("010001111"b), /* opnd(1) <- 9*opnd(2)/2 */ 15 88 15 89 ceil_fun initial("010010000"b), /* opnd(1) <- ceil(opnd(2)) */ 15 90 floor_fun initial("010010001"b), /* opnd(1) <- floor(opnd(2)) */ 15 91 round_fun initial("010010010"b), /* opnd(1) <- round(opnd(2)) */ 15 92 sign_fun initial("010010011"b), /* opnd(1) <- sign(opnd(2)) */ 15 93 abs_fun initial("010010100"b), /* opnd(1) <- abs(opnd(2)) */ 15 94 trunc_fun initial("010010101"b), /* opnd(1) <- trunc(opnd(2)) */ 15 95 byte_fun initial("010010110"b), /* opnd(1) <- byte(opnd(2)) */ 15 96 rank_fun initial("010010111"b), /* opnd(1) <- rank(opnd(2)) */ 15 97 index_rev_fun initial("010011000"b), /* opnd(1) <- index(reverse(opnd(2)),reverse(opnd(3))) */ 15 98 search_rev_fun initial("010011001"b), /* opnd(1) <- search(reverse(opnd(2)),opnd(3)) */ 15 99 verify_rev_fun initial("010011010"b), /* opnd(1) <- verify(reverse(opnd(2)),opnd(3)) */ 15 100 wordno_fun initial("010011011"b), /* opnd(1) <- wordno (opnd(2)) */ 15 101 segno_fun initial("010011100"b), /* opnd(1) <- segno (opnd(2)) */ 15 102 bitno_fun initial("010011101"b), /* opnd(1) <- bitno (opnd(2)) */ 15 103 charno_fun initial("010011110"b), /* opnd(1) <- charno (opnd(2)) */ 15 104 15 105 index_fun initial("010100000"b), /* opnd(1) <- index(opnd(2),opnd(3)) */ 15 106 off_fun initial("010100001"b), /* opnd(1) <- offset(opnd(2),opnd(3)) */ 15 107 complex_fun initial("010100010"b), /* opnd(1) <- complex(opnd(2),opnd(3)) */ 15 108 conjg_fun initial("010100011"b), /* opnd(1) <- conjg(opnd(2),opnd(3)) */ 15 109 mod_fun initial("010100100"b), /* opnd(1) <- mod(opnd(2),opnd(3)) */ 15 110 repeat_fun initial("010100101"b), /* opnd(1) <- repeat(opnd(2),opnd(3)) */ 15 111 verify_fun initial("010100110"b), /* opnd(1) <- verify(opnd(2),opnd(3)) */ 15 112 translate_fun initial("010100111"b), /* opnd(1) <- translate(opnd(2),opnd(3))*/ 15 113 real_fun initial("010101001"b), /* opnd(1) <- real(opnd(2)) */ 15 114 imag_fun initial("010101010"b), /* opnd(1) <- imag(opnd(2)) */ 15 115 length_fun initial("010101011"b), /* opnd(1) <- length(opnd(2)) */ 15 116 pl1_mod_fun initial("010101100"b), /* opnd(1) <- mod(opnd(2)) */ 15 117 search_fun initial("010101101"b), /* opnd(1) <- search(opnd(2),opnd(3)) */ 15 118 allocation_fun initial("010101110"b), /* opnd(1) <- allocation(opnd(2)) */ 15 119 reverse_fun initial("010101111"b), /* opnd(1) <- reverse(opnd(2)) */ 15 120 15 121 addr_fun initial("010110000"b), /* opnd(1) <- addr(opnd(2)) */ 15 122 addr_fun_bits initial("010110001"b), /* opnd(1) <- addr(opnd(2)) */ 15 123 ptr_fun initial("010110010"b), /* opnd(1) <- ptr(opnd(2),opnd(3)) */ 15 124 baseptr_fun initial("010110011"b), /* opnd(1) <- baseptr(opnd(2)) */ 15 125 addrel_fun initial("010110100"b), /* opnd(1) <- addrel(opnd(2),opnd(3)) */ 15 126 codeptr_fun initial("010110101"b), /* opnd(1) <- codeptr(opnd(2)) */ 15 127 environmentptr_fun initial("010110110"b), /* opnd(1) <- environmentptr(opnd(2)) */ 15 128 stackbaseptr_fun initial("010110111"b), /* opnd(1) is ptr to base of current stack */ 15 129 stackframeptr_fun initial("010111000"b), /* opnd(1) is ptr to current block's stack frame */ 15 130 setcharno_fun initial("010111001"b), /* opnd(1) <- opnd(2) with charno opnd(3) */ 15 131 addcharno_fun initial("010111010"b), /* opnd(1) <- opnd(2) with charno = charno + opnd(3) */ 15 132 setbitno_fun initial("010111011"b), /* setcharno for bitsno */ 15 133 addbitno_fun initial("010111100"b), /* addcharno for bitno */ 15 134 15 135 min_fun initial("011000000"b), /* opnd(1) <- min(opnd(1),opnd(2),...) */ 15 136 max_fun initial("011000001"b), /* opnd(1) <- max(opnd(1),opnd(2),...) */ 15 137 15 138 stack_ptr initial("011010001"b), /* opnd(1) <- stack frame ptr */ 15 139 empty_area initial("011010010"b), /* empty opnd(1), length in words is opnd(2) */ 15 140 enable_on initial("011010100"b), /* opnd(1) is the cond name 15 141* opnd(2) is the file name 15 142* opnd(3) is the block */ 15 143 revert_on initial("011010101"b), /* opnd(1) is the cond name, 15 144* opnd(2) is the file name */ 15 145 signal_on initial("011010110"b), /* opnd(1) is the cond name 15 146* opnd(2) is the file name */ 15 147 15 148 lock_fun initial("011010111"b), /* opnd(1) <- stac(opnd(2),opnd(3)) */ 15 149 stacq_fun initial("011011000"b), /* opnd(1) is result, opnd(2) is ptr to lock word, 15 150* opnd(3) is old value, (4) is new value. */ 15 151 clock_fun initial("011011001"b), /* opnd(1) is the clock time */ 15 152 vclock_fun initial("011011010"b), /* opnd(1) is the virtual clock time */ 15 153 15 154 bound_ck initial("011100000"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 15 155 range_ck initial("011100001"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 15 156 loop initial("011100010"b), /* do opnd(1) for opnd(2) from opnd(3) to opnd(4) by 1, 15 157* opnd(5) is the list */ 15 158 join initial("011100011"b), /* do opnd(1), opnd(2) ... opnd(n) */ 15 159 allot_based initial("011100100"b), /* allocate opnd(2) words in opnd(3), set opnd(1) */ 15 160 free_based initial("011100101"b), /* free opnd(1) in opnd(3), length is opnd(2) words */ 15 161 15 162 r_parn initial("011110001"b), /* format op code */ 15 163 l_parn initial("011110010"b), 15 164 r_format initial("011110011"b), 15 165 c_format initial("011110100"b), 15 166 f_format initial("011110101"b), 15 167 e_format initial("011110110"b), 15 168 b_format initial("011110111"b), 15 169 a_format initial("011111000"b), 15 170 x_format initial("011111001"b), 15 171 skip_format initial("011111010"b), 15 172 column_format initial("011111011"b), 15 173 page_format initial("011111100"b), 15 174 line_format initial("011111101"b), 15 175 picture_format initial("011111110"b), 15 176 bn_format initial("011111111"b), /* bit format, length(opnd(2)), radix factor(opnd(3)) */ 15 177 15 178 get_list_trans initial("100000000"b), /* getlist(opnd(2) with desc(opnd(1))) */ 15 179 get_edit_trans initial("100000001"b), /* getedit(opnd(2) with desc(opnd(1))) */ 15 180 get_data_trans initial("100000010"b), /* getdata(opnd(1) to opnd(n)) */ 15 181 put_list_trans initial("100000011"b), /* putlist(opnd(2) with desc(opnd(1))) */ 15 182 put_edit_trans initial("100000100"b), /* putedit(opnd(2) with desc(opnd(1))) */ 15 183 put_data_trans initial("100000101"b), /* putdata(opnd(2)) with subscript-list opnd(1) */ 15 184 terminate_trans initial("100000110"b), /* terminate stream transmission */ 15 185 stream_prep initial("100000111"b), /* initiate stream transmission */ 15 186 record_io initial("100001000"b), /* perform record io operation */ 15 187 fortran_read initial("100001001"b), /* A complete read statement */ 15 188 fortran_write initial("100001010"b), /* A complete write statement */ 15 189 ftn_file_manip initial("100001011"b), /* endfile,backspace,rewind,etc. */ 15 190 ftn_trans_loop initial("100001100"b), /* An implied do in i/o list */ 15 191 put_control initial("100001101"b), /* put control opnd(1) opnd(2) times */ 15 192 put_field initial("100001110"b), /* putlist(opnd(2)) of length(opnd(1)) */ 15 193 put_field_chk initial("100001111"b), /* putlist(op(2)) of len(op(1)) check char index(op(3)) */ 15 194 15 195 /* These operators are produced by the parse but are not used as input to the code generator. */ 15 196 /* They are processed by the semantic translator. */ 15 197 15 198 return_value initial("100010010"b), /* return(opnd(1)) */ 15 199 allot_var initial("100010011"b), /* allot opnd(1) in opnd(2) */ 15 200 free_var initial("100010100"b), /* free opnd(1) out of opnd(2) */ 15 201 get_file initial("100010101"b), /* opnd(1) is filename,opnd(2) is copy */ 15 202 /* opnd(3) is skip, opnd(4) is list */ 15 203 get_string initial("100010110"b), /* opnd(1) is string,opnd(2) is list */ 15 204 put_file initial("100010111"b), /* opnd(1) is filename,opnd(2) is page */ 15 205 /* opnd(3) is skip,opnd(4) is line */ 15 206 put_string initial("100011000"b), /* opnd(1) is string,opnd(2) is list */ 15 207 open_file initial("100011001"b), 15 208 close_file initial("100011010"b), 15 209 read_file initial("100011011"b), 15 210 write_file initial("100011100"b), 15 211 locate_file initial("100011101"b), 15 212 do_fun initial("100011110"b), /* opnd(1) is join of a list */ 15 213 /* opnd(2) is control variable ref */ 15 214 /* opnd(3) is specification operator */ 15 215 do_spec initial("100011111"b), /* opnd(1) to opnd(2) by opnd(3) */ 15 216 /* repeat opnd(4) while opnd(5) */ 15 217 /* opnd(6) is next specification */ 15 218 15 219 rewrite_file initial("100100000"b), 15 220 delete_file initial("100100001"b), 15 221 unlock_file initial("100100010"b), 15 222 lock_file initial("100100011"b), 15 223 refer initial("100100101"b), /* opnd(1) refer(opnd(2)) */ 15 224 prefix_plus initial("100100110"b), /* opnd(1) <- +opnd(2) */ 15 225 nop initial("100100111"b), /* no-op */ 15 226 assign_by_name initial("100101000"b), /* opnd(1) <- opnd(2),by name */ 15 227 15 228 /* These operators are produced by the semantic translator in processing the math 15 229* builtin functions and are used as input to the code generator */ 15 230 15 231 sqrt_fun initial("100110000"b), /* opnd(1) <- sqrt(opnd(2)) */ 15 232 sin_fun initial("100110001"b), /* opnd(1) <- sin(opnd(2)) */ 15 233 sind_fun initial("100110010"b), /* opnd(1) <- sind(opnd(2)) */ 15 234 cos_fun initial("100110011"b), /* opnd(1) <- cos(opnd(2)) */ 15 235 cosd_fun initial("100110100"b), /* opnd(1) <- cosd(opnd(2)) */ 15 236 tan_fun initial("100110101"b), /* opnd(1) <- tan(opnd(2)) */ 15 237 tand_fun initial("100110110"b), /* opnd(1) <- tand(opnd(2)) */ 15 238 asin_fun initial("100110111"b), /* opnd(1) <- asin(opnd(2)) */ 15 239 asind_fun initial("100111000"b), /* opnd(1) <- asind(opnd(2)) */ 15 240 acos_fun initial("100111001"b), /* opnd(1) <- acos(opnd(2)) */ 15 241 acosd_fun initial("100111010"b), /* opnd(1) <- acosd(opnd(2)) */ 15 242 atan_fun initial("100111011"b), /* opnd(1) <- atan(opnd(2)[,opnd(3)]) */ 15 243 atand_fun initial("100111100"b), /* opnd(1) <- atand(opnd(2)[,opnd(3)]) */ 15 244 log2_fun initial("100111101"b), /* opnd(1) <- log2(opnd(2)) */ 15 245 log_fun initial("100111110"b), /* opnd(1) <- log(opnd(2)) */ 15 246 log10_fun initial("100111111"b), /* opnd(1) <- log10(opnd(2)) */ 15 247 15 248 exp_fun initial("101000000"b)) /* opnd(1) <- exp(opnd(2)) */ 15 249 15 250 bit(9) aligned internal static options(constant); 15 251 15 252 /* END INCLUDE FILE ... op_codes.incl.pl1 */ 64 16 1 /* statement types */ 16 2 16 3 dcl ( unknown_statement initial("000000000"b), 16 4 allocate_statement initial("000000001"b), 16 5 assignment_statement initial("000000010"b), 16 6 begin_statement initial("000000011"b), 16 7 call_statement initial("000000100"b), 16 8 close_statement initial("000000101"b), 16 9 declare_statement initial("000000110"b), 16 10 lock_statement initial("000000111"b), 16 11 delete_statement initial("000001000"b), 16 12 display_statement initial("000001001"b), 16 13 do_statement initial("000001010"b), 16 14 else_clause initial("000001011"b), 16 15 end_statement initial("000001100"b), 16 16 entry_statement initial("000001101"b), 16 17 exit_statement initial("000001110"b), 16 18 format_statement initial("000001111"b), 16 19 free_statement initial("000010000"b), 16 20 get_statement initial("000010001"b), 16 21 goto_statement initial("000010010"b), 16 22 if_statement initial("000010011"b), 16 23 locate_statement initial("000010100"b), 16 24 null_statement initial("000010101"b), 16 25 on_statement initial("000010110"b), 16 26 open_statement initial("000010111"b), 16 27 procedure_statement initial("000011000"b), 16 28 put_statement initial("000011001"b), 16 29 read_statement initial("000011010"b), 16 30 return_statement initial("000011011"b), 16 31 revert_statement initial("000011100"b), 16 32 rewrite_statement initial("000011101"b), 16 33 signal_statement initial("000011110"b), 16 34 stop_statement initial("000011111"b), 16 35 system_on_unit initial("000100000"b), 16 36 unlock_statement initial("000100001"b), 16 37 wait_statement initial("000100010"b), 16 38 write_statement initial("000100011"b), 16 39 default_statement initial("000100100"b), 16 40 continue_statement initial("000100101"b)) bit(9) internal static aligned options(constant); 65 17 1 /* BEGIN INCLUDE FILE ... nodes.incl.pl1 */ 17 2 17 3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */ 17 4 17 5 dcl ( block_node initial("000000001"b), 17 6 statement_node initial("000000010"b), 17 7 operator_node initial("000000011"b), 17 8 reference_node initial("000000100"b), 17 9 token_node initial("000000101"b), 17 10 symbol_node initial("000000110"b), 17 11 context_node initial("000000111"b), 17 12 array_node initial("000001000"b), 17 13 bound_node initial("000001001"b), 17 14 format_value_node initial("000001010"b), 17 15 list_node initial("000001011"b), 17 16 default_node initial("000001100"b), 17 17 machine_state_node initial("000001101"b), 17 18 source_node initial("000001110"b), 17 19 label_node initial("000001111"b), 17 20 cross_reference_node initial("000010000"b), 17 21 sf_par_node initial("000010001"b), 17 22 temporary_node initial("000010010"b), 17 23 label_array_element_node initial("000010011"b), 17 24 by_name_agg_node initial("000010100"b)) 17 25 bit(9) internal static aligned options(constant); 17 26 17 27 dcl 1 node based aligned, 17 28 2 type unal bit(9), 17 29 2 source_id unal structure, 17 30 3 file_number bit(8), 17 31 3 line_number bit(14), 17 32 3 statement_number bit(5); 17 33 17 34 /* END INCLUDE FILE ... nodes.incl.pl1 */ 66 67 68 begin: 69 inhibit_walk = "0"b; 70 set_level = 0; 71 s_list,p_list,free,freec,p_tail,freep,freep_tail,l_list=null; 72 blk=root->block.son; 73 scan: 74 do while(blk->block.son ^= null); 75 blk=blk->block.son; 76 end; 77 statements: 78 doing_loop = "0"b; 79 do stm = blk->block.prologue, blk->block.main; 80 state_is_discarded = "0"b; 81 do stm = stm repeat stm->statement.next while(stm^=null); 82 pl1_stat_$cur_statement = stm; 83 if string(stm -> statement.source_id) = string(pl1_stat_$stop_id) 84 then do; 85 call ioa_$nnl("optimizer at ^p: ^a^/DB ",stm,decode_node_id(stm,"0"b)); 86 call debug; 87 end; 88 statement_type = stm->statement.statement_type; 89 if statement_type = entry_statement 90 then do; 91 call clear; 92 state_is_discarded = "0"b; 93 end; 94 else if statement_type ^= procedure_statement 95 then if statement_type ^= format_statement 96 then do; 97 if stm->statement.labels ^= null 98 then do; 99 call intersection(stm,1); /* order of calls is crucial */ 100 call intersection(stm,2); /* leave proper info on prim's for cg 101* or create new state */ 102 end; 103 if ^ state_is_discarded 104 then call reduce(stm->statement.root,stm,"0"b,"0"b); 105 if statement_type = return_statement | statement_type = stop_statement 106 then state_is_discarded = "1"b; 107 else if statement_type = begin_statement 108 then call erase; 109 end; 110 end; 111 end; 112 call clear; 113 114 /* process the list of loop operators */ 115 116 p = l_list; 117 do while(p ^= null); 118 doing_loop = "1"b; 119 q = p -> chain.value; 120 call reduce(q->operand(1),q,"0"b,"0"b); 121 call clear; 122 if p -> chain.next = null 123 then do; 124 p -> chain.next = freec; 125 freec = l_list; 126 l_list = null; 127 go to next_block; 128 end; 129 p = p -> chain.next; 130 end; 131 132 /* set blk to point to the next block node. */ 133 134 next_block: 135 if blk->block.brother ^= null 136 then blk=blk->block.brother; 137 else if blk->block.father ^= null 138 then do; 139 blk=blk->block.father; 140 go to statements; 141 end; 142 else return; 143 go to scan; 144 145 146 /* this routine walks down the tree matching all computations against the primary list, 147*and entering all reducible computations into the primary list if they are not already 148*there. If an operator or reference node matches a computation in the primary list, 149*the parent node is modified to refer to the node that is in the primary list, and the 150*reference count of that node is increased by one. The reference count, if any, 151*in the matching node is decreased by one and ,if possible, the node is freed. 152*All operators which could alter the value of a variable are recognized 153*and any computation which depends on these variables is removed from the primary list. */ 154 155 /* inhibit is an input parameter used to prevent commoning or entry onto the 156* primary list of any node contained in a loop subtree. 157* 158* irreducible is an output parameter set when an operator node is found to be 159* irreducible. An operator is irreducible if it: 160* 161* 1. is a call to an irreducible entry. 162* 2. produces side effects or output that depends on something 163* other than its formal input. 164* 3. contains any of the above. 165* 166*irreducible_op is a local variable used to determine if a given node is an irreducible 167*operator. If it is irreducible it is not put on the primary list, but contained 168*subexpression may be put on the list if they are not themselves irreducible. 169* 170*The top operaotor of an argument subexpression is never commoned 171*or put on the primary list, but it is not considered irreducible in the 172*sense that it does not make its containing operator irreducible. This 173*is because if the containing operator is a reducible function the 174*programmer has declared that the function won't alter its argument. If 175*the containing operator is an irreducible function, we don't need to 176*pass back this information. Since at the level where 177*we process the argument, we don't know wheither or not the containing 178*function is reducible, we don't set the irreducible bit for the 179*top operator of an argument. 180* 181*Before the code_generator phase, reference.inhibit = "1"b means that the reference 182*is the base of a defined variable (used for its address not its value) and should 183*not be commoned. This prevents conversion of the reference to a temporary by the 184*code generator, which would destroy the address. 185* 186*Note that a given invocation of reduce cannot return unless it is at the bottom of the tree 187*or has just called erase or has been commoned. This insures that all set contexts 188*are scanned. A commoned subtree cannot contain a set context because if it did, it 189*would be irreducible and therefore not in the primary list. */ 190 191 reduce: proc(pt,parent,irreducible,inhibit); 192 193 dcl pt ptr unaligned; 194 dcl (parent,p,q,p1,p2,p3,s1,tp) ptr; 195 dcl (i,j)fixed bin(15); 196 dcl opcode bit(9) aligned; 197 dcl (irreducible,sets_operand1,inhibit,signal_op,new_primary, 198 irreducible_op,jump_op,irreducible_entry,addr_op, 199 sets_reference,irreducible_sons,inhibit_sons,irreducible_2) 200 bit(1) aligned; 201 202 203 begin: 204 p = pt; 205 if p=null then return; 206 if p->node.type = reference_node 207 then do; 208 p1 = p->reference.symbol; 209 if p1->node.type = symbol_node 210 then do; 211 212 /* The aliasable bit of a reference node means that the storage 213* identified by this reference is potentially accessable via 214* another name, this is a potential alias. The circumstances 215* that cause the aliasable bit of the symbol node to be set are: 216* 217* The variable is used as an argument to addr. 218* (note that put string(x), read into(x), read or locate set(x) 219* all take addr of x.) 220* The variable is the base of a defined variable. 221* The variable is defined. 222* The variable is based. 223* The variable is external. 224* The variable is a parameter. 225* The variable is passed as an argument by_reference and is static or controlled. 226* 227* The reference is aliasable (potentially aliased) if its symbol node 228* has the aliasable bit or if it is a reference to a nonlocal automatic 229* variable that is passed as an argument by_reference. */ 230 231 p->reference.aliasable = p1->symbol.aliasable| 232 (p1->symbol.auto&(blk^=p1->symbol.block_node)&p1->symbol.passed_as_arg); 233 234 /* this code is executed to exclude from optimization those simple references 235* that are done by the code generator. If they were included here, 236* the size of the tree would be very large. */ 237 238 if p->reference.offset=null 239 then if p->reference.qualifier=null 240 then if p->reference.length=null 241 then if p1->symbol.temporary 242 then return; 243 else if p->reference.units=word_ | p->reference.units=0 244 then if p -> reference.ref_count = 0 245 then if ^ (p1->symbol.packed & p1->symbol.member) 246 then if p = p1 -> symbol.reference 247 then return; 248 else do; 249 p2 = p1 -> symbol.reference; 250 if compare_expression(p,p2) 251 then pt = p2; 252 return; 253 end; 254 end; 255 256 /* search the primary list for a previously computed instance of this reference. */ 257 258 q = p_list; 259 if ^inhibit 260 then if ^ p->reference.inhibit 261 then do; 262 do while(q^=null); 263 p2 = q -> primary.computation; 264 if p = p2 265 then return; 266 else if compare_expression(p2,p) 267 then do; 268 269 /* replace this reference with the previously computed one. */ 270 271 pt = p2; 272 p2->reference.ref_count = p2->reference.ref_count+1; 273 call adjust_count(p); 274 return; 275 end; 276 q = q->primary.next; 277 end; 278 end; 279 280 /* determine the reducibility of this reference while reducing its sons. */ 281 282 irreducible_op = "0"b; 283 if ^ inhibit_walk 284 then if ^p->reference.shared /* shared references have no sons */ 285 then do; 286 call reduce_ref_sons(p,irreducible_op); 287 end; 288 irreducible = irreducible|irreducible_op; 289 if inhibit|irreducible_op|p->reference.inhibit then return; 290 291 /* no temporaries can go on the primary list */ 292 293 if p1 -> node.type = symbol_node 294 then if p1 -> symbol.temporary 295 then return; 296 297 /* only unshared references should go on the primary list */ 298 299 if p -> reference.shared 300 then do; 301 p = copy_expression((p)); 302 p -> reference.shared = "0"b; 303 p -> reference.ref_count = 1; 304 pt = p; 305 end; 306 307 /* put this reference on the primary list. */ 308 309 q = create_node(p_list,1); 310 q->primary.computation = p; 311 q->primary.statement = pl1_stat_$cur_statement; 312 call record_secondaries(p,1); 313 return; 314 end; 315 if p->node.type = list_node 316 then do; 317 do i = 1 to p->list.number; 318 call reduce(p->list.element(i),p,irreducible,inhibit); 319 end; 320 return; 321 end; 322 if p->node.type ^= operator_node then return; 323 324 /* join operators should be handled like list nodes except that they are always irreducible */ 325 326 opcode = p->operator.op_code; 327 328 if opcode = join 329 then do; 330 do i = 1 to p->operator.number; 331 call reduce(p->operator.operand(i),p,irreducible,inhibit); 332 end; 333 irreducible = "1"b; 334 return; 335 end; 336 337 /* classify this operator and determine if it is irreducible. */ 338 339 jump_op = opcode>=jump & opcode<=jump_if_ge; 340 signal_op = opcode=record_io|opcode=allot_ctl|opcode=signal_on|opcode=terminate_trans|opcode=stream_prep| 341 opcode=open_file|opcode=close_file|opcode=allot_based|(opcode>=get_list_trans & opcode<=put_data_trans)| 342 opcode=lock_fun|opcode=stacq_fun; 343 irreducible_op = signal_op|jump_op|p->operator.number=0|opcode=return_words| 344 (opcode>=return_bits & opcode<=allot_auto)|opcode=free_ctl| 345 (opcode>=empty_area & opcode<=vclock_fun)|(opcode>=loop & opcode<=nop); 346 sets_operand1 = ^(opcode=return_words|opcode=return_bits|opcode=return_string|opcode=std_entry| 347 jump_op|p->operator.number=0|(opcode>=loop & opcode<=nop)); 348 addr_op = opcode = addr_fun | opcode = addr_fun_bits; 349 350 if addr_op 351 then addr_op = p -> operand(2) -> node.type = reference_node; 352 353 irreducible = irreducible|irreducible_op; 354 355 356 /* search the primary list for a previously computed instance of this operator. 357* If one is found, make the parent of this node point to it. */ 358 359 360 q=p_list; 361 if ^(inhibit|irreducible_op|parent->node.type = list_node) 362 then do; 363 do while(q^=null); 364 p2 = q -> primary.computation; 365 if p = p2 366 then return; 367 else if compare_expression(p2,p) 368 then do; 369 p1 = p2->operand(1); 370 if p1->reference.shared 371 then do; 372 p1,p2->operand(1) = copy_expression((p1)); 373 p1->reference.shared = "0"b; 374 p1->reference.ref_count = 1; 375 end; 376 pt = p2; 377 p1->reference.ref_count = p1->reference.ref_count+1; 378 call adjust_count(p); 379 return; 380 end; 381 q=q->primary.next; 382 end; 383 end; 384 385 /* If the operator can produce a signal that is allowed to alter storage and return, 386* process it as if it was a call to an external entry. */ 387 388 if signal_op 389 then do; 390 irreducible_sons = "0"b; 391 392 if opcode = get_data_trans 393 then do; 394 if p->operand(1) = null 395 then call erase; /* this is get data; */ 396 else do; 397 p = p->operand(1); /* join operator */ 398 do i = 1 to p->operator.number; 399 call set((p->operand(i))); 400 end; 401 end; 402 call external_call; 403 return; 404 end; 405 406 if opcode = get_edit_trans | opcode = get_list_trans 407 then do; 408 call reduce(p->operand(1),p,irreducible_op,inhibit); 409 q = p->operand(2); 410 if ^ q -> reference.shared 411 then call reduce_ref_sons(q,irreducible_sons); 412 call set(q); 413 call external_call; 414 call check_and_reduce_target(2 /* ,q,p,irreducible_sons */); 415 return; 416 end; 417 418 if opcode = allot_ctl 419 then do; 420 call reduce(p -> operand(2),p,irreducible_op,inhibit); 421 call set((p->operand(1))); 422 call external_call; 423 call reduce(p->operand(1),p,irreducible_op,inhibit); 424 return; 425 end; 426 427 if opcode = allot_based 428 then do; 429 q = p -> operand(1); 430 431 /* set option evaluated first and only once */ 432 433 if ^ q -> reference.shared 434 then call reduce_ref_sons(q,irreducible_sons); 435 436 /* operations after this point may be retried */ 437 438 call external_call; 439 440 call reduce(p -> operand(2),p,irreducible_op,inhibit); 441 442 if p -> operand(3) ^= null 443 then do; 444 call reduce(p -> operand(3),p,irreducible_op,inhibit); 445 call set((p -> operand(3))); 446 end; 447 448 call set(q); 449 call external_call; 450 call check_and_reduce_target(1 /* ,q,p,irreducible_sons */); 451 return; 452 end; 453 454 if opcode = lock_fun | opcode = stacq_fun 455 then do; 456 do i = 2 to p->operator.number; 457 call reduce(p->operand(i),p,irreducible_op,inhibit); 458 end; 459 460 q = p -> operand(1); 461 if ^ q -> reference.shared 462 then call reduce_ref_sons(q,irreducible_sons); 463 464 if opcode = stacq_fun 465 then call set((p -> operand(2))); 466 else call external_call; 467 call set(q); 468 469 call check_and_reduce_target(1 /* ,q,p,irreducible_sons */); 470 return; 471 end; 472 473 do i = 1 to p->operator.number; 474 call reduce(p->operand(i),p,irreducible_op,inhibit); 475 end; 476 call external_call; 477 return; 478 end; 479 480 /* all operators processed after this point do not produce conditions of interest to the optimizer. */ 481 482 if opcode = free_based 483 then do; 484 call reduce(p -> operand(2),p,irreducible_op,inhibit); 485 call reduce_ref_sons((p -> operand(1)),irreducible_op); 486 487 if p -> operand(3) ^= null 488 then do; 489 call reduce(p -> operand(3),p,irreducible_op,inhibit); 490 call set((p -> operand(3))); 491 end; 492 493 /* last block of code here is nonstandard and corresponds to runtime action */ 494 495 if p -> operand(1) -> reference.qualifier -> node.type = reference_node 496 then call set((p -> operand(1) -> reference.qualifier)); 497 498 return; 499 end; 500 501 if opcode = fortran_read 502 then do; 503 do i = 1 to 9; 504 call reduce(p->operand(i),p,irreducible_op,inhibit); 505 end; 506 p1 = p->operand(10); 507 if p1 ^= null /* check for an I/O list */ 508 then do i = 1 to p1->list.number; 509 call set((p1->list.element(i))); 510 call reduce(p1->operand(i),p1,irreducible_op,inhibit); 511 end; 512 return; 513 end; 514 515 /* reduce the second operand of all non-addr_op operators that have at least two operands. 516* (we omit reduction of the second operand of addr_ops to avoid code optimizations 517* for short strings done by the code generator) */ 518 519 if p->operator.number >= 2 520 then if ^ addr_op 521 then do; 522 irreducible_2 = "0"b; 523 call reduce(p -> operand(2),p,irreducible_2,inhibit); 524 irreducible_op = irreducible_op | irreducible_2; 525 end; 526 else do; 527 tp = p -> operand(2); 528 tp->reference.aliasable = tp->reference.symbol->symbol.aliasable; 529 if ^ tp -> reference.shared 530 then call reduce_ref_sons(tp,irreducible_op); 531 end; 532 533 if opcode = std_call 534 then do; 535 536 /* Calls to internal procedures and entry variables may set anything. Calls to external 537* entries can set: arguments passed by reference, aliased variables, and variables declared in a flush_at_call block. 538* The flush_at_call bit indicates that this block contains an on-unit, or an 539* internal procedure whose name is assigned or passed as an argument. Therefore, 540* any call out from this block could result in the invocation of the on-unit or 541* internal procedure and could set any variable known to this block. */ 542 543 /* The operands of a std_call operator are processed somewhat differently than the 544* operands of other operators. We want to reduce the arguments of the call before 545* flushing the primary list, but we do not want to actually reduce a reference 546* node being passed as an argument until after the primary list is cleared 547* (because of some code optimizations done by the code generator). The solution 548* we adopt is to reduce any length, qualifier, or offset expression on 549* a reference before clearing primary list and to not reduce the reference at 550* all. */ 551 552 /* the top operator of an argument expression passed to an irreducible entry cannot 553*be commoned because it is usable as a variable in the called procedure. */ 554 555 p3 = p->operand(2); 556 if p3->node.type = reference_node 557 then irreducible_entry = p3->reference.symbol->symbol.irreducible; 558 else irreducible_entry = "1"b; 559 560 irreducible_op = irreducible_op|irreducible_entry; 561 if irreducible_entry 562 then do; 563 p3 = p -> operand(3); 564 if p3 ^= null 565 then do; 566 q = p3 -> operand(2); 567 568 do i = 1 to q -> list.number; 569 tp = q -> element(i); 570 if tp -> node.type ^= reference_node 571 then call reduce(q -> element(i),q,irreducible_op,inhibit); 572 else do; 573 if ^ tp -> reference.shared 574 then call reduce_ref_sons(tp,irreducible_op); 575 end; 576 end; 577 end; 578 579 q = p -> operand(2); 580 if q -> node.type = operator_node then q = q -> operand(1); 581 q = q -> reference.symbol; 582 583 if q -> symbol.variable | q -> symbol.internal | q->symbol.temporary 584 then do; 585 call erase; 586 end; 587 else do; 588 if p3 ^= null 589 then do; 590 q = p3 -> operand(2); 591 592 do i = 1 to q -> list.number; 593 tp = q->list.element(i); 594 if tp->node.type = reference_node 595 then call set(tp); 596 end; 597 598 end; 599 call external_call; 600 end; 601 602 end; 603 604 else do; 605 p3 = p -> operand(3); 606 if p3 ^= null 607 then call reduce(p3 -> operand(2),p3,irreducible_op,inhibit); 608 end; 609 610 end; 611 612 /* reduce operands 3 through n for all operators that have them, except std_call. */ 613 614 if opcode ^= std_call 615 then do i = 3 to p->operator.number; 616 call reduce(p->operand(i),p,irreducible_op,inhibit); 617 end; 618 619 620 621 /* If this operator is reducible and stores its output into operand1, put it on the primary list. */ 622 623 inhibit_sons = inhibit; 624 sets_reference, 625 irreducible_sons, 626 new_primary = "0"b; 627 if sets_operand1 628 then if p->operator.operand(1) ^= null 629 then if p->operator.operand(1)->node.type = reference_node 630 then do; 631 632 /* we must reduce descendents of operand(1) before it is set */ 633 634 sets_reference = "1"b; 635 q = p->operand(1); 636 if ^ q->reference.shared 637 then do; 638 call reduce_ref_sons(q,irreducible_sons); 639 inhibit_sons = inhibit_sons | irreducible_sons; 640 irreducible_op = irreducible_op | irreducible_sons; 641 end; 642 643 if ^(irreducible_op | inhibit | parent->node.type = list_node) 644 then do; 645 new_primary = "1"b; 646 p1=create_node(p_list,1); 647 p1->primary.computation = p; 648 p1->primary.statement = pl1_stat_$cur_statement; 649 call record_secondaries(p,2); /* record all but operand 1 as secondaries. */ 650 if ^ q->reference.shared 651 then call record_secondaries(q,0); /* record descendents of opnd1 652* as secondaries */ 653 end; 654 end; 655 656 /* If the operator places its output into a variable the variable must be processed 657* by the "set" routine to purge the primary list of any computation that depends on 658* the value of this variable. NOTE: we must set the reference's aliasable bit 659* here, because it may not yet have been reduced */ 660 661 if sets_reference 662 then do; 663 if q->reference.symbol->node.type = symbol_node 664 then if ^(q->reference.symbol->symbol.temporary 665 |q->reference.symbol->symbol.return_value) 666 then do; 667 s1 = q -> reference.symbol; 668 q -> reference.aliasable = s1 -> symbol.aliasable | 669 (s1->symbol.auto&(blk^=s1->symbol.block_node)&s1->symbol.passed_as_arg); 670 671 call set(q); 672 673 if ^ q->reference.shared 674 then if ^ inhibit_sons 675 then inhibit_sons = inhibit_sons | sons_were_set(q); 676 end; 677 end; 678 679 680 681 /* if this operator was entered on the primary list, record operand 1 as a secondary. 682* This strange order is necessary to insure that i=i+1 is not retained as a primary, 683* but a=b+c is retained. Futhermore, a=b+c;a=10; must flush the add operator. */ 684 685 if new_primary 686 then if p_list ^= null 687 then if p_list->primary.computation = p 688 then if ^p->operand(1)->reference.symbol->symbol.temporary 689 then call record_secondaries((p->operand(1)),-1); 690 691 /* reduce operand one of all operators. */ 692 693 inhibit_walk = sets_reference; 694 inhibit_sons = inhibit_sons|(opcode=loop|opcode=ftn_trans_loop); 695 if p->operator.number>0 696 then if p->operator.operand(1) ^= null 697 then call reduce(p->operand(1),p,irreducible_op,inhibit_sons); 698 699 irreducible = irreducible|irreducible_op; 700 inhibit_walk = "0"b; 701 702 /* If the operator is a loop operator which does not immediately contain another 703*loop operator, and we are not processing the inside of a loop now, then put this 704*operator on the loop chain. */ 705 706 if opcode = loop 707 then if ^ doing_loop 708 then if p -> operand(1) -> operator.op_code ^= loop 709 then do; 710 if freec = null 711 then do; 712 freec = create_list(2); 713 freec -> list.element(2) = null; 714 end; 715 p1 = freec; 716 freec = p1 -> chain.next; 717 p1 -> chain.next = l_list; 718 l_list = p1; 719 p1 -> chain.value = p; 720 end; 721 722 /* if the operator is a transfer check to see if it goes to a statement futher down in 723*this block. If it does, then attach the current p_list to the statement by taking the intersection 724*of the list already on the statement and the current p_list. Each time a transfer is processed the 725*reference count in the statement node is decreased by one. When the optimizer encounters the 726*labeled statement it will check to see if all references have been processed by checking 727*for a reference count of one. If all references have been processed it will continue its optimization 728*using the intersection of its current p_list and the list attached to the statement. If all 729*references have not been processed it will erase its p_list. If the operator is an 730*unconditional transfer mark the state as discarded. */ 731 732 if jump_op 733 then do; 734 q=p->operand(1); 735 if q -> node.type = label_node 736 then do; 737 if q -> label.block_node = blk 738 then call process_jump_target((q -> label.statement)); 739 end; 740 else if q -> node.type = reference_node 741 then do; 742 s1 = q -> reference.symbol; 743 if s1 -> node.type = label_node 744 then if s1 -> label.block_node = blk 745 then if q -> reference.offset = null 746 then call process_jump_target((s1->label.statement->element(q->reference.c_offset + 1))); 747 else do; 748 q = s1 -> label.statement; 749 do j = 1 to q -> list.number; 750 if q -> element(j) ^= null 751 then call process_jump_target((q -> element(j))); 752 end; 753 end; 754 end; 755 756 if opcode = jump 757 then state_is_discarded = "1"b; 758 759 /* set bit for cg's use in optimizing if statements */ 760 761 if irreducible_2 762 then if p -> operator.number = 2 /* jump_true | jump_false */ 763 then stm -> statement.irreducible = "1"b; 764 end; 765 return; 766 767 768 reduce_ref_sons: proc(pt,irreducible_sons); 769 770 dcl (p,pt) ptr; 771 dcl irreducible_sons bit(1) aligned; 772 773 p = pt; 774 if p -> reference.length ^= null 775 then call reduce(p -> reference.length,p,irreducible_sons,inhibit); 776 if p -> reference.qualifier ^= null 777 then call reduce(p -> reference.qualifier,p,irreducible_sons,inhibit); 778 if p -> reference.offset ^= null 779 then call reduce(p -> reference.offset,p,irreducible_sons,inhibit); 780 781 end; /* reduce_ref_sons */ 782 783 784 /* this routine searches the primary list for sons of operand(1) of an operator 785* to see if they were set when operand(1) was set. if so, operand(1) should 786* not be put on the primary list */ 787 788 sons_were_set: proc(pt) reducible returns(bit(1) aligned); 789 790 dcl (p,pt) ptr; 791 792 p = pt; 793 794 if ^ check((p->reference.qualifier)) 795 then if ^ check((p->reference.offset)) 796 then if ^ check((p->reference.length)) 797 then return("0"b); 798 799 return("1"b); 800 801 check: proc(pt) reducible returns(bit(1) aligned); 802 803 dcl (p,pt,q) ptr; 804 805 p = pt; 806 807 if p = null then go to ok; 808 if p -> node.type = reference_node 809 then if p -> reference.shared 810 then go to ok; 811 812 do q = p_list repeat q -> primary.next while(q ^= null); 813 if q -> primary.computation = p then go to ok; 814 end; 815 816 return("1"b); 817 ok: return("0"b); 818 819 end; /* check */ 820 821 end; /* sons_were_set */ 822 823 824 /* this routine, called for a signal_op, checks to see if a target can 825* be reduced after the operation has taken place */ 826 827 check_and_reduce_target: proc(i /* ,q,p,irreducible_sons */); 828 829 dcl i fixed bin; 830 831 if ^ q -> reference.shared 832 then if ^ irreducible_sons 833 then irreducible_sons = irreducible_sons | sons_were_set(q); 834 835 if ^ irreducible_sons 836 then do; 837 inhibit_walk = "1"b; 838 call reduce(p -> operand(i),p,irreducible_op,inhibit); 839 inhibit_walk = "0"b; 840 end; 841 842 end; /* check_and_reduce_target */ 843 844 845 /* this routine does the actual processing for targets of jump_op's */ 846 847 process_jump_target: proc(pt); 848 849 dcl (pt,p1,p2,p4,q) ptr; 850 851 p1 = pt; 852 853 if p1->statement.ref_count_copy = 0 854 then p1->statement.ref_count_copy=p1->statement.reference_count-1; 855 else p1->statement.ref_count_copy=p1->statement.ref_count_copy-1; 856 if string(p1->statement.source_id) < string(pl1_stat_$cur_statement->statement.source_id) 857 then return; 858 if p1->statement.optimized 859 then call intersection(p1,2); 860 else do; 861 p1->statement.optimized="1"b; 862 q=p_list; 863 do while(q^=null); 864 p4=p1->statement.reference_list; 865 p2=create_node(p4,0); 866 p1->statement.reference_list=p4; 867 p2->primary.computation=q->primary.computation; 868 p2->primary.statement=q->primary.statement; 869 q=q->primary.next; 870 end; 871 end; 872 873 end; /* process_jump_target */ 874 875 end; /* reduce */ 876 877 878 /* this routine walks down a tree recognizing references to variables 879*and enters them in the secondary list if they are not already in the list. */ 880 881 record_secondaries: proc(pt,start); 882 883 dcl (p,pt,q,p1,p2) ptr; 884 dcl (i,start) fixed bin(15); 885 886 /* start : 887* -1 record pt but not its descendents 888* 0 record pt's descendent but not pt 889* 1 record pt and its descendents 890* 2 record operands 2-n of operator pt */ 891 892 begin: 893 p = pt; 894 if p=null then return; 895 if p->node.type = list_node 896 then do; 897 do i = 1 to p->list.number; 898 call record_secondaries((p->list.element(i)),1); 899 end; 900 return; 901 end; 902 if p->node.type = operator_node 903 then do; 904 do i=start to p->operator.number; 905 call record_secondaries((p->operand(i)),1); 906 end; 907 return; 908 end; 909 910 if p->node.type ^= reference_node then return; 911 912 p1 = p->reference.symbol; 913 if p1 ->node.type ^= symbol_node then return; 914 915 if start >= 0 916 then do; 917 if p->reference.qualifier ^= null then call record_secondaries((p->reference.qualifier),1); 918 if p->reference.offset ^= null then call record_secondaries((p->reference.offset),1); 919 if p->reference.length ^= null then call record_secondaries((p->reference.length),1); 920 end; 921 922 if start = 0 then return; 923 924 if p1 -> symbol.constant | p1 -> symbol.temporary then return; 925 926 /* search the secondary list to see if the variable is in the list */ 927 928 q=s_list; 929 do while(q^=null); 930 p2 = q->secondary.operation; 931 if p2 = p then goto chain_it; 932 if p->reference.symbol = p2->reference.symbol 933 then if compare_expression(p2,p) 934 then go to chain_it; 935 q=q->secondary.next; 936 end; 937 938 /* make a new secondary entry for the variable */ 939 940 q=create_node(s_list,2); 941 q->secondary.primary=null; 942 q->secondary.operation=p; 943 944 945 /* add this primary to the list of primaries effected by this secondary */ 946 947 chain_it: 948 if freec = null 949 then do; 950 freec = create_list(2); 951 freec->list.element(2) = null; 952 end; 953 p1=freec; 954 freec=p1->chain.next; 955 p1->chain.next=q->secondary.primary; 956 q->secondary.primary=p1; 957 p1->chain.value=p_list; 958 end record_secondaries; 959 960 /* this routine removes entries from the secondary list and related 961*primary list. */ 962 963 set: proc(pt); 964 965 dcl (p,pt,q,p1,q1,p2,s) ptr; 966 dcl c_offset fixed bin(24); 967 dcl p1_unal ptr unal auto; /* used for better code in the comparisons */ 968 969 970 begin: 971 p = pt; 972 if p=null then return; 973 if p->node.type ^= reference_node then return; 974 p1_unal, p1 = p->reference.symbol; 975 if p1->node.type ^= symbol_node then return; 976 s = p1->symbol.son; 977 do while(s^=null); 978 set_level = set_level + 1; 979 call set((s->symbol.reference)); 980 set_level = set_level - 1; 981 s = s->symbol.brother; 982 end; 983 if p->reference.aliasable 984 then do; 985 q = s_list; 986 do while(q^=null); 987 q1 = q->secondary.operation->reference.symbol; 988 if q->secondary.operation->reference.aliasable 989 then if compare_alias(p1,q1) 990 then do; 991 call free_them; 992 q1 = q->secondary.next; 993 call release_node(q,s_list,2); 994 q = q1; 995 go to next; 996 end; 997 q = q->secondary.next; 998 next: 999 end; 1000 return; 1001 end; 1002 1003 /* If the set was done with a pseudovariable, set the argument of the pseudovariable */ 1004 1005 if p1 -> symbol.defined 1006 then call set((p -> reference.qualifier)); 1007 1008 /* if this variable has been the argument of string, unspec, real, or imag, we 1009* must remove all computations depending on this symbol because the offset and 1010* c_offset may have been changed during processing. Also, ancestors may have 1011* been affected */ 1012 1013 if p1 -> symbol.overlayed_by_builtin & (p1 -> symbol.member | p1 -> symbol.dimensioned) 1014 then do; 1015 do while(p1 ^= null); 1016 if ^ p1 -> symbol.overlayed_by_builtin | ^ (p1 -> symbol.member | p1 -> symbol.dimensioned) 1017 then return; 1018 q = s_list; 1019 do while(q ^= null); 1020 if q -> secondary.operation -> reference.symbol = p1 /* p1_unal not used because p1 changes */ 1021 then do; 1022 call free_them; 1023 q1 = q -> secondary.next; 1024 call release_node(q,s_list,2); 1025 q = q1; 1026 end; 1027 else q = q -> secondary.next; 1028 end; 1029 if set_level > 0 1030 then return; 1031 p1 = p1 -> symbol.father; 1032 end; 1033 return; 1034 end; 1035 1036 /* if this is an array element with variable offset or array reference or string, remove all computations */ 1037 /* that are a function of any element of this array or string. */ 1038 1039 if (p1->symbol.array ^= null & (p->reference.array_ref | p-> reference.offset ^= null)) | p1->symbol.bit | p1->symbol.char 1040 then do; 1041 q=s_list; 1042 do while(q^=null); 1043 if q->secondary.operation->reference.symbol=p1_unal 1044 then do; 1045 call free_them; 1046 q1=q->secondary.next; 1047 call release_node(q,s_list,2); 1048 q=q1; 1049 end; 1050 else q=q->secondary.next; 1051 end; 1052 return; 1053 end; 1054 1055 /* if this is an array element with constant offset, remove all computations 1056* that are a function of this element or any array reference or array 1057* element with variable offset of this array. handle storage_block 1058* references in a similar manner */ 1059 1060 if p1 -> symbol.array ^= null | p1 -> symbol.storage_block 1061 then do; 1062 q = s_list; 1063 c_offset = p -> reference.c_offset; 1064 do while (q ^= null); 1065 q1 = q -> secondary.operation; 1066 if q1 -> reference.symbol = p1_unal 1067 then if q1 -> reference.c_offset = c_offset | q1 -> reference.array_ref | q1 -> reference.offset ^= null 1068 then do; 1069 call free_them; 1070 q1 = q -> secondary.next; 1071 call release_node(q,s_list,2); 1072 q = q1; 1073 go to next_a; 1074 end; 1075 q = q -> secondary.next; 1076 next_a: 1077 end; 1078 return; 1079 end; 1080 1081 /* this is not an array element or array reference or string. */ 1082 1083 q=s_list; 1084 do while(q^=null); 1085 if q->secondary.operation->reference.symbol = p1_unal 1086 then do; 1087 call free_them; 1088 call release_node(q,s_list,2); 1089 return; 1090 end; 1091 q=q->secondary.next; 1092 end; 1093 return; 1094 1095 /* This entry frees all computations that depend on anything that can be set by a 1096* call to an external procedure, otherthan the arguments passed by-reference. */ 1097 1098 external_call: entry; 1099 1100 declare free_flag bit(1); 1101 1102 q = s_list; 1103 do while(q^=null); 1104 q1 = q->secondary.operation; 1105 p2 = q1->reference.symbol->symbol.block_node; 1106 if p2 = null 1107 then free_flag = q1->reference.aliasable; 1108 else free_flag = q1->reference.aliasable|p2->block.flush_at_call; 1109 if free_flag 1110 then do; 1111 call free_them; 1112 q1 = q->secondary.next; 1113 call release_node(q,s_list,2); 1114 q = q1; 1115 end; 1116 else q = q->secondary.next; 1117 end; 1118 return; 1119 1120 /* subroutine to free all primary list entries that depend on the secondary 1121* entry identified by the pointer q. */ 1122 1123 free_them: proc; 1124 1125 dcl p1 ptr; 1126 1127 begin: 1128 p1 = q->secondary.primary; 1129 do while(p1^=null); 1130 call release_node((p1->chain.value),p_list,1); 1131 if p1->chain.next=null 1132 then do; 1133 p1->chain.next = freec; 1134 freec = q->secondary.primary; 1135 return; 1136 end; 1137 p1 = p1->chain.next; 1138 end; 1139 1140 end free_them; 1141 18 1 /* BEGIN INCLUDE FILE ... compare_alias.incl.pl1 */ 18 2 18 3 /* This subroutine is an include file and is included in the optimizer and in the 18 4* code generator. It determines whether or not two potentially aliased variables are capable of 18 5* occupying the same generation of storage. Its input is a pair of pointers each pointing 18 6* to a symbol node. */ 18 7 18 8 compare_alias: proc(pa,pb) reducible returns(aligned bit); 18 9 18 10 dcl (a,b,pa,pb) ptr; 19 1 /* BEGIN INCLUDE FILE ... picture_image.incl.pl1 19 2* 19 3* James R. Davis 12 Mar 79 19 4**/ 19 5 19 6 dcl 1 picture_image aligned based, 19 7 2 type fixed bin (8) unal, 19 8 2 prec fixed bin (8) unal, /* precision or length of associated value */ 19 9 2 scale fixed bin (8) unal, /* for both fixed and float pictures, 19 10* =ndigits after "v" - scale_factor */ 19 11 2 piclength fixed bin (8) unal, /* length of picture_constant.chars, <64 19 12* =length of normalized-picture-string */ 19 13 2 varlength fixed bin (8) unal, /* length of pictured variable in chars, <64 19 14* =length of normalized_picture_string - "k" and "v" */ 19 15 2 scalefactor fixed bin (8) unal, /* value of pict-sc-f, -256<=x<256 */ 19 16 2 explength fixed bin (8) unal, /* length of exp field for float */ 19 17 2 drift_character char (1) unal, 19 18 2 chars char (0 refer (picture_image.piclength)) aligned; 19 19 19 20 dcl ( 19 21 picture_char_type init (24), 19 22 picture_realfix_type init (25), 19 23 picture_complexfix_type 19 24 init (26), 19 25 picture_realflo_type init (27), 19 26 picture_complexflo_type 19 27 init (28) 19 28 ) fixed bin (8) unal static internal options (constant); 19 29 19 30 /* END INCLUDE FILE ... picture_image.incl.pl1 */ 18 11 18 12 18 13 a = pa; 18 14 b = pb; 18 15 if equal_types(a,b)|(bit_overlay(a)&bit_overlay(b))|(char_overlay(a)&char_overlay(b)) 18 16 then return("1"b); /* coded this way for efficiency */ 18 17 else return("0"b); 18 18 18 19 equal_types: proc(a,b) reducible returns(aligned bit); 18 20 18 21 dcl (a,b) ptr; 18 22 18 23 18 24 if string(a->symbol.data_type)=string(b->symbol.data_type) 18 25 then if a->symbol.aligned=b->symbol.aligned 18 26 then if a -> symbol.unsigned = b -> symbol.unsigned 18 27 then if a->symbol.varying=b->symbol.varying 18 28 then if a->symbol.binary=b->symbol.binary 18 29 then if a->symbol.real=b->symbol.real 18 30 then if(a->symbol.c_dcl_size=b->symbol.c_dcl_size|^(a->symbol.fixed|a->symbol.float)) 18 31 then if a->symbol.scale=b->symbol.scale 18 32 then if a->symbol.picture 18 33 then return(a->symbol.general->reference.symbol->symbol.initial->picture_image.chars = 18 34 b->symbol.general->reference.symbol->symbol.initial->picture_image.chars); 18 35 else return("1"b); 18 36 return("0"b); 18 37 end; /* equal_types */ 18 38 18 39 bit_overlay: proc(a) reducible returns(aligned bit); 18 40 18 41 dcl (a,p) ptr; 18 42 18 43 p = a; 18 44 do while(p->symbol.structure); 18 45 p = p->symbol.son; 18 46 end; 18 47 return(a->symbol.packed&p->symbol.bit); 18 48 end; /* bit_overlay */ 18 49 18 50 char_overlay: proc(a) reducible returns(aligned bit); 18 51 18 52 dcl (a,p) ptr; 18 53 18 54 p = a; 18 55 do while(p->symbol.structure); 18 56 p = p->symbol.son; 18 57 end; 18 58 return(a->symbol.packed&(p->symbol.char|p->symbol.picture)); 18 59 end; /* char_overlay */ 18 60 18 61 end; /* compare_alias */ 18 62 18 63 /* END INCLUDE FILE ... compare_alias.incl.pl1 */ 1142 1143 end set; 1144 1145 /* these routines are utility programs to create and free nodes */ 1146 /* i=0 for statement list primary nodes. i=1 for p_list primary nodes. i=2 for secondary nodes. */ 1147 1148 release_node: proc(pt,list_head,i); 1149 1150 dcl (p,pt,list_head) ptr; 1151 dcl i fixed bin(15); 1152 1153 begin: 1154 p = pt; 1155 if p->primary.computation = null 1156 then return; /* this is an attempt to release an already freed primary */ 1157 if p->primary.next ^=null 1158 then p->primary.next->primary.last=p->primary.last; 1159 if p->primary.last =null 1160 then list_head=p->primary.next; 1161 else p->primary.last->primary.next=p->primary.next; 1162 if i=1 1163 then do; /* this is a primary node */ 1164 if freep = null then freep_tail = p; 1165 p->primary.computation=null; /* null indicates that it is free */ 1166 p->primary.next=freep; 1167 freep=p; 1168 if p=p_tail then p_tail=p->primary.last; 1169 end; 1170 else do; 1171 p->primary.next = free; 1172 free=p; 1173 end; 1174 p->primary.last=null; 1175 end release_node; 1176 1177 1178 create_node: proc(list_head,i) returns(ptr); 1179 1180 dcl (list_head,p) ptr; 1181 dcl i fixed bin(15); 1182 1183 begin: 1184 if free = null 1185 then p = create_list(4); 1186 else do; 1187 p=free; 1188 free=free->list.element(4); 1189 end; 1190 p->list.element(3)=null; 1191 p->list.element(4)=list_head; 1192 if i=1 & list_head=null then p_tail=p; 1193 if list_head ^= null then list_head->list.element(3)=p; 1194 list_head=p; 1195 return(p); 1196 end create_node; 1197 1198 1199 /* erase everything from the primary and secondary lists. */ 1200 1201 clear: proc; 1202 1203 call erase; 1204 if p_tail ^= null 1205 then do; 1206 p_tail->list.element(4) = free; 1207 free = p_list; 1208 p_list,p_tail = null; 1209 end; 1210 end clear; 1211 1212 /* erase all primaries except those whose operands are constants. */ 1213 1214 erase: proc; 1215 1216 dcl (p,q) ptr; 1217 1218 begin: 1219 q=s_list; 1220 do while(q^=null); 1221 p=q->secondary.primary; 1222 do while(p^=null); 1223 if p->chain.value->primary.computation ^= null 1224 then call release_node((p->chain.value),p_list,1); 1225 if p->chain.next = null 1226 then do; 1227 p->chain.next=freec; 1228 freec=q->secondary.primary; 1229 go to continue; 1230 end; 1231 p=p->chain.next; 1232 end; 1233 continue: 1234 call release_node(q,s_list,2); 1235 q=s_list; 1236 end; 1237 1238 /* put free primaries on the free list. It is safe to do this because no 1239*more secondaries exist and therefore no references exist. */ 1240 1241 /* the primary list may still contain computations whose operands are constants */ 1242 1243 if freep_tail ^= null 1244 then do; 1245 freep_tail->primary.next=free; 1246 free=freep; 1247 freep_tail,freep=null; 1248 end; 1249 end erase; 1250 1251 1252 /* this routine gets the intersection of the p_list and the primary list 1253*attached to the statement node. If i=2 the statement node list is replace by this intersection. 1254*If i=1 the primary list p_list is replaced by the intersection. If the state has been 1255*discarded and i = 2, the primary list p_list is replaced by the union of p_list and the 1256*statement node list. */ 1257 1258 intersection: proc(pstate,p_i); 1259 1260 dcl (pstate,state,p,q,t) ptr; 1261 dcl (i,n,p_i) fixed bin(15); 1262 1263 begin: 1264 state = pstate; 1265 i = p_i; 1266 1267 n = 0; 1268 do q=state->statement.labels repeat q->list.element(1) while(q^=null); 1269 n = n + 1; 1270 end; 1271 1272 if state -> statement.ref_count_copy = 0 then state -> statement.ref_count_copy = 1273 state -> statement.reference_count; 1274 1275 if i=1 & state->statement.ref_count_copy ^= n 1276 then do; 1277 call clear; 1278 q=state->statement.reference_list; 1279 do while(q^=null); 1280 t = state -> statement.reference_list; 1281 call release_node(q,t,0); 1282 q, state->statement.reference_list = t; 1283 end; 1284 return; 1285 end; 1286 1287 if ^state->statement.optimized /* label was never referenced */ 1288 then if i=1 | state->statement.ref_count_copy = n 1289 then return; 1290 1291 if i = 2 & state_is_discarded & p_list = null 1292 then do; 1293 do p = state -> statement.reference_list repeat p -> primary.next while(p ^= null); 1294 t = create_node(p_list,1); 1295 t -> primary.computation = p -> primary.computation; 1296 t -> primary.statement = p -> primary.statement; 1297 call record_secondaries((t -> primary.computation),1); 1298 end; 1299 state_is_discarded = "0"b; 1300 return; 1301 end; 1302 1303 if i=2 then p=state->statement.reference_list; 1304 else p=p_list; 1305 do while(p^=null); 1306 if i=2 then q=p_list; 1307 else q=state->statement.reference_list; 1308 do while(q^=null); 1309 if q->primary.computation = p->primary.computation 1310 then do; 1311 p=p->primary.next; 1312 go to next; 1313 end; 1314 q=q->primary.next; 1315 end; 1316 1317 /* this element is not common to both lists, remove it (or if i = 2 & 1318* state_is_discarded, add it to p_list). */ 1319 1320 q=p->primary.next; 1321 if i=2 1322 then if state_is_discarded 1323 then do; 1324 t = create_node(p_list,1); 1325 t -> primary.computation = p -> primary.computation; 1326 t -> primary.statement = p -> primary.statement; 1327 call record_secondaries((t -> primary.computation),1); 1328 end; 1329 else do; 1330 t = state -> statement.reference_list; 1331 call release_node(p,t,0); 1332 state -> statement.reference_list = t; 1333 end; 1334 else call release_node(p,p_list,1); 1335 p=q; 1336 next: 1337 end; 1338 1339 if i = 2 then state_is_discarded = "0"b; 1340 1341 1342 end intersection; 1343 1344 1345 dump_primary: entry; 1346 dcl display_exp entry(ptr); 1347 do q = p_list repeat q->primary.next while(q^=null); 1348 call display_exp((q->primary.computation)); 1349 call ioa_("^/"); 1350 end; 1351 return; 1352 1353 dump_secondary: entry; 1354 do q = s_list repeat q->secondary.next while(q^=null); 1355 call display_exp((q->secondary.operation)); 1356 call ioa_("^/"); 1357 end; 1358 return; 1359 end /* optimizer */; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 07/31/89 1338.4 optimizer.pl1 >spec>install>MR12.3-1066>optimizer.pl1 55 1 07/31/89 1332.6 language_utility.incl.pl1 >spec>install>MR12.3-1066>language_utility.incl.pl1 1-307 2 05/06/74 1746.9 source_id_descriptor.incl.pl1 >ldd>include>source_id_descriptor.incl.pl1 1-325 3 05/06/74 1746.9 source_id_descriptor.incl.pl1 >ldd>include>source_id_descriptor.incl.pl1 1-335 4 05/06/74 1746.9 source_id_descriptor.incl.pl1 >ldd>include>source_id_descriptor.incl.pl1 1-374 5 05/06/74 1746.9 source_id_descriptor.incl.pl1 >ldd>include>source_id_descriptor.incl.pl1 1-386 6 05/06/74 1746.9 source_id_descriptor.incl.pl1 >ldd>include>source_id_descriptor.incl.pl1 56 7 08/13/81 2043.5 block.incl.pl1 >ldd>include>block.incl.pl1 57 8 04/07/83 1635.0 statement.incl.pl1 >ldd>include>statement.incl.pl1 58 9 07/21/80 1546.3 operator.incl.pl1 >ldd>include>operator.incl.pl1 59 10 12/07/83 1701.7 symbol.incl.pl1 >ldd>include>symbol.incl.pl1 60 11 10/25/79 1645.8 boundary.incl.pl1 >ldd>include>boundary.incl.pl1 61 12 05/06/74 1742.1 label.incl.pl1 >ldd>include>label.incl.pl1 62 13 08/13/81 2211.5 list.incl.pl1 >ldd>include>list.incl.pl1 63 14 07/21/80 1546.3 reference.incl.pl1 >ldd>include>reference.incl.pl1 64 15 04/07/83 1635.0 op_codes.incl.pl1 >ldd>include>op_codes.incl.pl1 65 16 05/03/76 1320.4 statement_types.incl.pl1 >ldd>include>statement_types.incl.pl1 66 17 07/21/80 1546.3 nodes.incl.pl1 >ldd>include>nodes.incl.pl1 1142 18 11/30/78 1227.5 compare_alias.incl.pl1 >ldd>include>compare_alias.incl.pl1 18-11 19 06/28/79 1204.8 picture_image.incl.pl1 >ldd>include>picture_image.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. a 000136 automatic pointer dcl 18-10 in procedure "compare_alias" set ref 18-13* 18-15* 18-15* 18-15* a parameter pointer dcl 18-52 in procedure "char_overlay" ref 18-50 18-54 18-58 a parameter pointer dcl 18-21 in procedure "equal_types" ref 18-19 18-24 18-24 18-24 18-24 18-24 18-24 18-24 18-24 18-24 18-24 18-24 18-24 a parameter pointer dcl 18-41 in procedure "bit_overlay" ref 18-39 18-43 18-47 addr_fun constant bit(9) initial dcl 15-8 ref 348 addr_fun_bits constant bit(9) initial dcl 15-8 ref 348 addr_op 000127 automatic bit(1) dcl 197 set ref 348* 350 350* 519 address 10 based structure level 2 packed packed unaligned dcl 14-3 adjust_count 000042 constant entry external dcl 1-20 ref 273 378 aliasable 12(16) based bit(1) level 3 in structure "reference" packed packed unaligned dcl 14-3 in procedure "optimizer" set ref 231* 528* 668* 983 988 1106 1108 aliasable 32(35) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 10-3 in procedure "optimizer" ref 231 528 668 aligned 31(21) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 18-24 18-24 allot_auto constant bit(9) initial dcl 15-8 ref 343 allot_based constant bit(9) initial dcl 15-8 ref 340 427 allot_ctl constant bit(9) initial dcl 15-8 ref 340 418 array 12 based pointer level 2 packed packed unaligned dcl 10-3 ref 1039 1060 array_ref 0(09) based bit(1) level 2 packed packed unaligned dcl 14-3 ref 1039 1066 attributes 31 based structure level 2 dcl 10-3 auto 32(09) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 231 668 b 000140 automatic pointer dcl 18-10 in procedure "compare_alias" set ref 18-14* 18-15* 18-15* 18-15* b parameter pointer dcl 18-21 in procedure "equal_types" ref 18-19 18-24 18-24 18-24 18-24 18-24 18-24 18-24 18-24 18-24 begin_statement constant bit(9) initial dcl 16-3 ref 107 binary 31(29) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 18-24 18-24 bit 31(03) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 1039 18-47 bits 13 based structure level 2 in structure "statement" packed packed unaligned dcl 8-9 in procedure "optimizer" bits 12(06) based structure level 2 in structure "reference" packed packed unaligned dcl 14-3 in procedure "optimizer" blk 000100 automatic pointer dcl 17 set ref 72* 73 75* 75 79 79 134 134* 134 137 139* 139 231 668 737 743 block based structure level 1 dcl 7-5 block_node 4 based pointer level 2 in structure "symbol" packed packed unaligned dcl 10-3 in procedure "optimizer" ref 231 668 1105 block_node 4 based pointer level 2 in structure "label" packed packed unaligned dcl 12-1 in procedure "optimizer" ref 737 743 brother 2 based pointer level 2 in structure "block" packed packed unaligned dcl 7-5 in procedure "optimizer" ref 134 134 brother 20 based pointer level 2 in structure "symbol" packed packed unaligned dcl 10-3 in procedure "optimizer" ref 981 c_dcl_size 30 based fixed bin(24,0) level 2 dcl 10-3 ref 18-24 18-24 c_offset 000114 automatic fixed bin(24,0) dcl 966 in procedure "set" set ref 1063* 1066 c_offset 1 based fixed bin(24,0) level 2 in structure "reference" dcl 14-3 in procedure "optimizer" ref 743 1063 1066 chain based structure level 1 dcl 46 char 31(04) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 1039 18-58 chars 2 based char level 2 dcl 19-6 ref 18-24 18-24 close_file constant bit(9) initial dcl 15-8 ref 340 compare_expression 000044 constant entry external dcl 1-48 ref 250 266 367 932 compiler_developed 32(35) based structure level 3 packed packed unaligned dcl 10-3 computation 1 based pointer level 2 packed packed unaligned dcl 28 set ref 263 310* 364 647* 685 813 867* 867 1155 1165* 1223 1295* 1295 1297 1309 1309 1325* 1325 1327 1348 constant 32(16) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 924 copy_expression 000046 constant entry external dcl 1-94 ref 301 372 create_list 000050 constant entry external dcl 1-147 ref 712 950 1183 data_type 31 based structure level 3 packed packed unaligned dcl 10-3 ref 18-24 18-24 debug 000040 constant entry external dcl 23 ref 86 decode_node_id 000052 constant entry external dcl 1-300 ref 85 defined 32(13) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 1005 dimensioned 31(19) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 1013 1016 display_exp 000054 constant entry external dcl 1346 ref 1348 1355 doing_loop 000111 automatic bit(1) dcl 19 set ref 77* 118* 706 element 1 based pointer array level 2 packed packed unaligned dcl 13-6 set ref 318* 509 569 570* 593 713* 743 750 750 898 951* 1188 1190* 1191* 1193* 1206* 1270 empty_area constant bit(9) initial dcl 15-8 ref 343 entry_statement constant bit(9) initial dcl 16-3 ref 89 father 1 based pointer level 2 in structure "block" packed packed unaligned dcl 7-5 in procedure "optimizer" ref 137 139 father 17 based pointer level 2 in structure "symbol" packed packed unaligned dcl 10-3 in procedure "optimizer" ref 1031 fixed 31(01) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 18-24 float 31(02) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 18-24 flush_at_call 24(24) based bit(1) level 2 packed packed unaligned dcl 7-5 ref 1108 format_statement constant bit(9) initial dcl 16-3 ref 94 fortran_read constant bit(9) initial dcl 15-8 ref 501 free 000014 internal static pointer dcl 24 set ref 71* 1171 1172* 1183 1187 1188* 1188 1206 1207* 1245 1246* free_based constant bit(9) initial dcl 15-8 ref 482 free_ctl constant bit(9) initial dcl 15-8 ref 343 free_flag 000116 automatic bit(1) packed unaligned dcl 1100 set ref 1106* 1108* 1109 freec 000016 internal static pointer dcl 24 set ref 71* 124 125* 710 712* 713 715 716* 947 950* 951 953 954* 1133 1134* 1227 1228* freep 000022 internal static pointer dcl 24 set ref 71* 1164 1166 1167* 1246 1247* freep_tail 000024 internal static pointer dcl 24 set ref 71* 1164* 1243 1245 1247* ftn_trans_loop constant bit(9) initial dcl 15-8 ref 694 general 16 based pointer level 2 packed packed unaligned dcl 10-3 ref 18-24 18-24 get_data_trans constant bit(9) initial dcl 15-8 ref 392 get_edit_trans constant bit(9) initial dcl 15-8 ref 406 get_list_trans constant bit(9) initial dcl 15-8 ref 340 406 i parameter fixed bin(15,0) dcl 1151 in procedure "release_node" ref 1148 1162 i 000110 automatic fixed bin(15,0) dcl 884 in procedure "record_secondaries" set ref 897* 898* 904* 905* i parameter fixed bin(15,0) dcl 1181 in procedure "create_node" ref 1178 1192 i parameter fixed bin(17,0) dcl 829 in procedure "check_and_reduce_target" ref 827 838 i 000110 automatic fixed bin(15,0) dcl 1261 in procedure "intersection" set ref 1265* 1275 1287 1291 1303 1306 1321 1339 i 000116 automatic fixed bin(15,0) dcl 195 in procedure "reduce" set ref 317* 318* 330* 331* 398* 399* 456* 457* 473* 474* 503* 504* 507* 509 510* 568* 569 570* 592* 593* 614* 616* inhibit 10(28) based bit(1) level 3 in structure "reference" packed packed unaligned dcl 14-3 in procedure "optimizer" ref 259 289 inhibit parameter bit(1) dcl 197 in procedure "reduce" set ref 191 259 289 318* 331* 361 408* 420* 423* 440* 444* 457* 474* 484* 489* 504* 510* 523* 570* 606* 616* 623 643 774* 776* 778* 838* inhibit_sons 000132 automatic bit(1) dcl 197 set ref 623* 639* 639 673 673* 673 694* 694 695* inhibit_walk 000112 automatic bit(1) dcl 19 set ref 68* 283 693* 700* 837* 839* initial 11 based pointer level 2 packed packed unaligned dcl 10-3 ref 18-24 18-24 internal 32(01) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 583 ioa_ 000034 constant entry external dcl 23 ref 1349 1356 ioa_$nnl 000036 constant entry external dcl 23 ref 85 irreducible 31(34) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 10-3 in procedure "optimizer" ref 556 irreducible parameter bit(1) dcl 197 in procedure "reduce" set ref 191 288* 288 318* 331* 333* 353* 353 699* 699 irreducible 13(05) based bit(1) level 3 in structure "statement" packed packed unaligned dcl 8-9 in procedure "optimizer" set ref 761* irreducible_2 000133 automatic bit(1) dcl 197 set ref 522* 523* 524 761 irreducible_entry 000126 automatic bit(1) dcl 197 set ref 556* 558* 560 561 irreducible_op 000124 automatic bit(1) dcl 197 set ref 282* 286* 288 289 343* 353 361 408* 420* 423* 440* 444* 457* 474* 484* 485* 489* 504* 510* 524* 524 529* 560* 560 570* 573* 606* 616* 640* 640 643 695* 699 838* irreducible_sons 000131 automatic bit(1) dcl 197 in procedure "reduce" set ref 390* 410* 433* 461* 624* 638* 639 640 831 831* 831 835 irreducible_sons parameter bit(1) dcl 771 in procedure "reduce_ref_sons" set ref 768 774* 776* 778* j 000117 automatic fixed bin(15,0) dcl 195 set ref 749* 750 750* join constant bit(9) initial dcl 15-8 ref 328 jump constant bit(9) initial dcl 15-8 ref 339 756 jump_if_ge constant bit(9) initial dcl 15-8 ref 339 jump_op 000125 automatic bit(1) dcl 197 set ref 339* 343 346 732 l_list 000026 internal static pointer dcl 24 set ref 71* 116 125 126* 717 718* label based structure level 1 dcl 12-1 label_node constant bit(9) initial dcl 17-5 ref 735 743 labels 4 based pointer level 2 packed packed unaligned dcl 8-9 ref 97 1268 last 3 based pointer level 2 packed packed unaligned dcl 28 set ref 1157* 1157 1159 1161 1168 1174* length 6 based pointer level 2 packed packed unaligned dcl 14-3 set ref 238 774 774* 794 919 919 list based structure level 1 dcl 13-6 list_head parameter pointer dcl 1150 in procedure "release_node" set ref 1148 1159* list_head parameter pointer dcl 1180 in procedure "create_node" set ref 1178 1191 1192 1193 1193 1194* list_node constant bit(9) initial dcl 17-5 ref 315 361 643 895 lock_fun constant bit(9) initial dcl 15-8 ref 340 454 loop constant bit(9) initial dcl 15-8 ref 343 346 694 706 706 main 13 based pointer level 2 packed packed unaligned dcl 7-5 ref 79 member 32(04) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 243 1013 1016 misc_attributes 31(19) based structure level 3 packed packed unaligned dcl 10-3 n 000111 automatic fixed bin(15,0) dcl 1261 set ref 1267* 1269* 1269 1275 1287 new_primary 000123 automatic bit(1) dcl 197 set ref 624* 645* 685 next 2 based pointer initial level 2 in structure "chain" packed packed unaligned dcl 46 in procedure "optimizer" set ref 122 124* 129 716 717* 954 955* 1131 1133* 1137 1225 1227* 1231 next 1 based pointer level 2 in structure "statement" packed packed unaligned dcl 8-9 in procedure "optimizer" ref 110 next 4 based pointer level 2 in structure "secondary" packed packed unaligned dcl 37 in procedure "optimizer" ref 935 992 997 1023 1027 1046 1050 1070 1075 1091 1112 1116 1357 next 4 based pointer level 2 in structure "primary" packed packed unaligned dcl 28 in procedure "optimizer" set ref 276 381 814 869 1157 1157 1159 1161* 1161 1166* 1171* 1245* 1298 1311 1314 1320 1350 node based structure level 1 dcl 17-27 nop constant bit(9) initial dcl 15-8 ref 343 346 null builtin function dcl 53 ref 71 73 81 97 117 122 126 134 137 205 238 238 238 262 363 394 442 487 507 564 588 606 627 685 695 710 713 743 750 774 776 778 807 812 863 894 917 918 919 929 941 947 951 972 977 986 1015 1019 1039 1039 1042 1060 1064 1066 1084 1103 1106 1129 1131 1155 1157 1159 1164 1165 1174 1183 1190 1192 1193 1204 1208 1220 1222 1223 1225 1243 1247 1268 1279 1291 1293 1305 1308 1347 1354 number 0(21) based fixed bin(14,0) level 2 in structure "list" packed packed unaligned dcl 13-6 in procedure "optimizer" ref 317 507 568 592 749 897 number 0(21) based fixed bin(14,0) level 2 in structure "operator" packed packed unaligned dcl 9-6 in procedure "optimizer" ref 330 343 346 398 456 473 519 614 695 761 904 offset 5 based pointer level 2 packed packed unaligned dcl 14-3 set ref 238 743 778 778* 794 918 918 1039 1066 op_code 0(09) based bit(9) level 2 packed packed unaligned dcl 9-6 ref 326 706 opcode 000120 automatic bit(9) dcl 196 set ref 326* 328 339 339 340 340 340 340 340 340 340 340 340 340 340 340 343 343 343 343 343 343 343 343 346 346 346 346 346 346 348 348 392 406 406 418 427 454 454 464 482 501 533 614 694 694 706 756 open_file constant bit(9) initial dcl 15-8 ref 340 operand 1 based pointer array level 2 packed packed unaligned dcl 9-6 set ref 120* 331* 350 369 372* 394 397 399 408* 409 420* 421 423* 429 440* 442 444* 445 457* 460 464 474* 484* 485 487 489* 490 495 495 504* 506 510* 523* 527 555 563 566 579 580 590 605 606* 616* 627 627 635 685 685 695 695* 706 734 838* 905 operation 1 based pointer level 2 packed packed unaligned dcl 37 set ref 930 942* 987 988 1020 1043 1065 1085 1104 1355 operator based structure level 1 dcl 9-6 operator_node constant bit(9) initial dcl 17-5 ref 322 580 902 optimized 12(24) based bit(1) level 2 packed packed unaligned dcl 8-9 set ref 858 861* 1287 overlayed_by_builtin 33(14) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 1013 1016 p 000100 automatic pointer dcl 883 in procedure "record_secondaries" set ref 892* 894 895 897 898 902 904 905 910 912 917 917 918 918 919 919 931 932 932* 942 p 000166 automatic pointer dcl 18-52 in procedure "char_overlay" set ref 18-54* 18-55 18-56* 18-56 18-58 18-58 p 000104 automatic pointer dcl 17 in procedure "optimizer" set ref 116* 117 119 122 124 129* 129 p 000100 automatic pointer dcl 194 in procedure "reduce" set ref 203* 205 206 208 231 238 238 238 243 243 243 243 250* 259 264 266* 273* 283 286* 289 299 301* 301 302 303 304 310 312* 315 317 318 318* 322 326 330 331 331* 343 346 350 365 367* 378* 394 397* 397 398 399 408 408* 409 420 420* 421 423 423* 429 440 440* 442 444 444* 445 456 457 457* 460 464 473 474 474* 484 484* 485 487 489 489* 490 495 495 504 504* 506 519 523 523* 527 555 563 579 605 614 616 616* 627 627 635 647 649* 685 685 685 695 695 695 695* 706 719 734 761 838 838* p 000100 automatic pointer dcl 1150 in procedure "release_node" set ref 1153* 1155 1157 1157 1157 1159 1159 1161 1161 1164 1165 1166 1167 1168 1168 1171 1172 1174 p 000100 automatic pointer dcl 965 in procedure "set" set ref 970* 972 973 974 983 1005 1039 1039 1063 p 000100 automatic pointer dcl 1216 in procedure "erase" set ref 1221* 1222 1223 1223 1225 1227 1231* 1231 p 000102 automatic pointer dcl 1260 in procedure "intersection" set ref 1293* 1293* 1295 1296* 1298 1303* 1304* 1305 1309 1311* 1311 1320 1325 1326 1331* 1334* 1335* p 000400 automatic pointer dcl 790 in procedure "sons_were_set" set ref 792* 794 794 794 p 000410 automatic pointer dcl 803 in procedure "check" set ref 805* 807 808 808 813 p 000370 automatic pointer dcl 770 in procedure "reduce_ref_sons" set ref 773* 774 774 774* 776 776 776* 778 778 778* p 000100 automatic pointer dcl 1180 in procedure "create_node" set ref 1183* 1187* 1190 1191 1192 1193 1194 1195 p 000156 automatic pointer dcl 18-41 in procedure "bit_overlay" set ref 18-43* 18-44 18-45* 18-45 18-47 p1 000104 automatic pointer dcl 883 in procedure "record_secondaries" set ref 912* 913 924 924 953* 954 955 956 957 p1 000104 automatic pointer dcl 194 in procedure "reduce" set ref 208* 209 231 231 231 231 238 243 243 243 249 293 293 369* 370 372 372* 373 374 377 377 506* 507 507 509 510 510* 646* 647 648 715* 716 717 718 719 p1 000104 automatic pointer dcl 965 in procedure "set" set ref 974* 975 976 988* 1005 1013 1013 1013 1015 1016 1016 1016 1020 1031* 1031 1039 1039 1039 1060 1060 p1 000430 automatic pointer dcl 849 in procedure "process_jump_target" set ref 851* 853 853 853 855 855 856 858 858* 861 864 866 p1 000126 automatic pointer dcl 1125 in procedure "free_them" set ref 1127* 1129 1130 1131 1133 1137* 1137 p1_unal 000115 automatic pointer packed unaligned dcl 967 set ref 974* 1043 1066 1085 p2 000432 automatic pointer dcl 849 in procedure "process_jump_target" set ref 865* 867 868 p2 000106 automatic pointer dcl 883 in procedure "record_secondaries" set ref 930* 931 932 932* p2 000106 automatic pointer dcl 194 in procedure "reduce" set ref 249* 250* 250 263* 264 266* 271 272 272 364* 365 367* 369 372 376 p2 000110 automatic pointer dcl 965 in procedure "set" set ref 1105* 1106 1108 p3 000110 automatic pointer dcl 194 set ref 555* 556 556 563* 564 566 588 590 605* 606 606 606* p4 000434 automatic pointer dcl 849 set ref 864* 865* 866 p_i parameter fixed bin(15,0) dcl 1261 ref 1258 1265 p_list 000012 internal static pointer dcl 24 set ref 71* 258 309* 360 646* 685 685 812 862 957 1130* 1207 1208* 1223* 1291 1294* 1304 1306 1324* 1334* 1347 p_tail 000020 internal static pointer dcl 24 set ref 71* 1168 1168* 1192* 1204 1206 1208* pa parameter pointer dcl 18-10 ref 18-8 18-13 packed 33 based bit(1) level 4 packed packed unaligned dcl 10-3 ref 243 18-47 18-58 parent parameter pointer dcl 194 ref 191 361 643 passed_as_arg 33(01) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 231 668 pb parameter pointer dcl 18-10 ref 18-8 18-14 piclength 0(27) based fixed bin(8,0) level 2 packed packed unaligned dcl 19-6 ref 18-24 18-24 picture 31(18) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 18-24 18-58 picture_image based structure level 1 dcl 19-6 pl1_stat_$cur_statement 000030 external static pointer dcl 21 set ref 82* 311 648 856 pl1_stat_$stop_id 000032 external static bit(27) packed unaligned dcl 22 ref 83 primary 2 based pointer level 2 in structure "secondary" packed packed unaligned dcl 37 in procedure "optimizer" set ref 941* 955 956* 1127 1134 1221 1228 primary based structure level 1 dcl 28 in procedure "optimizer" procedure_statement constant bit(9) initial dcl 16-3 ref 94 prologue 11 based pointer level 2 packed packed unaligned dcl 7-5 ref 79 pstate parameter pointer dcl 1260 ref 1258 1263 pt parameter pointer dcl 770 in procedure "reduce_ref_sons" ref 768 773 pt parameter pointer packed unaligned dcl 193 in procedure "reduce" set ref 191 203 250* 271* 304* 376* pt parameter pointer dcl 803 in procedure "check" ref 801 805 pt parameter pointer dcl 965 in procedure "set" ref 963 970 pt parameter pointer dcl 1150 in procedure "release_node" ref 1148 1153 pt parameter pointer dcl 849 in procedure "process_jump_target" ref 847 851 pt parameter pointer dcl 883 in procedure "record_secondaries" ref 881 892 pt parameter pointer dcl 790 in procedure "sons_were_set" ref 788 792 put_data_trans constant bit(9) initial dcl 15-8 ref 340 q 000102 automatic pointer dcl 883 in procedure "record_secondaries" set ref 928* 929 930 935* 935 940* 941 942 955 956 q 000106 automatic pointer dcl 17 in procedure "optimizer" set ref 119* 120 120* 1347* 1347* 1348* 1350 1354* 1354* 1355* 1357 q 000102 automatic pointer dcl 194 in procedure "reduce" set ref 258* 262 263 276* 276 309* 310 311 360* 363 364 381* 381 409* 410 410* 412* 429* 433 433* 448* 460* 461 461* 467* 566* 568 569 570 570* 579* 580 580* 580 581* 581 583 583 583 590* 592 593 635* 636 638* 650 650* 663 663 663 667 668 671* 673 673* 734* 735 737 737 740 742 743 743 748* 749 750 750 831 831* q 000436 automatic pointer dcl 849 in procedure "process_jump_target" set ref 862* 863 867 868 869* 869 q 000102 automatic pointer dcl 1216 in procedure "erase" set ref 1218* 1220 1221 1228 1233* 1235* q 000412 automatic pointer dcl 803 in procedure "check" set ref 812* 812* 813* 814 q 000104 automatic pointer dcl 1260 in procedure "intersection" set ref 1268* 1268* 1270 1278* 1279 1281* 1282* 1306* 1307* 1308 1309 1314* 1314 1320* 1335 q 000102 automatic pointer dcl 965 in procedure "set" set ref 985* 986 987 988 992 993* 994* 997* 997 1018* 1019 1020 1023 1024* 1025* 1027* 1027 1041* 1042 1043 1046 1047* 1048* 1050* 1050 1062* 1064 1065 1070 1071* 1072* 1075* 1075 1083* 1084 1085 1088* 1091* 1091 1102* 1103 1104 1112 1113* 1114* 1116* 1116 1127 1134 q1 000106 automatic pointer dcl 965 set ref 987* 988* 992* 994 1023* 1025 1046* 1048 1065* 1066 1066 1066 1066 1070* 1072 1104* 1105 1106 1108 1112* 1114 qualifier 4 based pointer level 2 packed packed unaligned dcl 14-3 set ref 238 495 495 776 776* 794 917 917 1005 real 31(30) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 18-24 18-24 record_io constant bit(9) initial dcl 15-8 ref 340 ref_count 0(18) based fixed bin(17,0) level 2 packed packed unaligned dcl 14-3 set ref 243 272* 272 303* 374* 377* 377 ref_count_copy 7(18) based fixed bin(17,0) level 2 packed packed unaligned dcl 8-9 set ref 853 853* 855* 855 1272 1272* 1275 1287 reference based structure level 1 dcl 14-3 in procedure "optimizer" reference 15 based pointer level 2 in structure "symbol" packed packed unaligned dcl 10-3 in procedure "optimizer" ref 243 249 979 reference_count 7 based fixed bin(17,0) level 2 packed packed unaligned dcl 8-9 ref 853 1272 reference_list 5 based pointer level 2 packed packed unaligned dcl 8-9 set ref 864 866* 1278 1280 1282* 1293 1303 1307 1330 1332* reference_node constant bit(9) initial dcl 17-5 ref 206 350 495 556 570 594 627 740 808 910 973 return_bits constant bit(9) initial dcl 15-8 ref 343 346 return_statement constant bit(9) initial dcl 16-3 ref 105 return_string constant bit(9) initial dcl 15-8 ref 346 return_value 32(18) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 663 return_words constant bit(9) initial dcl 15-8 ref 343 346 root 3 based pointer level 2 in structure "statement" packed packed unaligned dcl 8-9 in procedure "optimizer" set ref 103* root parameter pointer dcl 16 in procedure "optimizer" ref 14 72 s 000112 automatic pointer dcl 965 set ref 976* 977 979 981* 981 s1 000112 automatic pointer dcl 194 set ref 667* 668 668 668 668 742* 743 743 743 748 s_list 000010 internal static pointer dcl 24 set ref 71* 928 940* 985 993* 1018 1024* 1041 1047* 1062 1071* 1083 1088* 1102 1113* 1218 1233* 1235 1354 scale 2(28) based fixed bin(7,0) level 2 packed packed unaligned dcl 10-3 ref 18-24 18-24 secondary based structure level 1 dcl 37 set_level 000110 automatic fixed bin(17,0) dcl 18 set ref 70* 978* 978 980* 980 1029 sets_operand1 000121 automatic bit(1) dcl 197 set ref 346* 627 sets_reference 000130 automatic bit(1) dcl 197 set ref 624* 634* 661 693 shared 0(11) based bit(1) level 2 packed packed unaligned dcl 14-3 set ref 283 299 302* 370 373* 410 433 461 529 573 636 650 673 808 831 signal_on constant bit(9) initial dcl 15-8 ref 340 signal_op 000122 automatic bit(1) dcl 197 set ref 340* 343 388 son 21 based pointer level 2 in structure "symbol" packed packed unaligned dcl 10-3 in procedure "optimizer" ref 976 18-45 18-56 son 3 based pointer level 2 in structure "block" packed packed unaligned dcl 7-5 in procedure "optimizer" ref 72 73 75 source_id 0(09) based structure level 2 packed packed unaligned dcl 8-9 ref 83 856 856 stacq_fun constant bit(9) initial dcl 15-8 ref 340 454 464 start parameter fixed bin(15,0) dcl 884 ref 881 904 915 922 state 000100 automatic pointer dcl 1260 set ref 1263* 1268 1272 1272 1272 1275 1278 1280 1282 1287 1287 1293 1303 1307 1330 1332 state_is_discarded 000113 automatic bit(1) dcl 19 set ref 80* 92* 103 105* 756* 1291 1299* 1321 1339* statement 2 based pointer level 2 in structure "primary" packed packed unaligned dcl 28 in procedure "optimizer" set ref 311* 648* 868* 868 1296* 1296 1326* 1326 statement 11 based pointer level 2 in structure "label" packed packed unaligned dcl 12-1 in procedure "optimizer" ref 737 743 748 statement based structure level 1 dcl 8-9 in procedure "optimizer" statement_type 12(27) based bit(9) level 2 in structure "statement" packed packed unaligned dcl 8-9 in procedure "optimizer" ref 88 statement_type 000114 automatic bit(9) dcl 20 in procedure "optimizer" set ref 88* 89 94 94 105 105 107 std_call constant bit(9) initial dcl 15-8 ref 533 614 std_entry constant bit(9) initial dcl 15-8 ref 346 stm 000102 automatic pointer dcl 17 set ref 79* 81* 81 81* 82 83 85* 85* 88 97 99* 100* 103 103* 110 761 stop_statement constant bit(9) initial dcl 16-3 ref 105 storage_block 31(12) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 1060 storage_class 32(09) based structure level 3 packed packed unaligned dcl 10-3 stream_prep constant bit(9) initial dcl 15-8 ref 340 string builtin function dcl 53 ref 83 83 856 856 18-24 18-24 structure 31 based bit(1) level 4 packed packed unaligned dcl 10-3 ref 18-44 18-55 symbol 3 based pointer level 2 in structure "reference" packed packed unaligned dcl 14-3 in procedure "optimizer" ref 208 528 556 581 663 663 663 667 685 742 912 932 932 974 987 1020 1043 1066 1085 1105 18-24 18-24 symbol based structure level 1 dcl 10-3 in procedure "optimizer" symbol_node constant bit(9) initial dcl 17-5 ref 209 293 663 913 975 t 000106 automatic pointer dcl 1260 set ref 1280* 1281* 1282 1294* 1295 1296 1297 1324* 1325 1326 1327 1330* 1331* 1332 temporary 32(17) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 238 293 583 663 685 924 terminate_trans constant bit(9) initial dcl 15-8 ref 340 tp 000114 automatic pointer dcl 194 set ref 527* 528 528 529 529* 569* 570 573 573* 593* 594 594* type based bit(9) level 2 packed packed unaligned dcl 17-27 ref 206 209 293 315 322 350 361 495 556 570 580 594 627 643 663 735 740 743 808 895 902 910 913 973 975 units 0(14) based fixed bin(3,0) level 2 packed packed unaligned dcl 14-3 ref 243 243 unsigned 31(24) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 18-24 18-24 value 1 based pointer level 2 packed packed unaligned dcl 46 set ref 119 719* 957* 1130 1223 1223 variable 31(32) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 583 varying 31(26) based bit(1) level 4 packed packed unaligned dcl 10-3 ref 18-24 18-24 vclock_fun constant bit(9) initial dcl 15-8 ref 343 word_ constant fixed bin(3,0) initial dcl 11-5 ref 243 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. a_format internal static bit(9) initial dcl 15-8 abs_fun internal static bit(9) initial dcl 15-8 acos_fun internal static bit(9) initial dcl 15-8 acosd_fun internal static bit(9) initial dcl 15-8 add internal static bit(9) initial dcl 15-8 addbitno_fun internal static bit(9) initial dcl 15-8 addcharno_fun internal static bit(9) initial dcl 15-8 addrel_fun internal static bit(9) initial dcl 15-8 allocate_statement internal static bit(9) initial dcl 16-3 allocation_fun internal static bit(9) initial dcl 15-8 allot_var internal static bit(9) initial dcl 15-8 and_bits internal static bit(9) initial dcl 15-8 array_node internal static bit(9) initial dcl 17-5 asin_fun internal static bit(9) initial dcl 15-8 asind_fun internal static bit(9) initial dcl 15-8 assign internal static bit(9) initial dcl 15-8 assign_by_name internal static bit(9) initial dcl 15-8 assign_round internal static bit(9) initial dcl 15-8 assign_size_ck internal static bit(9) initial dcl 15-8 assign_zero internal static bit(9) initial dcl 15-8 assignment_statement internal static bit(9) initial dcl 16-3 atan_fun internal static bit(9) initial dcl 15-8 atand_fun internal static bit(9) initial dcl 15-8 b_format internal static bit(9) initial dcl 15-8 baseno_fun internal static bit(9) initial dcl 15-8 baseptr_fun internal static bit(9) initial dcl 15-8 binary_to_octal_string 000000 constant entry external dcl 1-38 binary_to_octal_var_string 000000 constant entry external dcl 1-43 bindec 000000 constant entry external dcl 1-23 bindec$vs 000000 constant entry external dcl 1-28 binoct 000000 constant entry external dcl 1-33 bit_ internal static fixed bin(3,0) initial dcl 11-5 bit_pointer internal static bit(9) initial dcl 15-8 bit_to_char internal static bit(9) initial dcl 15-8 bit_to_word internal static bit(9) initial dcl 15-8 bitno_fun internal static bit(9) initial dcl 15-8 block_node internal static bit(9) initial dcl 17-5 bn_format internal static bit(9) initial dcl 15-8 bool_fun internal static bit(9) initial dcl 15-8 bound_ck internal static bit(9) initial dcl 15-8 bound_node internal static bit(9) initial dcl 17-5 by_name_agg_node internal static bit(9) initial dcl 17-5 byte_fun internal static bit(9) initial dcl 15-8 c_format internal static bit(9) initial dcl 15-8 call_statement internal static bit(9) initial dcl 16-3 cat_string internal static bit(9) initial dcl 15-8 ceil_fun internal static bit(9) initial dcl 15-8 char_to_word internal static bit(9) initial dcl 15-8 character_ internal static fixed bin(3,0) initial dcl 11-5 charno_fun internal static bit(9) initial dcl 15-8 clock_fun internal static bit(9) initial dcl 15-8 close_statement internal static bit(9) initial dcl 16-3 codeptr_fun internal static bit(9) initial dcl 15-8 column_format internal static bit(9) initial dcl 15-8 complex_fun internal static bit(9) initial dcl 15-8 conjg_fun internal static bit(9) initial dcl 15-8 constant_length 000000 constant entry external dcl 1-54 context_node internal static bit(9) initial dcl 17-5 continue_statement internal static bit(9) initial dcl 16-3 convert 000000 constant entry external dcl 1-60 convert$from_builtin 000000 constant entry external dcl 1-72 convert$to_integer 000000 constant entry external dcl 1-66 convert$to_target 000000 constant entry external dcl 1-88 convert$to_target_fb 000000 constant entry external dcl 1-82 convert$validate 000000 constant entry external dcl 1-78 copy_expression$copy_sons 000000 constant entry external dcl 1-99 copy_string internal static bit(9) initial dcl 15-8 copy_unique_expression 000000 constant entry external dcl 1-103 copy_words internal static bit(9) initial dcl 15-8 cos_fun internal static bit(9) initial dcl 15-8 cosd_fun internal static bit(9) initial dcl 15-8 create_array 000000 constant entry external dcl 1-108 create_block 000000 constant entry external dcl 1-112 create_bound 000000 constant entry external dcl 1-118 create_context 000000 constant entry external dcl 1-122 create_cross_reference 000000 constant entry external dcl 1-128 create_default 000000 constant entry external dcl 1-132 create_identifier 000000 constant entry external dcl 1-136 create_label 000000 constant entry external dcl 1-140 create_operator 000000 constant entry external dcl 1-152 create_reference 000000 constant entry external dcl 1-158 create_statement 000000 constant entry external dcl 1-163 create_statement$prologue 000000 constant entry external dcl 1-171 create_storage 000000 constant entry external dcl 1-179 create_symbol 000000 constant entry external dcl 1-184 create_token 000000 constant entry external dcl 1-191 create_token$init_hash_table 000000 constant entry external dcl 1-197 create_token$protected 000000 constant entry external dcl 1-199 cross_reference_node internal static bit(9) initial dcl 17-5 decbin 000000 constant entry external dcl 1-206 declare_constant 000000 constant entry external dcl 1-211 declare_constant$bit 000000 constant entry external dcl 1-219 declare_constant$char 000000 constant entry external dcl 1-224 declare_constant$desc 000000 constant entry external dcl 1-229 declare_constant$integer 000000 constant entry external dcl 1-234 declare_descriptor 000000 constant entry external dcl 1-239 declare_descriptor$ctl 000000 constant entry external dcl 1-249 declare_descriptor$param 000000 constant entry external dcl 1-259 declare_integer 000000 constant entry external dcl 1-269 declare_picture 000000 constant entry external dcl 1-274 declare_picture_temp 000000 constant entry external dcl 1-279 declare_pointer 000000 constant entry external dcl 1-287 declare_statement internal static bit(9) initial dcl 16-3 declare_temporary 000000 constant entry external dcl 1-292 decode_source_id 000000 constant entry external dcl 1-306 default_node internal static bit(9) initial dcl 17-5 default_statement internal static bit(9) initial dcl 16-3 delete_file internal static bit(9) initial dcl 15-8 delete_statement internal static bit(9) initial dcl 16-3 desc_size internal static bit(9) initial dcl 15-8 digit_ internal static fixed bin(3,0) initial dcl 11-5 digit_to_bit internal static bit(9) initial dcl 15-8 display_statement internal static bit(9) initial dcl 16-3 div internal static bit(9) initial dcl 15-8 do_fun internal static bit(9) initial dcl 15-8 do_spec internal static bit(9) initial dcl 15-8 do_statement internal static bit(9) initial dcl 16-3 e_format internal static bit(9) initial dcl 15-8 else_clause internal static bit(9) initial dcl 16-3 enable_on internal static bit(9) initial dcl 15-8 end_statement internal static bit(9) initial dcl 16-3 environmentptr_fun internal static bit(9) initial dcl 15-8 equal internal static bit(9) initial dcl 15-8 error 000000 constant entry external dcl 1-314 error$omit_text 000000 constant entry external dcl 1-319 error_ 000000 constant entry external dcl 1-324 error_$finish 000000 constant entry external dcl 1-343 error_$initialize_error 000000 constant entry external dcl 1-341 error_$no_text 000000 constant entry external dcl 1-334 ex_prologue internal static bit(9) initial dcl 15-8 exit_statement internal static bit(9) initial dcl 16-3 exp internal static bit(9) initial dcl 15-8 exp_fun internal static bit(9) initial dcl 15-8 f_format internal static bit(9) initial dcl 15-8 floor_fun internal static bit(9) initial dcl 15-8 format_value_node internal static bit(9) initial dcl 17-5 fortran_write internal static bit(9) initial dcl 15-8 free_node 000000 constant entry external dcl 1-345 free_statement internal static bit(9) initial dcl 16-3 free_var internal static bit(9) initial dcl 15-8 ftn_file_manip internal static bit(9) initial dcl 15-8 get_array_size 000000 constant entry external dcl 1-348 get_file internal static bit(9) initial dcl 15-8 get_size 000000 constant entry external dcl 1-352 get_statement internal static bit(9) initial dcl 16-3 get_string internal static bit(9) initial dcl 15-8 goto_statement internal static bit(9) initial dcl 16-3 greater_or_equal internal static bit(9) initial dcl 15-8 greater_than internal static bit(9) initial dcl 15-8 half_ internal static fixed bin(3,0) initial dcl 11-5 half_to_word internal static bit(9) initial dcl 15-8 if_statement internal static bit(9) initial dcl 16-3 imag_fun internal static bit(9) initial dcl 15-8 index_after_fun internal static bit(9) initial dcl 15-8 index_before_fun internal static bit(9) initial dcl 15-8 index_fun internal static bit(9) initial dcl 15-8 index_rev_fun internal static bit(9) initial dcl 15-8 jump_false internal static bit(9) initial dcl 15-8 jump_if_eq internal static bit(9) initial dcl 15-8 jump_if_gt internal static bit(9) initial dcl 15-8 jump_if_le internal static bit(9) initial dcl 15-8 jump_if_lt internal static bit(9) initial dcl 15-8 jump_if_ne internal static bit(9) initial dcl 15-8 jump_true internal static bit(9) initial dcl 15-8 l_parn internal static bit(9) initial dcl 15-8 label_array_element_node internal static bit(9) initial dcl 17-5 length_fun internal static bit(9) initial dcl 15-8 less_or_equal internal static bit(9) initial dcl 15-8 less_than internal static bit(9) initial dcl 15-8 line_format internal static bit(9) initial dcl 15-8 locate_file internal static bit(9) initial dcl 15-8 locate_statement internal static bit(9) initial dcl 16-3 lock_file internal static bit(9) initial dcl 15-8 lock_statement internal static bit(9) initial dcl 16-3 log10_fun internal static bit(9) initial dcl 15-8 log2_fun internal static bit(9) initial dcl 15-8 log_fun internal static bit(9) initial dcl 15-8 machine_state_node internal static bit(9) initial dcl 17-5 make_desc internal static bit(9) initial dcl 15-8 max_block_number internal static fixed bin(17,0) initial dcl 7-74 max_fun internal static bit(9) initial dcl 15-8 max_list_elements internal static fixed bin(17,0) initial dcl 13-12 max_number_of_operands internal static fixed bin(15,0) initial dcl 9-15 merge_attributes 000000 constant entry external dcl 1-355 min_fun internal static bit(9) initial dcl 15-8 mod2_ internal static fixed bin(3,0) initial dcl 11-5 mod4_ internal static fixed bin(3,0) initial dcl 11-5 mod_bit internal static bit(9) initial dcl 15-8 mod_byte internal static bit(9) initial dcl 15-8 mod_fun internal static bit(9) initial dcl 15-8 mod_half internal static bit(9) initial dcl 15-8 mod_word internal static bit(9) initial dcl 15-8 mult internal static bit(9) initial dcl 15-8 n automatic fixed bin(15,0) dcl 26 negate internal static bit(9) initial dcl 15-8 not_bits internal static bit(9) initial dcl 15-8 not_equal internal static bit(9) initial dcl 15-8 null_statement internal static bit(9) initial dcl 16-3 off_fun internal static bit(9) initial dcl 15-8 on_statement internal static bit(9) initial dcl 16-3 open_statement internal static bit(9) initial dcl 16-3 optimizer 000000 constant entry external dcl 1-361 or_bits internal static bit(9) initial dcl 15-8 pack internal static bit(9) initial dcl 15-8 page_format internal static bit(9) initial dcl 15-8 param_desc_ptr internal static bit(9) initial dcl 15-8 param_ptr internal static bit(9) initial dcl 15-8 parse_error 000000 constant entry external dcl 1-364 parse_error$no_text 000000 constant entry external dcl 1-368 picture_char_type internal static fixed bin(8,0) initial packed unaligned dcl 19-20 picture_complexfix_type internal static fixed bin(8,0) initial packed unaligned dcl 19-20 picture_complexflo_type internal static fixed bin(8,0) initial packed unaligned dcl 19-20 picture_format internal static bit(9) initial dcl 15-8 picture_realfix_type internal static fixed bin(8,0) initial packed unaligned dcl 19-20 picture_realflo_type internal static fixed bin(8,0) initial packed unaligned dcl 19-20 pl1_error_print$listing_segment 000000 constant entry external dcl 1-384 pl1_error_print$write_out 000000 constant entry external dcl 1-372 pl1_mod_fun internal static bit(9) initial dcl 15-8 pl1_print$for_lex 000000 constant entry external dcl 1-418 pl1_print$non_varying 000000 constant entry external dcl 1-398 pl1_print$non_varying_nl 000000 constant entry external dcl 1-402 pl1_print$string_pointer 000000 constant entry external dcl 1-406 pl1_print$string_pointer_nl 000000 constant entry external dcl 1-410 pl1_print$unaligned_nl 000000 constant entry external dcl 1-414 pl1_print$varying 000000 constant entry external dcl 1-392 pl1_print$varying_nl 000000 constant entry external dcl 1-395 prefix_plus internal static bit(9) initial dcl 15-8 ptr_fun internal static bit(9) initial dcl 15-8 put_control internal static bit(9) initial dcl 15-8 put_edit_trans internal static bit(9) initial dcl 15-8 put_field internal static bit(9) initial dcl 15-8 put_field_chk internal static bit(9) initial dcl 15-8 put_file internal static bit(9) initial dcl 15-8 put_list_trans internal static bit(9) initial dcl 15-8 put_statement internal static bit(9) initial dcl 16-3 put_string internal static bit(9) initial dcl 15-8 r_format internal static bit(9) initial dcl 15-8 r_parn internal static bit(9) initial dcl 15-8 range_ck internal static bit(9) initial dcl 15-8 rank_fun internal static bit(9) initial dcl 15-8 read_file internal static bit(9) initial dcl 15-8 read_statement internal static bit(9) initial dcl 16-3 real_fun internal static bit(9) initial dcl 15-8 refer internal static bit(9) initial dcl 15-8 refer_extent 000000 constant entry external dcl 1-426 rel_fun internal static bit(9) initial dcl 15-8 repeat_fun internal static bit(9) initial dcl 15-8 reserve$clear 000000 constant entry external dcl 1-430 reserve$declare_lib 000000 constant entry external dcl 1-434 reserve$read_lib 000000 constant entry external dcl 1-439 return_value internal static bit(9) initial dcl 15-8 reverse_fun internal static bit(9) initial dcl 15-8 revert_on internal static bit(9) initial dcl 15-8 revert_statement internal static bit(9) initial dcl 16-3 rewrite_file internal static bit(9) initial dcl 15-8 rewrite_statement internal static bit(9) initial dcl 16-3 round_fun internal static bit(9) initial dcl 15-8 search_fun internal static bit(9) initial dcl 15-8 search_rev_fun internal static bit(9) initial dcl 15-8 segno_fun internal static bit(9) initial dcl 15-8 semantic_translator 000000 constant entry external dcl 1-444 semantic_translator$abort 000000 constant entry external dcl 1-446 semantic_translator$error 000000 constant entry external dcl 1-450 setbitno_fun internal static bit(9) initial dcl 15-8 setcharno_fun internal static bit(9) initial dcl 15-8 sf_par_node internal static bit(9) initial dcl 17-5 share_expression 000000 constant entry external dcl 1-454 sign_fun internal static bit(9) initial dcl 15-8 signal_statement internal static bit(9) initial dcl 16-3 sin_fun internal static bit(9) initial dcl 15-8 sind_fun internal static bit(9) initial dcl 15-8 skip_format internal static bit(9) initial dcl 15-8 source_node internal static bit(9) initial dcl 17-5 sqrt_fun internal static bit(9) initial dcl 15-8 stack_ptr internal static bit(9) initial dcl 15-8 stackbaseptr_fun internal static bit(9) initial dcl 15-8 stackframeptr_fun internal static bit(9) initial dcl 15-8 statement_node internal static bit(9) initial dcl 17-5 std_arg_list internal static bit(9) initial dcl 15-8 std_return internal static bit(9) initial dcl 15-8 stop internal static bit(9) initial dcl 15-8 sub internal static bit(9) initial dcl 15-8 substr builtin function dcl 53 system_on_unit internal static bit(9) initial dcl 16-3 tan_fun internal static bit(9) initial dcl 15-8 tand_fun internal static bit(9) initial dcl 15-8 temporary_node internal static bit(9) initial dcl 17-5 token_node internal static bit(9) initial dcl 17-5 token_to_binary 000000 constant entry external dcl 1-459 translate_fun internal static bit(9) initial dcl 15-8 trunc_fun internal static bit(9) initial dcl 15-8 unknown_statement internal static bit(9) initial dcl 16-3 unlock_file internal static bit(9) initial dcl 15-8 unlock_statement internal static bit(9) initial dcl 16-3 unpack internal static bit(9) initial dcl 15-8 verify_fun internal static bit(9) initial dcl 15-8 verify_ltrim_fun internal static bit(9) initial dcl 15-8 verify_rev_fun internal static bit(9) initial dcl 15-8 verify_rtrim_fun internal static bit(9) initial dcl 15-8 wait_statement internal static bit(9) initial dcl 16-3 word_to_mod2 internal static bit(9) initial dcl 15-8 word_to_mod4 internal static bit(9) initial dcl 15-8 word_to_mod8 internal static bit(9) initial dcl 15-8 wordno_fun internal static bit(9) initial dcl 15-8 write_file internal static bit(9) initial dcl 15-8 write_statement internal static bit(9) initial dcl 16-3 x_format internal static bit(9) initial dcl 15-8 xor_bits internal static bit(9) initial dcl 15-8 NAMES DECLARED BY EXPLICIT CONTEXT. begin 000530 constant label dcl 203 in procedure "reduce" begin 006250 constant label dcl 1263 in procedure "intersection" begin 004170 constant label dcl 892 in procedure "record_secondaries" begin 000034 constant label dcl 68 in procedure "optimizer" begin 004534 constant label dcl 970 in procedure "set" begin 006120 constant label dcl 1218 in procedure "erase" begin 005341 constant label dcl 1127 in procedure "free_them" begin 005720 constant label dcl 1153 in procedure "release_node" begin 006006 constant label dcl 1183 in procedure "create_node" bit_overlay 005624 constant entry internal dcl 18-39 ref 18-15 18-15 chain_it 004466 constant label dcl 947 ref 931 932 char_overlay 005655 constant entry internal dcl 18-50 ref 18-15 18-15 check 003727 constant entry internal dcl 801 ref 794 794 794 check_and_reduce_target 003775 constant entry internal dcl 827 ref 414 450 469 clear 006062 constant entry internal dcl 1201 ref 91 112 121 1277 compare_alias 005410 constant entry internal dcl 18-8 ref 988 continue 006202 constant label dcl 1233 ref 1229 create_node 006001 constant entry internal dcl 1178 ref 309 646 865 940 1294 1324 dump_primary 000403 constant entry external dcl 1345 dump_secondary 000453 constant entry external dcl 1353 equal_types 005460 constant entry internal dcl 18-19 ref 18-15 erase 006113 constant entry internal dcl 1214 ref 107 394 585 1203 external_call 005237 constant entry internal dcl 1098 ref 402 413 422 438 449 466 476 599 free_them 005340 constant entry internal dcl 1123 ref 991 1022 1045 1069 1087 1111 intersection 006243 constant entry internal dcl 1258 ref 99 100 858 next 006647 constant label dcl 1336 in procedure "intersection" ref 1312 next 004670 constant label dcl 998 in procedure "set" ref 995 next_a 005173 constant label dcl 1076 ref 1073 next_block 000363 constant label dcl 134 ref 127 ok 003772 constant label dcl 817 ref 807 808 813 optimizer 000027 constant entry external dcl 14 process_jump_target 004043 constant entry internal dcl 847 ref 737 743 750 record_secondaries 004163 constant entry internal dcl 881 ref 312 649 650 685 898 905 917 918 919 1297 1327 reduce 000523 constant entry internal dcl 191 ref 103 120 318 331 408 420 423 440 444 457 474 484 489 504 510 523 570 606 616 695 774 776 778 838 reduce_ref_sons 003566 constant entry internal dcl 768 ref 286 410 433 461 485 529 573 638 release_node 005713 constant entry internal dcl 1148 ref 993 1024 1047 1071 1088 1113 1130 1223 1233 1281 1331 1334 scan 000054 constant label dcl 73 ref 143 set 004527 constant entry internal dcl 963 ref 399 412 421 445 448 464 467 490 495 509 594 671 979 1005 sons_were_set 003664 constant entry internal dcl 788 ref 673 831 statements 000063 constant label dcl 77 ref 140 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 7240 7316 7001 7250 Length 10160 7001 56 626 236 20 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME optimizer 144 external procedure is an external procedure. reduce 380 internal procedure calls itself recursively. reduce_ref_sons internal procedure shares stack frame of internal procedure reduce. sons_were_set internal procedure shares stack frame of internal procedure reduce. check internal procedure shares stack frame of internal procedure reduce. check_and_reduce_target internal procedure shares stack frame of internal procedure reduce. process_jump_target internal procedure shares stack frame of internal procedure reduce. record_secondaries 126 internal procedure calls itself recursively. set 159 internal procedure calls itself recursively. free_them internal procedure shares stack frame of internal procedure set. compare_alias internal procedure shares stack frame of internal procedure set. equal_types internal procedure shares stack frame of internal procedure set. bit_overlay internal procedure shares stack frame of internal procedure set. char_overlay internal procedure shares stack frame of internal procedure set. release_node 66 internal procedure is called by several nonquick procedures. create_node 74 internal procedure is called by several nonquick procedures. clear 66 internal procedure is called by several nonquick procedures. erase 82 internal procedure is called by several nonquick procedures. intersection 90 internal procedure is called by several nonquick procedures. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 s_list optimizer 000012 p_list optimizer 000014 free optimizer 000016 freec optimizer 000020 p_tail optimizer 000022 freep optimizer 000024 freep_tail optimizer 000026 l_list optimizer STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME create_node 000100 p create_node erase 000100 p erase 000102 q erase intersection 000100 state intersection 000102 p intersection 000104 q intersection 000106 t intersection 000110 i intersection 000111 n intersection optimizer 000100 blk optimizer 000102 stm optimizer 000104 p optimizer 000106 q optimizer 000110 set_level optimizer 000111 doing_loop optimizer 000112 inhibit_walk optimizer 000113 state_is_discarded optimizer 000114 statement_type optimizer record_secondaries 000100 p record_secondaries 000102 q record_secondaries 000104 p1 record_secondaries 000106 p2 record_secondaries 000110 i record_secondaries reduce 000100 p reduce 000102 q reduce 000104 p1 reduce 000106 p2 reduce 000110 p3 reduce 000112 s1 reduce 000114 tp reduce 000116 i reduce 000117 j reduce 000120 opcode reduce 000121 sets_operand1 reduce 000122 signal_op reduce 000123 new_primary reduce 000124 irreducible_op reduce 000125 jump_op reduce 000126 irreducible_entry reduce 000127 addr_op reduce 000130 sets_reference reduce 000131 irreducible_sons reduce 000132 inhibit_sons reduce 000133 irreducible_2 reduce 000370 p reduce_ref_sons 000400 p sons_were_set 000410 p check 000412 q check 000430 p1 process_jump_target 000432 p2 process_jump_target 000434 p4 process_jump_target 000436 q process_jump_target release_node 000100 p release_node set 000100 p set 000102 q set 000104 p1 set 000106 q1 set 000110 p2 set 000112 s set 000114 c_offset set 000115 p1_unal set 000116 free_flag set 000126 p1 free_them 000136 a compare_alias 000140 b compare_alias 000156 p bit_overlay 000166 p char_overlay THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as r_ne_as r_ge_s r_le_s unpk_to_pk call_ext_out_desc call_ext_out call_int_this call_int_other return_mac ext_entry int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. adjust_count compare_expression copy_expression create_list debug decode_node_id display_exp ioa_ ioa_$nnl THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. pl1_stat_$cur_statement pl1_stat_$stop_id LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 14 000024 68 000034 70 000035 71 000036 72 000047 73 000054 75 000060 76 000062 77 000063 79 000064 80 000071 81 000072 82 000100 83 000103 85 000107 86 000152 88 000157 89 000163 91 000165 92 000171 93 000172 94 000173 97 000177 99 000202 100 000214 103 000226 105 000250 107 000260 110 000266 111 000272 112 000301 116 000305 117 000310 118 000314 119 000316 120 000321 121 000340 122 000344 124 000350 125 000353 126 000355 127 000357 129 000360 130 000362 134 000363 137 000372 139 000375 140 000377 142 000400 143 000401 1345 000402 1347 000410 1348 000420 1349 000432 1350 000445 1351 000451 1353 000452 1354 000460 1355 000470 1356 000502 1357 000515 1358 000521 191 000522 203 000530 205 000537 206 000543 208 000550 209 000552 231 000556 238 000605 243 000621 249 000647 250 000651 252 000675 258 000676 259 000700 262 000706 263 000712 264 000715 266 000721 271 000737 272 000746 273 000753 274 000762 276 000763 277 000766 282 000767 283 000770 286 000776 288 001000 289 001004 293 001016 299 001026 301 001031 302 001043 303 001045 304 001050 309 001057 310 001075 311 001100 312 001104 313 001117 315 001120 317 001122 318 001133 319 001151 320 001153 322 001154 326 001156 328 001162 330 001164 331 001175 332 001213 333 001215 334 001220 339 001221 340 001231 343 001324 346 001405 348 001430 350 001441 353 001450 360 001453 361 001455 363 001470 364 001474 365 001477 367 001503 369 001521 370 001524 372 001527 373 001545 374 001547 376 001552 377 001561 378 001567 379 001576 381 001577 382 001602 388 001603 390 001605 392 001606 394 001611 397 001623 398 001625 399 001637 400 001650 402 001652 403 001657 406 001660 408 001664 409 001703 410 001706 412 001713 413 001722 414 001727 415 001733 418 001734 420 001736 421 001755 422 001767 423 001774 424 002013 427 002014 429 002016 433 002021 438 002026 440 002033 442 002052 444 002056 445 002074 448 002106 449 002115 450 002122 451 002126 454 002127 456 002133 457 002145 458 002163 460 002165 461 002170 464 002175 466 002213 467 002220 469 002227 470 002233 473 002234 474 002245 475 002263 476 002265 477 002272 482 002273 484 002276 485 002315 487 002322 489 002326 490 002344 495 002356 498 002376 501 002377 503 002401 504 002407 505 002425 506 002427 507 002432 509 002447 510 002460 511 002477 512 002501 519 002502 522 002511 523 002512 524 002531 525 002534 527 002535 528 002540 529 002546 533 002553 555 002556 556 002561 558 002573 560 002575 561 002577 563 002601 564 002604 566 002610 568 002612 569 002623 570 002625 573 002651 576 002656 579 002660 580 002663 581 002671 583 002674 585 002702 586 002707 588 002710 590 002714 592 002717 593 002731 594 002733 596 002746 599 002750 602 002755 605 002756 606 002761 614 003003 616 003017 617 003035 623 003037 624 003043 627 003046 634 003061 635 003063 636 003065 638 003070 639 003072 640 003075 643 003076 645 003112 646 003114 647 003132 648 003135 649 003141 650 003154 661 003171 663 003173 667 003204 668 003207 671 003237 673 003246 685 003261 693 003321 694 003324 695 003335 699 003362 700 003366 706 003370 710 003404 712 003411 713 003423 715 003427 716 003431 717 003434 718 003437 719 003440 732 003442 734 003444 735 003447 737 003454 739 003465 740 003466 742 003470 743 003472 748 003515 749 003517 750 003531 752 003541 756 003543 761 003551 765 003565 768 003566 773 003570 774 003573 776 003615 778 003640 781 003663 788 003664 792 003666 794 003671 799 003723 801 003727 805 003731 807 003734 808 003740 812 003747 813 003756 814 003763 816 003766 817 003772 827 003775 831 003777 835 004012 837 004015 838 004020 839 004040 842 004042 847 004043 851 004045 853 004050 855 004062 856 004064 858 004076 861 004115 862 004117 863 004121 864 004126 865 004131 866 004145 867 004150 868 004154 869 004156 870 004160 873 004161 881 004162 892 004170 894 004174 895 004200 897 004205 898 004217 899 004234 900 004236 902 004237 904 004241 905 004253 906 004270 907 004272 910 004273 912 004275 913 004277 915 004303 917 004305 918 004325 919 004346 922 004367 924 004372 928 004376 929 004401 930 004406 931 004411 932 004415 935 004437 936 004442 940 004443 941 004461 942 004464 947 004466 950 004473 951 004505 953 004511 954 004513 955 004516 956 004522 957 004523 958 004525 963 004526 970 004534 972 004540 973 004544 974 004550 975 004553 976 004557 977 004561 978 004566 979 004570 980 004602 981 004605 982 004610 983 004611 985 004615 986 004620 987 004624 988 004630 991 004640 992 004641 993 004644 994 004662 995 004664 997 004665 998 004670 1000 004671 1005 004672 1013 004707 1015 004721 1016 004726 1018 004740 1019 004743 1020 004750 1022 004756 1023 004757 1024 004762 1025 005000 1026 005002 1027 005003 1028 005006 1029 005007 1031 005012 1032 005015 1033 005016 1039 005017 1041 005036 1042 005041 1043 005046 1045 005053 1046 005054 1047 005057 1048 005075 1049 005077 1050 005100 1051 005103 1052 005104 1060 005105 1062 005112 1063 005115 1064 005120 1065 005124 1066 005127 1069 005143 1070 005144 1071 005147 1072 005165 1073 005167 1075 005170 1076 005173 1078 005174 1083 005175 1084 005200 1085 005204 1087 005211 1088 005212 1089 005230 1091 005231 1092 005234 1093 005235 1098 005236 1102 005244 1103 005247 1104 005254 1105 005257 1106 005262 1108 005273 1109 005304 1111 005306 1112 005307 1113 005312 1114 005330 1115 005332 1116 005333 1117 005336 1118 005337 1123 005340 1127 005341 1129 005344 1130 005350 1131 005371 1133 005375 1134 005400 1135 005403 1137 005404 1138 005406 1140 005407 18 8 005410 18 13 005412 18 14 005415 18 15 005420 18 17 005455 18 19 005460 18 24 005462 18 35 005617 18 36 005622 18 39 005624 18 43 005626 18 44 005631 18 45 005636 18 46 005640 18 47 005641 18 50 005655 18 54 005657 18 55 005662 18 56 005666 18 57 005670 18 58 005671 1148 005712 1153 005720 1155 005724 1157 005727 1159 005735 1161 005743 1162 005746 1164 005751 1165 005756 1166 005760 1167 005762 1168 005763 1169 005771 1171 005772 1172 005774 1174 005775 1175 005777 1178 006000 1183 006006 1187 006025 1188 006027 1190 006031 1191 006034 1192 006040 1193 006051 1194 006056 1195 006057 1201 006061 1203 006067 1204 006074 1206 006101 1207 006104 1208 006106 1210 006111 1214 006112 1218 006120 1220 006122 1221 006126 1222 006131 1223 006136 1225 006164 1227 006170 1228 006173 1229 006176 1231 006177 1232 006201 1233 006202 1235 006220 1236 006223 1243 006224 1245 006231 1246 006234 1247 006236 1249 006241 1258 006242 1263 006250 1265 006254 1267 006256 1268 006257 1269 006266 1270 006267 1272 006273 1275 006303 1277 006317 1278 006324 1279 006327 1280 006334 1281 006337 1282 006353 1283 006357 1284 006360 1287 006361 1291 006371 1293 006404 1294 006412 1295 006430 1296 006434 1297 006436 1298 006453 1299 006457 1300 006461 1303 006462 1304 006470 1305 006473 1306 006500 1307 006507 1308 006512 1309 006516 1311 006523 1312 006525 1314 006526 1315 006530 1320 006531 1321 006534 1324 006542 1325 006560 1326 006564 1327 006566 1328 006603 1330 006604 1331 006607 1332 006623 1333 006626 1334 006627 1335 006645 1336 006647 1339 006650 1342 006655 ----------------------------------------------------------- Historical Background This edition of the Multics software materials and documentation is provided and donated to Massachusetts Institute of Technology by Group BULL including BULL HN Information Systems Inc. as a contribution to computer science knowledge. This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology, Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell BULL Inc., Groupe BULL and BULL HN Information Systems Inc. to the development of this operating system. Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970), renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership of Professor Fernando Jose Corbato. Users consider that Multics provided the best software architecture for managing computer hardware properly and for executing programs. Many subsequent operating systems incorporated Multics principles. Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. . ----------------------------------------------------------- Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without fee is hereby granted,provided that the below copyright notice and historical background appear in all copies and that both the copyright notice and historical background and this permission notice appear in supporting documentation, and that the names of MIT, HIS, BULL or BULL HN not be used in advertising or publicity pertaining to distribution of the programs without specific prior written permission. Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc. Copyright 2006 by BULL HN Information Systems Inc. Copyright 2006 by Bull SAS All Rights Reserved