00001 /* 00002 * Copyright 2003, 2004, 2005, 2006 PathScale, Inc. All Rights Reserved. 00003 */ 00004 00005 /* 00006 00007 Copyright (C) 2000, 2001 Silicon Graphics, Inc. All Rights Reserved. 00008 00009 This program is free software; you can redistribute it and/or modify it 00010 under the terms of version 2 of the GNU General Public License as 00011 published by the Free Software Foundation. 00012 00013 This program is distributed in the hope that it would be useful, but 00014 WITHOUT ANY WARRANTY; without even the implied warranty of 00015 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 00016 00017 Further, this software is distributed without any warranty that it is 00018 free of the rightful claim of any third person regarding infringement 00019 or the like. Any license provided herein, whether implied or 00020 otherwise, applies only to this software file. Patent licenses, if 00021 any, provided herein do not apply to combinations of this program with 00022 other software, or any other product whatsoever. 00023 00024 You should have received a copy of the GNU General Public License along 00025 with this program; if not, write the Free Software Foundation, Inc., 59 00026 Temple Place - Suite 330, Boston MA 02111-1307, USA. 00027 00028 Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky, 00029 Mountain View, CA 94043, or: 00030 00031 http://www.sgi.com 00032 00033 For further information regarding this notice, see: 00034 00035 http://oss.sgi.com/projects/GenInfo/NoticeExplan 00036 00037 */ 00038 00039 00040 //-*-c++-*- 00041 // 00042 // The main internal include file for LNO 00043 // 00044 // 00045 // Exported types and functions: 00046 // 00047 // EST_REGISTER_USAGE 00048 // 00049 // BOOL Fits() const 00050 // BOOL Does_Not_Fit() const 00051 // 00052 // Both are FALSE when we are not 00053 // sure either way, otherwise exactly one is true. 00054 // 00055 // void Set_Fits(BOOL) 00056 // void Set_Does_Not_Fit(BOOL) 00057 // 00058 // Only when there is no register estimate, but somehow you 00059 // know. Sets Est_Regs() to -1, sets Fits() or Does_Not_Fit() 00060 // to the passed in value and sets the other to FALSE. 00061 // 00062 // void Set_Est_Regs(INT fp_est, INT fp_regs_available) 00063 // INT int_est, INT int_regs_available, 00064 // INT tlb_est, INT tlb_available) 00065 // INT Est_Fp_Regs() const 00066 // INT Est_Int_Regs() const 00067 // INT Est_TLB() const 00068 // 00069 // An estimate. If all parameters are >= 0, then we set 00070 // one of the bits above to TRUE (fits iff est <= regs_available). 00071 // Est_Fp_Regs() is the most recent value of est, or -1 if unknown. 00072 // 00073 // EST_REGISTER_USAGE(EST_REGISTER_USAGE) 00074 // void operator = (EST_REGISTER_USAGE) 00075 // 00076 // What you'd expect. The constructor sets to no info, Est_Regs() 00077 // to -1. 00078 // 00079 // DO_LOOP_INFO 00080 // 00081 // Hold information about DO loops 00082 // 00083 // ACCESS_ARRAY *LB 00084 // 00085 // The lower bound is the max of all the access vectors in LB 00086 // 00087 // ACCESS_ARRAY *UB 00088 // 00089 // The upper bound is the min of all the access vectors in UB 00090 // 00091 // ACCESS_VECTOR *Step 00092 // 00093 // The Step 00094 // 00095 // mBOOL Is_Inner 00096 // 00097 // Are there any DO loops inside this loop 00098 // 00099 // mBOOL Has_Calls 00100 // 00101 // Any calls inside this do loop 00102 // 00103 // mBOOL Has_Nested_Calls 00104 // 00105 // Any calls to nested functions inside this do loop 00106 // 00107 // mBOOL Has_Unsummarized_Calls 00108 // 00109 // Any calls without IPA summary info inside this do loop 00110 // 00111 // mBOOL Has_Unsummarized_Call_Cost 00112 // 00113 // Any calls without IPA summary cost info inside this do loop 00114 // 00115 // mBOOL Has_Threadprivate 00116 // 00117 // Has a THREADPRIVATE variable (these inhibit automatic 00118 // parallelization) 00119 // 00120 // mBOOL Has_Gotos 00121 // 00122 // Any non-structured control flow, while loops or computed 00123 // gotos inside this do loop. 00124 // 00125 // mBOOL Has_Conditional 00126 // 00127 // Any Gotos jumps to a label inside the loop body. 00128 // If there is such goto, the loop cannot be unrolled, 00129 // because unrolling will introduce duplicated label. 00130 // 00131 // mBOOL Has_Exits 00132 // 00133 // Any gotos/returns leaving the loop 00134 // 00135 // mBOOL Has_Gotos_This_Level 00136 // 00137 // Any gotos jump to a label in this DO loop but not 00138 // nested in a deeper DO loop (this is important because 00139 // if no and if no exits then any write at this level is a must write 00140 // 00141 // mBOOL Has_Bad_Mem 00142 // 00143 // Does this have any non-mapped loads or stores or calls. 00144 // This may be set arbitrarily if Has_Calls or Has_Exits is set. 00145 // 00146 // mBOOL Has Barriers 00147 // 00148 // Has either a FOIRWARD_BARRIER or a BACKWARD_BARRIER. Right 00149 // now this is equivalent to 'Has_Bad_Mem'. 00150 // 00151 // mBOOL Is_Ivdep 00152 // 00153 // Was ivdep set for this loop. Currently, ivdep is only 00154 // recognised for inner loops. 00155 // 00156 // mBOOL Is_Concurrent_Call; 00157 // 00158 // Is there a concurrent call directive on this loop 00159 // or any outermore loop. If so, ignore dependences 00160 // caused by a call 00161 // 00162 // mBOOL Concurrent_Directive 00163 // 00164 // Is there a concurrent directive on this loop. 00165 // If true, ignore "non-obvious" dependences 00166 // 00167 // mBOOL No_Fission 00168 // 00169 // Fission is not allowed for this loop. Default is FALSE. 00170 // 00171 // mBOOL No_Fusion 00172 // 00173 // Fusion is not allowed for this loop. Default is FALSE. 00174 // 00175 // mBOOL Aggressive_Inner_Fission 00176 // 00177 // Fission inner loop as fine as possible. Default is FALSE. 00178 // 00179 // mBOOL Cannot_Interchange 00180 // 00181 // NO INTERCHANGE pragma seen for this loop. Default is FALSE. 00182 // 00183 // mBOOL Cannot_Block 00184 // 00185 // NO BLOCKING pragma seen for this loop. Default is FALSE. 00186 // 00187 // mBOOL Pragma_Cannot_Concurrentize 00188 // 00189 // NO CONCURRENTIZE pragma seen for this loop. Default is FALSE 00190 // 00191 // mBOOL Pragma_Prefer_Concurrentize 00192 // 00193 // PREFER CONCURRENTIZE pragma seen for this loop. 00194 // Default is FALSE 00195 // 00196 // mBOOL Auto_Parallelized 00197 // 00198 // Automatically parallelized this loop 00199 // 00200 // mBOOL Serial_Version_of_Concurrent_Loop 00201 // 00202 // Loop is in serial version of concurrent loop 00203 // 00204 // mBOOL Is_Inner_Tile 00205 // 00206 // The block is an inner tile. Default is FALSE. (May not 00207 // be marked on every inner tile, but will be for those created 00208 // during cache and scalar expansion tiling in the SNL phase 00209 // and scalar expansion tiling in other phases.) 00210 // 00211 // mBOOL Is_Outer_Tile 00212 // 00213 // The block is an outer tile. Default is FALSE. 00214 // 00215 // mBOOL Is_Backward 00216 // 00217 // TRUE if every use of the loop index has a proveably negative 00218 // coefficent, FALSE otherwise. 00219 // 00220 // mBOOL Is_Outer_Lego_Tile 00221 // 00222 // TRUE if this loop is an outer tile created in lego tiling. 00223 // 00224 // mBOOL Is_Inner_Lego_Tile 00225 // 00226 // TRUE if this loop is an inner tile created in lego tiling. 00227 // 00228 // mBOOL Is_Processor_Tile 00229 // 00230 // TRUE if this loop is a processor tile loop. 00231 // 00232 // mBOOL Is_Doacross; 00233 // 00234 // TRUE if this loop is a true doacross loop (with sync) 00235 // 00236 // mBOOL Suggested_Parallel 00237 // 00238 // TRUE if we desire this loop to be a parallel loop 00239 // 00240 // mBOOL Parallelizable 00241 // 00242 // TRUE if the loop is parallelizable in some position within 00243 // the given SNL. 00244 // 00245 // mBOOL Last_Value_Peeled 00246 // 00247 // TRUE if the loop was created by peeling the last iteration 00248 // of a parallel loop 00249 // 00250 // mBOOL Not_Enough_Parallel_Work 00251 // 00252 // TRUE if loop was not parallelized because there was not 00253 // enough estimated work to make it worthwhile to go parallel 00254 // 00255 // mBOOL Inside_Critical_Section 00256 // 00257 // TRUE if the loop is inside a critical section (and therefore 00258 // cannot be parallelized 00259 // 00260 // double Work_Estimate 00261 // 00262 // Work estimate of one iteration of the innermost loop 00263 // (used to build if-test under -LNO:ap=1) 00264 // 00265 // mINT8 Required_Unroll 00266 // 00267 // UNROLL pragma seen for this loop. Default is 0. Value, if 00268 // positive, is how many times we must outer unroll this loop. 00269 // 00270 // mINT32 Required_Blocksize[MHD_MAX_LEVELS] 00271 // 00272 // BLOCKING SIZE pragma seen for this loop. Default is {-1,-1,...} 00273 // The blocksize for each level of the cache. 0 means put in 00274 // the tile but don't block. It will not result in any illegal 00275 // transformations. 00276 // 00277 // mINT32 Tile_Size 00278 // 00279 // If Is_Inner_Tile is set, this is the size at which the loop 00280 // has been tiled. 00281 // 00282 // INT Blockable_Specification 00283 // 00284 // 0 if unspecified. 2 or more are interesting values. This 00285 // and the Blockable_Specification-1 loops directly nested 00286 // inside can be blocked. If a positive value is specified here, 00287 // the transformation routines *may* choose to consider the 00288 // nest blockable even if it thinks dependences prevent it. 00289 // 00290 // INT* Permutation_Spec_Array 00291 // 00292 // If non-NULL, indicates a permutation requested for this loop. 00293 // E.g. Permutation_Spec_Array[0] = 1, 00294 // Permutation_Spec_Array[1] = 0 00295 // says to interchange this loop and the one next inside. 00296 // The compiler may do this. It also may refuse to do it, 00297 // especially if that transformation is illegal. Note that 00298 // Permutation_Spec_Array[0] = x 00299 // says that the new outer loop (0) is the old x. 00300 // 00301 // mINT8 Permutation_Spec_Count 00302 // 00303 // The number of elements in the array Permutation_Spec_Array. 00304 // i.e. Permutation_Spec_Array[0..Permutation_Spec_Count-1]. 00305 // 00306 // INT64 Est_Num_Iterations 00307 // 00308 // An estimate for how many iterations in the loop. 00309 // Currently, any loop with symbolic bounds or a non-const step 00310 // is estimated to have LNO_Num_Iters=100 iterations. 00311 // Initialized to -1. 00312 // 00313 // INT64 Est_Max_Iterations_Index 00314 // 00315 // From the sizes of each index (e.g. a(i) where a(1..63), 00316 // an estimate of the maximum iterations possible. 00317 // Initialized to -1. This is set by Mark_Code(), and 00318 // *not* set by Set_Est_Num_Iterations. This is for 00319 // efficiency. Perhaps this should change. 00320 // 00321 // mBOOL Num_Iterations_Symbolic 00322 // 00323 // Did the estimate for Est_Num_Iterations rely on LNO_Num_Iters 00324 // 00325 // void Set_Est_Num_Iterations(DOLOOP_STACK *do_stack) 00326 // 00327 // Set the estimate given that the stack contains the 00328 // DO_LOOP_INFOs with ACCESS_ARRAYs for the outer loops 00329 // 00330 // void Set_Est_Num_Iterations(DOLOOP_STACK *do_stack) 00331 // 00332 // Set the estimate given that the stack contains the 00333 // DO_LOOP_INFOs with ACCESS_ARRAYs for the outer loops 00334 // 00335 // mUINT8 Depth 00336 // 00337 // What is the "depth" of this DO loop. The outer DO loop 00338 // (good or bad) is numbered 0. The next inner 1, etc. 00339 // 00340 // WN *Guard 00341 // 00342 // Points to the if statement that "guards" this loop. 00343 // By guard we mean guarantee that the do loop is not 00344 // zero trip count. If this is NULL, then the loop 00345 // is non-zero trip count without any special guard. 00346 // 00347 // LEGO_INFO* Lego_Info 00348 // 00349 // Pointer to information needed for lego transformations. 00350 // 00351 // MP_INFO* Mp_Info 00352 // 00353 // Pointer to information needed for MP transformations. 00354 // 00355 // INT Lego_Mp_Key_Lower 00356 // 00357 // Lower bound of range of Lego_Mp_Key values for this loop 00358 // 00359 // INT Lego_Mp_Key_Upper 00360 // 00361 // Upper bound of range of Lego_Mp_Key values for this loop 00362 // 00363 // INT Lego_Mp_Key_Depth 00364 // 00365 // Depth of this loop in the tile group with keys from 00366 // Lego_Mp_Key_Lower to Lego_Mp_Key_Upper, inclusive. 00367 // 00368 // EST_REGISTER_USAGE Est_Register_Usage 00369 // 00370 // An estimation of the register usage from the model. 00371 // This only makes sense for an inner loop. 00372 // 00373 // DO_LOOP_INFO(MEM_POOL *pool, ACCESS_ARRAY *lb, ACCESS_ARRAY *ub, 00374 // ACCESS_VECTOR *step, BOOL has_calls, BOOL has_unsummarized_calls, 00375 // BOOL has unsummarized_call_cost, BOOL has_gotos, BOOL has_exits, 00376 // BOOL has_goto_this_level, BOOL is_inner) 00377 // 00378 // 00379 // DO_LOOP_INFO(DO_LOOP_INFO *dli, MEM_POOL *pool) 00380 // 00381 // Copy the info 00382 // 00383 // MEM_POOL *Pool() 00384 // 00385 // Which pool was used for this info 00386 // 00387 // void Print(FILE *fp) 00388 // 00389 // Print out the info 00390 // 00391 // BOOL Is_Cache_Winddown() const 00392 // void Set_Cache_Winddown(BOOL b = TRUE) 00393 // BOOL Is_Register_Winddown() const 00394 // void Set_Register_Winddown(BOOL b = TRUE) 00395 // BOOL Is_In_Cache_Winddown() const 00396 // void Set_In_Cache_Winddown(BOOL b = TRUE) 00397 // BOOL Is_In_Register_Winddown() const 00398 // void Set_In_Register_Winddown(BOOL b = TRUE) 00399 // BOOL Is_Generally_Unimportant() const 00400 // void Set_Generally_Unimportant(BOOL b = TRUE) 00401 // 00402 // Set/Get flags for DO_LOOP_INFO. If the optional parameter 00403 // on the Set is FALSE, then reset the bit. The first four 00404 // indicate whether the loop is the result of winding down 00405 // from cache blocking or register blocking. The next four 00406 // are for loops inside cache windown or register winddown loops. 00407 // [Note that the setting if Is_Cache_Winddown does not imply 00408 // the setting if Is_In_Cache_Winddown, the latter saying that 00409 // a loop *further out* is a cache winddown; likewise for 00410 // registers]. The next four indicate whether (according to 00411 // our attempts to model the loop), the loop fits 00412 // in the registers, doesn't or (if neither is set) 00413 // not sure. Both cannot be set. Currently, only an inner 00414 // loop may have one of these set. 00415 // 00416 // INT Doacross_Tile_Size 00417 // 00418 // Size of the doacross tile size. 00419 // 00420 // INT Sync_Distances[2] 00421 // 00422 // Two synchronization vectors for doacross: 00423 // (Sync_Distances[0],-1), (Sync_Distances[1],1) 00424 // 00425 // INT Doacross_Overhead 00426 // 00427 // Overhead of the doacross. I.e., init delay and sync 00428 // overhead. 00429 // 00430 // DO_LOOP_INFO* Get_Do_Loop_Info(WN* wn, BOOL ok_if_none = FALSE) 00431 // 00432 // Get the annotation for this do loop. Fails if ok_if_none 00433 // is FALSE and there is no annotation. 00434 // 00435 // IF_INFO* Get_If_Info(WN* wn, BOOL ok_if_none = FALSE) 00436 // 00437 // Get the annotation for this if. Fails if ok_if_none 00438 // is FALSE and there is no annotation. 00439 // 00440 // void Set_Do_Loop_Info(WN* wn, DO_LOOP_INFO* dli) 00441 // 00442 // Set the loop to have this annotation. 00443 // 00444 // BOOL Do_Loop_Is_Good (WN *wn) 00445 // 00446 // Is this a good do loop? Currently, a DO loop is not good 00447 // if it has any unmapped loads/stores/calls 00448 // If a DO loop is not good. All its surrounding DO loops must 00449 // be not good as well 00450 // 00451 // BOOL Do_Loop_Has_Calls (WN *wn) 00452 // 00453 // Does this do loop have calls 00454 // 00455 // BOOL Do_Loop_Has_Gotos (WN *wn) 00456 // 00457 // Does this do loop have gotos 00458 // 00459 // BOOL Do_Loop_Has_Gotos_This_Level (WN *wn) 00460 // 00461 // Does this do loop have gotos that jump to this level 00462 // 00463 // BOOL Do_Loop_Has_Unsummarized_Calls (WN *wn) 00464 // 00465 // Does this do loop have calls that are not summarized by IPA 00466 // 00467 // BOOL Do_Loop_Has_Unsummarized_Call_Cost (WN *wn) 00468 // 00469 // Does this do loop have calls whose cost is not summarized 00470 // by IPA 00471 // 00472 // BOOL Do_Loop_Is_Mp (WN *wn) 00473 // 00474 // Is this an mp DO loop? 00475 // 00476 // BOOL Do_Loop_Is_Inner (WN *wn) 00477 // 00478 // Is this an inner DO loop? 00479 // 00480 // BOOL Do_Loop_Is_Ivdep (WN *wn) 00481 // 00482 // Is this an ivdep loop 00483 // 00484 // INT Do_Loop_Depth(WN *wn) 00485 // 00486 // BOOL Mark_Code(WN *func_nd, BOOL promote_pointers=FALSE, 00487 // BOOL strict_limit=TRUE) 00488 // 00489 // Mark all the do loops and IFs in the function 00490 // using the DO_LOOP_INFO data structure and the LNO_Info_Map map. 00491 // if promote_pointers, try to promote pointers into arrays 00492 // note that promote_pointers doesn't set up access_vectors 00493 // for the generated arrays 00494 // if 'strict_limit', use a strict limit on the number of loops 00495 // allowed in a nest (i.e. LNO_MAX_DO_LOOP_DEPTH_STRICT). 00496 // Otherwise, use a more liberal limit (i.e. 00497 // LNO_MAX_DO_LOOP_DEPTH-1 = 32) 00498 // return TRUE if there exists a do loop in the code 00499 // 00500 // BOOL Build_Array_Dependence_Graph (WN* func_nd) 00501 // 00502 // Called with the WHIRL tree for the function to build the 00503 // array dependence graph. Return TRUE if graph was OK, FALSE 00504 // otherwise. 00505 // 00506 // void Build_CG_Dependence_Graph (WN* func_nd) 00507 // 00508 // Build CG dependence graph from scratch. 00509 // 00510 // void Build_CG_Dependence_Graph (ARRAY_DIRECTED_GRAPH16*) 00511 // 00512 // Build CG dependence graph using LNO array dependence graph. 00513 // 00514 // Exported Global Variables: 00515 // 00516 // LNO_MAX_DO_LOOP_DEPTH=32 00517 // 00518 // The maximum depth of a DO loop. Used by SNL as a data 00519 // structure limiation. 00520 // 00521 // LNO_MAX_DO_LOOP_DEPTH_STRICT: default=10 00522 // 00523 // A stricter limit that can be set on the command line. 00524 // Anything deeper will be dismantled by CAN 00525 // 00526 // WN_MAP Parent_Map 00527 // 00528 // Map each node to its parent 00529 // 00530 // 00531 // WN_MAP LNO_Info_Map 00532 // 00533 // Map each DO_LOOP to a DO_LOOP_INFO * 00534 // Map each array statement to an ACCESS_ARRAY * 00535 // 00536 // WN_MAP Array_Dependence_Map 00537 // 00538 // Map each array statement to a vertex in the array dependence 00539 // graph. 00540 // 00541 // MEM_POOL LNO_default_pool, LNO_local_pool 00542 // 00543 // The phase and local pools used by LNO. 00544 // Neither of these pools is "zeroed" 00545 // 00546 // FILE *STDOUT 00547 // 00548 // Set to stdout. Can be used by dbx. 00549 // 00550 // class REGION_INFO 00551 // 00552 // Summarizes important information about a parallel region. 00553 // 00554 // BOOL Auto_Parallelized() 00555 // 00556 // Was this region generated by auto-parallelization. 00557 // 00558 // REGION_INFO() 00559 // 00560 // Default constructor. 00561 // 00562 // REGION_INFO(BOOL auto_parallelized) 00563 // 00564 // Constructor. Pass 'auto_parallelized' == TRUE if region was 00565 // constructed by auto-parallelization, FALSE otherwise. 00566 // 00567 // ~REGION_INFO() 00568 // 00569 // Destructor 00570 // 00571 // void Print(FILE* fp) 00572 // 00573 // Print human readable version of REGION_INFO contents to 00574 // FILE* 'fp'. 00575 // 00576 // REGION_INFO* Get_Region_Info(WN* wn) 00577 // 00578 // Returns pointer to region info, if there is one, otherwise, 00579 // returns NULL. 00580 // 00581 // Tracing flags 00582 // 00583 // All of lno's tracing flags are associated with TP_LNOPT = 31 00584 // The individual bits are used as follows 00585 // 00586 // TT_LNO_DEP 0x0001 base dependence analysis trace 00587 // TT_LNO_DEP2 0x0002 detailed dependence analysis trace 00588 // TT_LNO_VERBOSE 0x0004 print useful LNO info to stdout 00589 // TT_LNO_PREFETCH_VERBOSE 0x0008 print "useful" prefetch info to stdout 00590 // 00591 // TT_LNO_SKIP_FIZ_FUSE 0x0010 skip fiz_fuse phase 00592 // TT_LNO_SKIP_PH2 0x0020 skip phase 2 00593 // TT_LNO_SKIP_INNER_FISSION 0x0040 skip inner_fission phase 00594 // TT_LNO_SKIP_LNO 0x0080 skip lno entirely, run only pre-opt 00595 // 00596 // TT_LNO_SNL_DEBUG1 0x0100 debugging information for SNL 00597 // TT_LNO_SNL_DEBUG2 0x0200 extra debugging information for SNL 00598 // TT_LNO_SNL_INTERACT 0x0400 interactive transformation selection 00599 // (untested, certainly broken) 00600 // TT_LNO_SE_MALLOC 0x0800 use the stack for scalar expansion 00601 // SHOULD USE -LNO:use_malloc INSTEAD 00602 // 00603 // TT_LNO_PREFETCH 0x1000 Enable prefetching. 00604 // TT_LNO_PREFETCH_DEBUG 0x2000 Dump prefetch debug info to trace file 00605 // TT_LNO_MODEL 0x4000 debug the machine model 00606 // TT_LNO_CACHE_MODEL_DEBUG 0x8000 debug the cache model 00607 // 00608 // TT_LNO_AEQUIV 0x10000 debug equivalence local arrays 00609 // TT_LNO_SCLRZE 0x20000 debug scalarize local arrays 00610 // TT_LNO_DEAD 0x40000 debug dead code cf elimination 00611 // TT_LNO_GUARD 0x80000 turns off guarding of DO loops 00612 // and memory invariant removal 00613 // 00614 // TT_LNO_MINVARIANT_DEBUG 0x100000 debug memory invariant removal 00615 // TT_LNO_NORENAME 0x200000 turns off scalar renaming 00616 // TT_LNO_SKIP_GS 0x400000 turns off gather/scatter 00617 // 00618 // TT_LNO_SKIP_NONLIN 0x1000000 turn off NONLINEAR analysis 00619 // TT_LNO_DEBUG_DELIN 0x2000000 debug delinearization 00620 // TT_LNO_BIG_SCALAR_TILES 0x4000000 use arbitrarily large scalar 00621 // expansion tiles 00622 // TT_GRAPH_CAPACITY 0x8000000 set the graph capacity to 00623 // given value 00624 // TT_LNO_DEBUG_CSE 0x10000000 debug inter-iteration cses 00625 // 00626 // 00627 // The following tracing flags are associated with TP_LNOPT2, 00628 // the next set of LNO options. This class TP_LNOPT2 is 00629 // tentatively being used for LEGO options. 00630 // (If you need more, there is yet another LNO class, TT_LNOPT = 33.) 00631 // 00632 // TT_LEGO_VERBOSE 0x00000001 verbose mode 00633 // TT_LEGO_DEBUG 0x00000002 debugging dump mode 00634 // TT_LEGO_PRAGMAS_ONLY 0x00000004 stop lego processing after 00635 // processing the pragmas only 00636 // TT_LEGO_DISABLE_DIVMOD 0x00000008 disable div/mod optimizations 00637 // TT_LEGO_DISABLE_HOIST 0x00000010 disable hoisting 00638 // TT_LEGO_DISABLE_IMPLICIT_AFFINITY 0x00000020 disable implicit affinity 00639 // TT_LEGO_DISABLE_EXPLICIT_AFFINITY 0x00000040 disable explicit affinity 00640 // TT_LEGO_DISABLE_INTERCHANGE 0x00000080 disable lego interchange 00641 // TT_LNO_RUN_ARA 0x00000100 turns on ARA 00642 // TT_LNO_ARA_VERBOSE 0x00000200 turns on ARA verbose mode 00643 // TT_LNO_ARA_DEBUG 0x00000400 turns on ARA debug 00644 // TT_LNO_NO_AUTO_PARALLEL 0x00000800 turns on off autoparallelization 00645 // with interchange 00646 // 00647 // TT_LEGO_DISABLE_RR_MAPS 0x00001000 disable using maps for lowering 00648 // of reshaped arrays 00649 // TT_LEGO_DISABLE_FP_DIVMOD 0x00002000 disable using FP arithmetic for 00650 // INT32 div/mod/rem operations 00651 // TT_LNO_PARALLEL_DEBUG 0x00004000 debug parallelization 00652 // TT_LNO_NO_TRANSPOSE 0x00008000 no transpose optimization 00653 // TT_LNO_DEBUG_PROMPF 0x00010000 debug PROMPF 00654 // TT_LNO_DISABLE_SEFIN 0x00020000 disable finalization of scalar 00655 // variables 00656 // TT_LNO_NO_PAD 0x00040000 inhibit automatic padding of 00657 // arrays that have power-of-2 sizes 00658 // TT_LNO_OMP_TRANSFORMS 0x00080000 describe Whirl transformations 00659 // performed by OMP_Prelower() 00660 // TT_HMB_FORCE_VERSIONS 0x00100000 use multiple-version algorithm 00661 // for array bounds hoisting even 00662 // for single-version case 00663 00664 /* ==================================================================== 00665 * ==================================================================== 00666 * 00667 * Module: lnopt_main.h 00668 * $Revision: 1.13 $ 00669 * $Date: 05/06/20 21:34:05-07:00 $ 00670 * $Author: fchow@fluorspar.internal.keyresearch.com $ 00671 * $Source: be/lno/SCCS/s.lnopt_main.h $ 00672 * 00673 * Revision history: 00674 * 27-NOV-94 - Original Version 00675 * 00676 * Description: 00677 * 00678 * The internal interface for the loop optimizer. 00679 * 00680 * ==================================================================== 00681 * ==================================================================== 00682 */ 00683 00684 #ifndef lnopt_main_INCLUDED 00685 #define lnopt_main_INCLUDED 00686 00687 #ifndef wn_INCLUDED 00688 #include "wn.h" 00689 #endif 00690 #ifndef mempool_INCLUDED 00691 #include "mempool.h" 00692 #endif 00693 #ifndef cxx_memory_INCLUDED 00694 #include "cxx_memory.h" 00695 #endif 00696 #ifndef config_cache_INCLUDED 00697 #include "config_cache.h" 00698 #endif 00699 #ifndef config_lno_INCLUDED 00700 #include "config_lno.h" 00701 #endif 00702 #ifndef access_vector_INCLUDED 00703 #include "access_vector.h" 00704 #endif 00705 #ifndef access_main_INCLUDED 00706 #include "access_main.h" 00707 #endif 00708 #ifndef tracing_INCLUDED 00709 #include "tracing.h" 00710 #endif 00711 #ifndef if_info_INCLUDED 00712 #include "if_info.h" 00713 #endif 00714 00715 #include "dep_graph.h" 00716 00717 #ifdef KEY // bug 7422 00718 #define LNO_MAX_DO_LOOP_DEPTH 64 00719 #else 00720 #define LNO_MAX_DO_LOOP_DEPTH 32 00721 #endif 00722 extern WN_MAP Parent_Map; /* contains the mapping for the */ 00723 /* parent pointers for all nodes */ 00724 extern WN_MAP LNO_Info_Map; 00725 extern WN_MAP Array_Dependence_Map; 00726 extern MEM_POOL LNO_default_pool; 00727 extern MEM_POOL LNO_local_pool; 00728 extern INT snl_debug; 00729 00730 extern BOOL Run_Snl; 00731 extern BOOL Contains_MP; // does the PU contain any MP constructs 00732 00733 extern FILE *STDOUT; 00734 00735 extern BOOL LNO_Debug_Delinearization; 00736 extern BOOL LNO_Allow_Nonlinear; 00737 extern BOOL LNO_Allow_Delinearize; 00738 extern BOOL LNO_Tlog; 00739 extern FILE* LNO_Analysis; 00740 00741 // The following is useful since LNO might be called to do lego 00742 // processing without optimizations. This variable is TRUE by 00743 // default, off if lno is disabled for some reason. 00744 // (see lnopt_main.cxx for conditions when it gets set to FALSE). 00745 extern BOOL LNO_enabled; 00746 00747 extern WN* Current_Func_Node; 00748 00749 extern class DU_MANAGER *Du_Mgr; // manage the def-use chains 00750 extern class ALIAS_MANAGER *Alias_Mgr; // manage alias info 00751 extern class REDUCTION_MANAGER *red_manager; // manage redution information 00752 extern class ARRAY_DIRECTED_GRAPH16 *Array_Dependence_Graph; // LNO dep graph 00753 typedef STACK<ST *> STACK_OF_ST; 00754 00755 // Permutation arrays 00756 class PERMUTATION_DESCRIPTOR { 00757 public: 00758 ST *_st; // the array 00759 BOOL _is_good; // is it good in the region of interest (not written) 00760 PERMUTATION_DESCRIPTOR(ST *st) { _st = st; _is_good = FALSE; } 00761 }; 00762 00763 typedef STACK<PERMUTATION_DESCRIPTOR> PERMUTATION_ARRAYS; 00764 00765 extern PERMUTATION_ARRAYS *Permutation_Arrays; 00766 00767 class ACCESS_ARRAY; 00768 class ACCESS_VECTOR; 00769 class LEGO_INFO; 00770 class ARA_LOOP_INFO; 00771 class MP_INFO; 00772 00773 class EST_REGISTER_USAGE { 00774 mINT16 _fp_est; 00775 mINT16 _int_est; 00776 mINT16 _tlb_est; 00777 mBOOL _fits; 00778 mBOOL _no_fit; 00779 public: 00780 EST_REGISTER_USAGE() : _fp_est(-1), _int_est(-1), _tlb_est(-1), 00781 _fits(FALSE), _no_fit(FALSE) {} 00782 void operator = (EST_REGISTER_USAGE r) { 00783 _fp_est = r._fp_est; _int_est=r._int_est; _tlb_est=r._tlb_est; 00784 _fits = r._fits; _no_fit = r._no_fit; 00785 } 00786 BOOL Fits() const {return _fits;} 00787 BOOL Does_Not_Fit() const {return _no_fit;} 00788 INT Est_Fp_Regs() const {return _fp_est;} 00789 INT Est_Int_Regs() const {return _int_est;} 00790 INT Est_TLB() const {return _tlb_est;} 00791 void Set_Est_Regs(INT fp_est, INT fp_regs_available, 00792 INT int_est, INT int_regs_available, 00793 INT tlb_est, INT tlb_available); 00794 void Set_Fits(BOOL f) 00795 {_fp_est = -1; _int_est = -1; _tlb_est = -1; _fits = f; _no_fit = FALSE;} 00796 void Set_Does_Not_Fit(BOOL f) 00797 {_fp_est = -1; _int_est = -1; _tlb_est = -1; _fits = FALSE; _no_fit = f;} 00798 void Print(FILE* f); 00799 }; 00800 00801 // Until 7.3, when we create a copy constructor for the ARA_LOOP_INFO, 00802 // Use this mechanism to indicate that it's OK to copy a DO_LOOP_INFO 00803 // with an ARA_LOOP_INFO, because we are going to discard the ARA in- 00804 // formation soon. Right now, this should only happen if we are doing 00805 // last value peeling. 00806 00807 extern BOOL Last_Value_Peeling(); 00808 extern void Last_Value_Peeling_On(); 00809 extern void Last_Value_Peeling_Off(); 00810 00811 class DO_LOOP_INFO { 00812 private: 00813 MEM_POOL *_pool; 00814 mUINT8 _wind_down_flags; 00815 enum DLI_FLAG {CWD = 1, RWD = 2, ICWD = 4, IRWD = 8, UNIMPORTANT = 16}; 00816 void Set_Flag(DLI_FLAG flag, BOOL set) { 00817 if (set) 00818 _wind_down_flags |= flag; 00819 else 00820 _wind_down_flags &= ~flag; 00821 } 00822 BOOL Get_Flag(DLI_FLAG flag) const { 00823 return (_wind_down_flags & flag) != 0; 00824 } 00825 00826 public: 00827 ACCESS_ARRAY *LB; 00828 ACCESS_ARRAY *UB; 00829 ACCESS_VECTOR *Step; 00830 00831 INT64 Est_Num_Iterations; 00832 INT64 Est_Max_Iterations_Index; 00833 mBOOL Num_Iterations_Symbolic; 00834 mBOOL Num_Iterations_Profile; 00835 void Set_Est_Num_Iterations(DOLOOP_STACK *do_stack); 00836 00837 mBOOL Has_Calls; 00838 #ifdef KEY //bug 14284 00839 mBOOL Has_Nested_Calls; 00840 #endif 00841 mBOOL Has_Unsummarized_Calls; 00842 mBOOL Has_Unsummarized_Call_Cost; 00843 mBOOL Has_Threadprivate; 00844 mBOOL Has_Gotos; 00845 mBOOL Has_Conditional; 00846 mBOOL Has_Gotos_This_Level; 00847 mBOOL Has_Exits; 00848 mBOOL Is_Inner; 00849 mBOOL Has_Bad_Mem; 00850 mBOOL Is_Ivdep; 00851 mBOOL Is_Concurrent_Call; 00852 mBOOL Concurrent_Directive; 00853 mBOOL No_Fission; 00854 mBOOL No_Fusion; 00855 mBOOL Aggressive_Inner_Fission; 00856 mBOOL Cannot_Interchange; 00857 mBOOL Cannot_Block; 00858 mBOOL Pragma_Cannot_Concurrentize; 00859 mBOOL Pragma_Prefer_Concurrentize; 00860 mBOOL Serial_Version_of_Concurrent_Loop; 00861 mBOOL Auto_Parallelized; 00862 mBOOL Is_Inner_Tile; 00863 mBOOL Is_Outer_Tile; 00864 mBOOL Is_Backward; 00865 mBOOL Is_Outer_Lego_Tile; 00866 mBOOL Is_Inner_Lego_Tile; 00867 mBOOL Is_Processor_Tile; 00868 mBOOL Is_Doacross; 00869 mBOOL Suggested_Parallel; 00870 mBOOL Parallelizable; 00871 #ifdef KEY 00872 mBOOL Vectorizable; 00873 mBOOL Delay_Full_Unroll; 00874 #endif 00875 mBOOL Last_Value_Peeled; 00876 mBOOL Not_Enough_Parallel_Work; 00877 mBOOL Inside_Critical_Section; 00878 mBOOL Has_Barriers; 00879 mINT8 Required_Unroll; 00880 mINT32 Tile_Size; 00881 double Work_Estimate; 00882 mINT32 Required_Blocksize[MHD_MAX_LEVELS]; 00883 WN *Guard; 00884 LEGO_INFO* Lego_Info; 00885 ARA_LOOP_INFO* ARA_Info; 00886 MP_INFO* Mp_Info; 00887 INT Lego_Mp_Key_Lower; 00888 INT Lego_Mp_Key_Upper; 00889 INT Lego_Mp_Key_Depth; 00890 SYMBOL* Lego_LB_Symbols; 00891 mUINT8 Depth; 00892 INT Blockable_Specification; 00893 INT* Permutation_Spec_Array; 00894 mINT8 Permutation_Spec_Count; 00895 EST_REGISTER_USAGE Est_Register_Usage; 00896 INT Doacross_Tile_Size; 00897 INT Sync_Distances[2]; 00898 INT Doacross_Overhead; 00899 00900 MEM_POOL *Pool() { return _pool; }; 00901 00902 BOOL Is_Cache_Winddown() const {return Get_Flag(CWD);} 00903 void Set_Cache_Winddown(BOOL b = TRUE) {Set_Flag(CWD, b);} 00904 BOOL Is_Register_Winddown() const {return Get_Flag(RWD);} 00905 void Set_Register_Winddown(BOOL b = TRUE) {Set_Flag(RWD, b);} 00906 BOOL Is_In_Cache_Winddown() const {return Get_Flag(ICWD);} 00907 void Set_In_Cache_Winddown(BOOL b = TRUE) {Set_Flag(ICWD, b);} 00908 BOOL Is_In_Register_Winddown() const {return Get_Flag(IRWD);} 00909 void Set_In_Register_Winddown(BOOL b = TRUE) {Set_Flag(IRWD, b);} 00910 BOOL Is_Generally_Unimportant() const {return Get_Flag(UNIMPORTANT);} 00911 void Set_Generally_Unimportant(BOOL b = TRUE) {Set_Flag(UNIMPORTANT, b);} 00912 00913 DO_LOOP_INFO(MEM_POOL *pool, ACCESS_ARRAY *lb, ACCESS_ARRAY *ub, 00914 ACCESS_VECTOR *step, BOOL has_calls, BOOL has_nested_calls, BOOL has_unsummarized_calls, 00915 BOOL has_unsummarized_call_cost, BOOL has_gotos, 00916 BOOL has_gotos_this_level,BOOL has_exits, BOOL is_inner); 00917 DO_LOOP_INFO(DO_LOOP_INFO *dli, MEM_POOL *pool); 00918 00919 void Print(FILE *fp, INT = 0); 00920 ~DO_LOOP_INFO() { 00921 CXX_DELETE(LB,_pool); 00922 CXX_DELETE(UB,_pool); 00923 CXX_DELETE(Step,_pool); 00924 if (Permutation_Spec_Count > 0) 00925 CXX_DELETE(Permutation_Spec_Array, _pool); 00926 } 00927 private: 00928 DO_LOOP_INFO(); //intentionally undefined 00929 }; 00930 00931 inline DO_LOOP_INFO* Get_Do_Loop_Info(const WN* wn, BOOL ok_if_none = FALSE) 00932 { 00933 Is_True(wn && WN_opcode(wn) == OPC_DO_LOOP, ("Get_Do_Loop_Info bug")); 00934 DO_LOOP_INFO* dli = (DO_LOOP_INFO *) WN_MAP_Get(LNO_Info_Map, wn); 00935 if (!ok_if_none) 00936 FmtAssert(dli, ("Get_Do_Loop_Info(): Unmarked do loop 0x%lx", wn)); 00937 return dli; 00938 } 00939 00940 inline void Set_Do_Loop_Info(WN* wn, DO_LOOP_INFO* dli) 00941 { 00942 Is_True(wn && WN_opcode(wn) == OPC_DO_LOOP, ("Set_Do_Loop_Info bug")); 00943 WN_MAP_Set(LNO_Info_Map, wn, dli); 00944 } 00945 00946 inline BOOL Do_Loop_Is_Good (WN *wn) 00947 { 00948 DO_LOOP_INFO *dli = Get_Do_Loop_Info(wn); 00949 return(dli && !dli->Has_Bad_Mem); 00950 } 00951 00952 inline BOOL Do_Loop_Has_Calls (WN *wn) 00953 { 00954 DO_LOOP_INFO *dli = Get_Do_Loop_Info(wn); 00955 return(dli && dli->Has_Calls); 00956 } 00957 00958 inline BOOL Do_Loop_Has_Unsummarized_Calls (WN *wn) 00959 { 00960 DO_LOOP_INFO *dli = Get_Do_Loop_Info(wn); 00961 return(dli && dli->Has_Unsummarized_Calls); 00962 } 00963 00964 inline BOOL Do_Loop_Has_Unsummarized_Call_Cost (WN *wn) 00965 { 00966 DO_LOOP_INFO *dli = Get_Do_Loop_Info(wn); 00967 return(dli && dli->Has_Unsummarized_Call_Cost); 00968 } 00969 00970 inline BOOL Do_Loop_Has_Threadprivate (WN *wn) 00971 { 00972 DO_LOOP_INFO *dli = Get_Do_Loop_Info(wn); 00973 return(dli && dli->Has_Threadprivate); 00974 } 00975 00976 inline BOOL Do_Loop_Has_Gotos (WN *wn) 00977 { 00978 DO_LOOP_INFO *dli = Get_Do_Loop_Info(wn); 00979 return(dli && dli->Has_Gotos); 00980 } 00981 00982 inline BOOL Do_Loop_Has_Conditional( WN *wn) 00983 { 00984 DO_LOOP_INFO *dli = Get_Do_Loop_Info(wn); 00985 return(dli && dli->Has_Conditional); 00986 } 00987 00988 inline BOOL Do_Loop_Has_Gotos_This_Level (WN *wn) 00989 { 00990 DO_LOOP_INFO *dli = Get_Do_Loop_Info(wn); 00991 return(dli && dli->Has_Gotos_This_Level); 00992 } 00993 00994 inline BOOL Do_Loop_Has_Exits (WN *wn) 00995 { 00996 DO_LOOP_INFO *dli = Get_Do_Loop_Info(wn); 00997 return(dli && dli->Has_Exits); 00998 } 00999 01000 inline BOOL Do_Loop_Is_Inner (WN *wn) 01001 { 01002 DO_LOOP_INFO *dli = Get_Do_Loop_Info(wn); 01003 return(dli->Is_Inner); 01004 } 01005 01006 inline BOOL Do_Loop_Is_Ivdep(WN *wn) 01007 { 01008 DO_LOOP_INFO *dli = Get_Do_Loop_Info(wn); 01009 return(dli->Is_Ivdep); 01010 } 01011 01012 inline BOOL Do_Loop_Is_Concurrent_Call(WN *wn) 01013 { 01014 DO_LOOP_INFO *dli = Get_Do_Loop_Info(wn); 01015 return(dli->Is_Concurrent_Call); 01016 } 01017 01018 inline BOOL Do_Loop_Concurrent_Directive(WN *wn) 01019 { 01020 DO_LOOP_INFO *dli = Get_Do_Loop_Info(wn); 01021 return(dli->Concurrent_Directive); 01022 } 01023 01024 inline INT Do_Loop_Depth (WN *wn) 01025 { 01026 DO_LOOP_INFO *dli = Get_Do_Loop_Info(wn); 01027 return(dli->Depth); 01028 } 01029 01030 extern BOOL Mark_Code(WN *wn, BOOL promote_pointers = FALSE, 01031 BOOL strict_limit = TRUE); 01032 01033 extern BOOL Build_Array_Dependence_Graph (WN* func_nd); 01034 extern void Build_CG_Dependence_Graph (WN* func_nd); 01035 extern void Build_CG_Dependence_Graph (ARRAY_DIRECTED_GRAPH16* 01036 Array_Dependence_Graph); 01037 #ifdef TARG_X8664 01038 extern void Mark_Auto_Vectorizable_Loops (WN* func_nd); 01039 #endif 01040 01041 inline IF_INFO* Get_If_Info(WN* wn, BOOL ok_if_none = FALSE) 01042 { 01043 Is_True(wn && WN_opcode(wn) == OPC_IF, ("Get_If_Info bug")); 01044 IF_INFO* ii = (IF_INFO *) WN_MAP_Get(LNO_Info_Map, wn); 01045 if (!ok_if_none) 01046 FmtAssert(ii, ("Get_If_Info(): Unmarked if")); 01047 return ii; 01048 } 01049 01050 class REGION_INFO { 01051 private: 01052 mBOOL _auto_parallelized; 01053 public: 01054 BOOL Auto_Parallelized() {return _auto_parallelized;} 01055 REGION_INFO() {_auto_parallelized = FALSE;} 01056 REGION_INFO(BOOL auto_parallelized): _auto_parallelized(auto_parallelized) {} 01057 ~REGION_INFO() {} 01058 void Print(FILE* fp); 01059 }; 01060 01061 inline REGION_INFO* Get_Region_Info(const WN* wn) 01062 { 01063 FmtAssert(wn != NULL && WN_opcode(wn) == OPC_REGION, 01064 ("Get_Region_Info: Passed null pointer to pointer to non-REGION node")); 01065 REGION_INFO* rgi = (REGION_INFO *) WN_MAP_Get(LNO_Info_Map, wn); 01066 return rgi; 01067 } 01068 01069 // TP_LNOPT = 31 options. 01070 01071 #define TT_LNO_DEP 0x00000001 01072 #define TT_LNO_DEP2 0x00000002 01073 #define TT_LNO_VERBOSE 0x00000004 01074 #define TT_LNO_PREFETCH_VERBOSE 0x00000008 01075 01076 #define TT_LNO_SKIP_FIZ_FUSE 0x00000010 01077 #define TT_LNO_SKIP_PH2 0x00000020 01078 #define TT_LNO_SKIP_INNER_FISSION 0x00000040 01079 #define TT_LNO_SKIP_LNO 0x00000080 01080 01081 #define TT_LNO_SNL_DEBUG1 0x00000100 01082 #define TT_LNO_SNL_DEBUG2 0x00000200 01083 #define TT_LNO_SNL_INTERACT 0x00000400 01084 #define TT_LNO_SE_MALLOC 0x00000800 01085 01086 #define TT_LNO_PREFETCH 0x00001000 01087 #define TT_LNO_PREFETCH_DEBUG 0x00002000 01088 #define TT_LNO_MODEL 0x00004000 01089 #define TT_LNO_CACHE_MODEL_DEBUG 0x00008000 01090 01091 #define TT_LNO_AEQUIV 0x00010000 01092 #define TT_LNO_SCLRZE 0x00020000 01093 #define TT_LNO_DEAD 0x00040000 01094 #define TT_LNO_GUARD 0x00080000 01095 01096 #define TT_LNO_MINVARIANT_DEBUG 0x00100000 01097 #define TT_LNO_NORENAME 0x00200000 01098 #define TT_LNO_SKIP_GS 0x00400000 01099 01100 #define TT_LNO_SKIP_NONLIN 0x01000000 01101 #define TT_LNO_DEBUG_DELIN 0x02000000 01102 #define TT_LNO_BIG_SCALAR_TILES 0x04000000 01103 #define TT_GRAPH_CAPACITY 0x08000000 01104 01105 #define TT_LNO_DEBUG_CSE 0x10000000 01106 #ifdef KEY 01107 #define TT_LNO_DEBUG_SIMD 0x20000000 01108 #define TT_LNO_DEBUG_HOISTIF 0x40000000 01109 #define TT_LNO_LOOP_UNSWITCH 0x80000000 01110 #endif /* KEY */ 01111 01112 // TP_LNOPT = 32 options 01113 01114 #define TT_LEGO_VERBOSE 0x00000001 01115 #define TT_LEGO_DEBUG 0x00000002 01116 #define TT_LEGO_PRAGMAS_ONLY 0x00000004 01117 #define TT_LEGO_DISABLE_DIVMOD 0x00000008 01118 01119 #define TT_LEGO_DISABLE_HOIST 0x00000010 01120 #define TT_LEGO_DISABLE_IMPLICIT_AFFINITY 0x00000020 01121 #define TT_LEGO_DISABLE_EXPLICIT_AFFINITY 0x00000040 01122 #define TT_LEGO_DISABLE_INTERCHANGE 0x00000080 01123 01124 #define TT_LNO_RUN_ARA 0x00000100 01125 #define TT_LNO_ARA_VERBOSE 0x00000200 01126 #define TT_LNO_ARA_DEBUG 0x00000400 01127 #define TT_LNO_NO_AUTO_PARALLEL 0x00000800 01128 01129 #define TT_LEGO_DISABLE_RR_MAPS 0x00001000 01130 #define TT_LEGO_DISABLE_FP_DIVMOD 0x00002000 01131 #define TT_LNO_PARALLEL_DEBUG 0x00004000 01132 #define TT_LNO_NO_TRANSPOSE 0x00008000 01133 01134 #define TT_LNO_DEBUG_PROMPF 0x00010000 01135 #define TT_LNO_DISABLE_SEFIN 0x00020000 01136 #define TT_LNO_NO_PAD 0x00040000 01137 #define TT_LNO_OMP_TRANSFORMS 0x00080000 01138 #define TT_HMB_FORCE_VERSIONS 0x00100000 01139 #define TT_SHACKLE_ONLY 0x00200000 01140 #define TT_TILE_ONLY 0x00400000 01141 #define TT_IPA_LNO_READ 0x00800000 01142 #define TT_CALL_INFO 0x01000000 01143 #define TT_SHACKLE_DEBUG 0x02000000 01144 #define TT_CROSS_LOOP 0x04000000 01145 01146 #ifdef TARG_X8664 01147 extern BOOL Minvariant_Removal_For_Simd; 01148 #endif 01149 #endif /* lnopt_main_INCLUDED */ 01150 01151
1.5.6