00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055 #ifdef _KEEP_RCS_ID
00056 static char *source_file = __FILE__;
00057 static char *rcs_id = "";
00058 #endif
00059
00060 #include "defs.h"
00061 #include "resource.h"
00062 #include "errors.h"
00063 #include "tracing.h"
00064 #include "mempool.h"
00065 #include "bb.h"
00066 #include "op.h"
00067 #include "op_map.h"
00068 #include "cg_cflow.h"
00069 #include "cg_db_op.h"
00070 #include "cg_flags.h"
00071 #include "tn_map.h"
00072 #include "cg_loop.h"
00073
00074 OP_MAP DB_AUX_OP_Map = NULL;
00075
00076 void DB_Initialize(void)
00077
00078 {
00079 if ( !DB_AUX_OP_Map )
00080 DB_AUX_OP_Map = OP_MAP_Create();
00081 }
00082
00083 void DB_Initialize_OP( OP *op, INT16 dbnum )
00084 {
00085
00086 Is_True(DB_AUX_OP_Map , ("DB_AUX_OP_map not allocated"));
00087 Is_True(OP_MAP_Get(DB_AUX_OP_Map, op) == NULL, ("DB_AUX_OP already allocated"));
00088 OP_MAP_Set(DB_AUX_OP_Map, op, (void *)TYPE_P_ALLOC(DB_AUX_OP));
00089 Set_OPDB_flags(op,0);
00090 Set_OP_dbnum(op,dbnum);
00091 Set_OP_link(op,NULL);
00092 Set_OP_condtn(op,OP_guard(op));
00093 if ( OP_invguard(op) )
00094 Set_OP_invcondtn(op);
00095
00096 }
00097
00098
00099
00100 BOOL Is_DB_OP_Init(OP *op)
00101 {
00102 if ( !DB_AUX_OP_Map )
00103 return FALSE;
00104
00105 if ( !OP_MAP_Get(DB_AUX_OP_Map, op ) )
00106 return FALSE;
00107
00108 return TRUE;
00109 }
00110
00111
00112 void DB_Copy_Aux_OP(OP *dest, OP *src)
00113 {
00114
00115 if ( !Is_DB_OP_Init(src) ) return;
00116 if ( !Is_DB_OP_Init(dest) ) DB_Initialize_OP(dest,OP_dbnum(src));
00117
00118 Set_OPDB_flags(dest,OPDB_flags(src));
00119 Set_OP_dbnum(dest,OP_dbnum(src));
00120 Set_OP_link(dest,OP_link(src));
00121 Set_OP_condtn(dest,OP_condtn(src));
00122
00123 }
00124
00125
00126 void DB_Trace_BB(BB *bb)
00127 {
00128 OP *op;
00129
00130 if ( !CG_enable_reverse_if_conversion ||
00131 Original_DB_count < 2 ) return;
00132
00133 #if 0
00134 if ( LC_Failed() ) return;
00135 #endif
00136
00137 fprintf ( TFile, "\n<cgprep> ****************************************");
00138 fprintf(TFile, " if converted BB:%d \n",BB_id(bb));
00139 FOR_ALL_BB_OPs(bb, op) {
00140 if ( !Is_DB_OP_Init(op) ) {
00141 fprintf(TFile," DB:?? \n");
00142 fprintf(TFile," ");
00143 Print_OP_No_SrcLine(op);
00144 } else {
00145 fprintf(TFile," DB:%d -> BB:%d, "
00146 ,OP_dbnum(op), BB_id(DoBodyBB(OP_dbnum(op))));
00147 if (DoBodyICR(OP_dbnum(op)) ) {
00148 fprintf ( TFile, " %s<ICR:",DBnegateicr(OP_dbnum(op)) ? "!" : "");
00149 Print_TN ( DoBodyICR(OP_dbnum(op)), FALSE );
00150 if (DoBodyICRomega(OP_dbnum(op)))
00151 fprintf(TFile, "[%d]", DoBodyICRomega(OP_dbnum(op)));
00152 fprintf(TFile, ">");
00153 }
00154 if (DoBodyBRCC(OP_dbnum(op)) ) {
00155 if ( DBbrccisf(OP_dbnum(op)) ) {
00156 fprintf ( TFile, " <%s",DoBodyBRCCsense(OP_dbnum(op)) ? "bc1f " : "bc1t ");
00157 } else {
00158 fprintf ( TFile, " <%s",DoBodyBRCCsense(OP_dbnum(op)) ? "beq " : "bne ");
00159 }
00160 Print_TN ( DoBodyBRCC(OP_dbnum(op)), FALSE );
00161 fprintf(TFile, ">");
00162 }
00163
00164 if ( OP_condtn(op) ) {
00165 fprintf ( TFile, " %s<CTN:",OP_invcondtn(op) ? "!" : "");
00166 Print_TN ( OP_condtn(op), FALSE );
00167 fprintf(TFile, ">");
00168 }
00169 if ( OP_cgselect(op) )
00170 fprintf ( TFile, " <ifc select> ");
00171 if ( OP_CFCCOP(op) )
00172 fprintf ( TFile, " <CFCCOP> ");
00173
00174 fprintf(TFile, "\n");
00175 fprintf(TFile," ");
00176 Print_OP_No_SrcLine(op);
00177 }
00178 }
00179 fprintf ( TFile, "<cgprep> ****************************************\n\n");
00180
00181 }
00182
00183 static MEM_POOL rif_pool;
00184 static hTN_MAP rif_tn_map;
00185 static BOOL is_rif_map_init = FALSE;
00186 static BB_MAP rif_bb_map_ICR;
00187 static BB_MAP rif_bb_map_BRCC;
00188
00189 void DB_Rename_Cond_TN_Init(BB *bb )
00190 {
00191 TN **db_rename_bb_ICR;
00192 TN **db_rename_bb_BRCC;
00193 static ST *last_PU = NULL;
00194
00195 if (last_PU != Get_Current_PU_ST()) {
00196 is_rif_map_init = FALSE;
00197 last_PU = Get_Current_PU_ST();
00198 }
00199
00200 if ( !(Original_DB_count > 1 && BB_loophead(bb)) ) return;
00201 if (CG_enable_reverse_if_conversion == FALSE) return;
00202
00203 if ( !is_rif_map_init ) {
00204 MEM_POOL_Initialize(&rif_pool,"reverse_if_conversion_pool",TRUE);
00205 rif_bb_map_ICR = BB_MAP_Create();
00206 rif_bb_map_BRCC = BB_MAP_Create();
00207 }
00208
00209 is_rif_map_init = TRUE;
00210 if ( !BB_MAP_Get(rif_bb_map_ICR, bb) ) {
00211 INT16 dbnum;
00212 UINT8 ntimes = BB_unrollings(bb);
00213 UINT8 unrolling;
00214 INT16 offset;
00215 TN *unroll_tn;
00216 ntimes = ntimes > 0 ? ntimes : 1;
00217 offset = ntimes * Original_DB_count;
00218 db_rename_bb_ICR = TYPE_MEM_POOL_ALLOC_N(TN *, &rif_pool, offset);
00219 db_rename_bb_BRCC = TYPE_MEM_POOL_ALLOC_N(TN *, &rif_pool, offset);
00220 BB_MAP_Set(rif_bb_map_ICR, bb, db_rename_bb_ICR);
00221 BB_MAP_Set(rif_bb_map_BRCC, bb, db_rename_bb_BRCC);
00222
00223 for (dbnum = 1; dbnum <= Original_DB_count; dbnum++ ) {
00224 for ( unrolling = 0 ; unrolling < ntimes ; unrolling++ ) {
00225 db_rename_bb_ICR[dbnum-1+unrolling*Original_DB_count] = (ntimes > 1 ) ?
00226 CG_LOOP_unroll_names_get(DoBodyICR(dbnum), unrolling) :
00227 DoBodyICR(dbnum);
00228 unroll_tn = (ntimes > 1 ) ?
00229 CG_LOOP_unroll_names_get(DoBodyBRCC(dbnum), unrolling) :
00230 DoBodyBRCC(dbnum);
00231 db_rename_bb_BRCC[dbnum-1+unrolling*Original_DB_count] = unroll_tn;
00232 }
00233 }
00234 }
00235 MEM_POOL_Push(&rif_pool);
00236 rif_tn_map = hTN_MAP_Create(&rif_pool);
00237 }
00238
00239 void DB_Rename_Cond_TN(BB *bb, TN *dest, TN *src, UINT8 omega)
00240 {
00241 if (CG_enable_reverse_if_conversion == FALSE) return;
00242
00243 if ( !TN_is_if_conv_cond(dest) ) return;
00244
00245 if ( !(Original_DB_count > 1 && BB_loophead(bb)) ) return;
00246
00247 if ( !is_rif_map_init ) return;
00248 hTN_MAP_Set(rif_tn_map, dest, src);
00249
00250 Set_TN_is_if_conv_cond(src);
00251 Reset_TN_is_if_conv_cond(dest);
00252
00253 }
00254
00255 inline TN *find_last_cond_tn (BB *bb, TN *tn )
00256 {
00257 TN *new_tn;
00258 TN *last_tn;
00259
00260 if ( !tn ) return tn;
00261
00262 for ( new_tn = tn; new_tn; new_tn = (TN *)hTN_MAP_Get(rif_tn_map, last_tn) ) {
00263 last_tn = new_tn;
00264 }
00265
00266 return (tn == last_tn) ? NULL : last_tn;
00267
00268 }
00269
00270 void DB_Rename_Cond_TN_Finish( void )
00271 {
00272 if ( !is_rif_map_init ) return;
00273 BB_MAP_Delete(rif_bb_map_ICR);
00274 BB_MAP_Delete(rif_bb_map_BRCC);
00275 MEM_POOL_Delete(&rif_pool);
00276 is_rif_map_init = FALSE;
00277 Original_DB_count = 1;
00278 }
00279
00280 inline TN *rif_cond_tn_get_ICR(BB *bb, INT16 dbnum, UINT8 unrolling)
00281 {
00282 INT16 offset = unrolling * Original_DB_count;
00283 TN **entry = (TN **)BB_MAP_Get(rif_bb_map_ICR, bb);
00284 return entry ? entry[dbnum-1+offset] : NULL;
00285 }
00286
00287 inline void rif_cond_tn_set_ICR(BB *bb, INT16 dbnum, TN *tn, UINT8 unrolling)
00288 {
00289 INT16 offset = unrolling * Original_DB_count;
00290 TN **entry = (TN **)BB_MAP_Get(rif_bb_map_ICR, bb);
00291 if ( !entry ) return;
00292 entry[dbnum-1+offset] = tn;
00293 }
00294
00295 inline TN *rif_cond_tn_get_BRCC(BB *bb, INT16 dbnum, UINT8 unrolling)
00296 {
00297 INT16 offset = unrolling * Original_DB_count;
00298 TN **entry = (TN **)BB_MAP_Get(rif_bb_map_BRCC, bb);
00299 return entry ? entry[dbnum-1+offset] : NULL;
00300 }
00301
00302 inline void rif_cond_tn_set_BRCC(BB *bb, INT16 dbnum, TN *tn, UINT8 unrolling )
00303 {
00304 INT16 offset = unrolling * Original_DB_count;
00305 TN **entry = (TN **)BB_MAP_Get(rif_bb_map_BRCC, bb);
00306 if ( !entry ) return;
00307 entry[dbnum-1+offset] = tn;
00308 }
00309
00310 void DB_Rename_Cond_TN_OPs(BB *bb )
00311 {
00312 OP *op;
00313 TN *new_tn = NULL;
00314 UINT8 ntimes = BB_unrollings(bb);
00315 UINT8 unrolling;
00316 ntimes = ntimes > 0 ? ntimes : 1;
00317
00318 if ( !(Original_DB_count > 1 && BB_loophead(bb)) ) return;
00319
00320 if ( !is_rif_map_init ) return;
00321
00322 if ( BB_MAP_Get(rif_bb_map_ICR, bb) ) {
00323 INT16 dbnum;
00324
00325 for ( dbnum = 1; dbnum <= Original_DB_count; dbnum++ ) {
00326 for ( unrolling = 0 ; unrolling < ntimes ; unrolling++ ) {
00327 if (new_tn = find_last_cond_tn(bb,rif_cond_tn_get_ICR(bb,dbnum, unrolling)) ) {
00328 Set_TN_is_if_conv_cond(new_tn);
00329 rif_cond_tn_set_ICR(bb,dbnum,new_tn, unrolling);
00330 }
00331 if (new_tn = find_last_cond_tn(bb,rif_cond_tn_get_BRCC(bb,dbnum, unrolling)) ) {
00332 Set_TN_is_if_conv_cond(new_tn);
00333 rif_cond_tn_set_BRCC(bb,dbnum,new_tn, unrolling);
00334 }
00335 }
00336 }
00337 }
00338
00339 FOR_ALL_BB_OPs(bb, op ) {
00340 if ( Is_DB_OP_Init(op) ) {
00341 if ( new_tn = find_last_cond_tn(bb,OP_condtn(op)) )
00342 Set_OP_condtn(op, new_tn);
00343 }
00344 }
00345
00346 MEM_POOL_Pop(&rif_pool);
00347 }
00348
00349 TN *DB_Get_ICR(BB *bb, INT16 dbnum, UINT8 unrolling)
00350 {
00351 TN *tn;
00352 if ( !is_rif_map_init ) return DoBodyICR(dbnum);
00353 tn = rif_cond_tn_get_ICR(bb, dbnum,unrolling);
00354 return tn ? tn : DoBodyICR(dbnum);
00355 }
00356
00357 TN *DB_Get_BRCC(BB *bb, INT16 dbnum, UINT8 unrolling)
00358 {
00359 TN *tn;
00360 if ( !is_rif_map_init ) return DoBodyBRCC(dbnum);
00361 tn = rif_cond_tn_get_BRCC(bb, dbnum,unrolling);
00362 return tn ? tn : DoBodyBRCC(dbnum);
00363 }
00364
00365
00366
00367
00368
00369
