Open64: osprey/be/opt/opt_find.cxx Source File

00001 //-*-c++-*-
00002 
00003 /*
00004  * Copyright 2003, 2004, 2005, 2006 PathScale, Inc.  All Rights Reserved.
00005  */
00006 
00007 // ====================================================================
00008 // ====================================================================
00009 //
00010 // Module: opt_find.cxx
00011 // $Revision: 1.1.1.1 $
00012 // $Date: 2005/10/21 19:00:00 $
00013 // $Author: marcel $
00014 // $Source: /proj/osprey/CVS/open64/osprey1.0/be/opt/opt_find.cxx,v $
00015 //
00016 // Revision history:
00017 //  08-APR-95 dahl - Original Version
00018 //
00019 // ====================================================================
00020 //
00021 // Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00022 //
00023 // This program is free software; you can redistribute it and/or modify
00024 // it under the terms of version 2 of the GNU General Public License as
00025 // published by the Free Software Foundation.
00026 //
00027 // This program is distributed in the hope that it would be useful, but
00028 // WITHOUT ANY WARRANTY; without even the implied warranty of
00029 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00030 //
00031 // Further, this software is distributed without any warranty that it
00032 // is free of the rightful claim of any third person regarding
00033 // infringement  or the like.  Any license provided herein, whether
00034 // implied or otherwise, applies only to this software file.  Patent
00035 // licenses, if any, provided herein do not apply to combinations of
00036 // this program with other software, or any other product whatsoever.
00037 //
00038 // You should have received a copy of the GNU General Public License
00039 // along with this program; if not, write the Free Software Foundation,
00040 // Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
00041 //
00042 // Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00043 // Mountain View, CA 94043, or:
00044 //
00045 // http://www.sgi.com
00046 //
00047 // For further information regarding this notice, see:
00048 //
00049 // http://oss.sgi.com/projects/GenInfo/NoticeExplan
00050 //
00051 // ====================================================================
00052 //
00053 // Description:
00054 //
00055 //   Search statements upward from end of BB to beginning looking for a
00056 // given CODEREP. Can search both LHS and RHS expressions (Find_cr) or 
00057 // just LHS (Find_def). Note that Find_cr() and Find_def() are almost
00058 // identical, they are put here in the same file for maintenance reasons.
00059 //
00060 // ====================================================================
00061 // ====================================================================
00062 
00063 
00064 #ifdef USE_PCH
00065 #include "opt_pch.h"
00066 #endif // USE_PCH
00067 #pragma hdrstop
00068 
00069 
00070 #ifdef _KEEP_RCS_ID
00071 #define opt_find_CXX  "opt_find.cxx"
00072 static char *rcs_id =   opt_find_CXX"$Revision: 1.7 $";
00073 #endif /* _KEEP_RCS_ID */
00074 
00075 #include "defs.h"
00076 #include "erglob.h"
00077 #include "tracing.h"
00078 
00079 #include "opt_base.h"
00080 #include "opt_util.h"
00081 #include "opt_main.h"
00082 #include "opt_bb.h"
00083 #include "opt_cfg.h"
00084 #include "opt_sym.h"
00085 #include "opt_htable.h"
00086 #include "opt_mu_chi.h"
00087 #include "opt_ssa.h"
00088 #include "bb_node_set.h"
00089 
00090 
00091 
00092 // returns TRUE if the two CODEREPs have same bit position
00093 // for CK_VAR need to make sure comparison is Vx to Vy (bitpos type)
00094 // for !CK_VAR comparison is Ex to Ey (bitpos type)
00095 BOOL
00096 CODEREP::Compare_bitpos(const CODEREP *cr) const
00097 {
00098   Is_True(this->Bitpos() != ILLEGAL_BP, ("this has illegal BP."));
00099   Is_True(cr->Bitpos() != ILLEGAL_BP, ("this has illegal BP."));
00100 
00101   if (Kind() != cr->Kind()) return FALSE;
00102   if (Kind() == CK_VAR) {
00103     if (cr->Kind() == CK_VAR && Bitpos() == cr->Bitpos()) // Vx <--> Vy
00104       return TRUE;
00105   } else if (Bitpos() == cr->Bitpos())        // Ex <--> Ey
00106       return TRUE;
00107   return FALSE;
00108 }
00109 
00110 
00111 //  Handle VAR or IVAR coderep
00112 //  Return TRUE if the coderep should have the same bitpos.
00113 //  This routine does not require that the CR has a bitpos assigned.
00114 //
00115 BOOL
00116 CODEREP::Same_bitpos(const CODEREP *cr) const
00117 {
00118   if (Kind() != cr->Kind()) return FALSE;
00119 
00120   if (Bitpos() != ILLEGAL_BP && cr->Bitpos() != ILLEGAL_BP)
00121     return Bitpos() == cr->Bitpos();
00122   else {
00123     switch (Kind()) {
00124     case CK_VAR:
00125       if (Aux_id() == cr->Aux_id() && Version()==cr->Version())
00126   return TRUE;
00127       return FALSE;
00128     case CK_IVAR:
00129       {
00130   CODEREP *gcr = Ilod_base();
00131   CODEREP *lcr = cr->Ilod_base();
00132   if (gcr == NULL)
00133     gcr = Istr_base();
00134   if (lcr == NULL) 
00135     lcr = cr->Istr_base();
00136   if (!lcr->Same_bitpos(gcr))
00137     return FALSE;
00138   if (Opr() != OPR_ILOADX) {
00139     if (Offset() != cr->Offset())
00140       return FALSE;
00141   }
00142   else {
00143     gcr = Index();
00144     lcr = cr->Index();
00145     if (!lcr->Same_bitpos(gcr))
00146       return FALSE;
00147   }
00148   if (Get_mtype_class(Dtyp()) != Get_mtype_class(cr->Dtyp()))
00149     return FALSE; // type class not the same
00150   if (MTYPE_size_min(Dsctyp()) != MTYPE_size_min(cr->Dsctyp()))
00151     return FALSE; // size not the same
00152 
00153   if (OPCODE_operator(Op()) == OPR_MLOAD) {
00154     gcr = Mload_size();
00155     if (gcr == NULL)
00156       gcr = Mstore_size();
00157     lcr = cr->Mload_size();
00158     if (lcr == NULL)
00159       lcr = cr->Mstore_size();
00160     if (!lcr->Same_bitpos(gcr))
00161       return FALSE;
00162   }
00163       }
00164       return TRUE;
00165     case CK_OP:
00166       {
00167   if (Op() != cr->Op())
00168     return FALSE;
00169   if (Kid_count() != cr->Kid_count()) // arrays can be different
00170     return FALSE;
00171        
00172   // check additional fields for some specific opcodes
00173   if (OPCODE_operator(Op()) == OPR_INTRINSIC_OP &&
00174       Intrinsic() != cr->Intrinsic())
00175     return FALSE;
00176 #ifdef KEY
00177   else if (OPCODE_operator(Op()) == OPR_PURE_CALL_OP &&
00178            Call_op_aux_id() != cr->Call_op_aux_id())
00179     return FALSE;
00180 #endif
00181   else if (OPCODE_operator(Op()) == OPR_CVTL && Offset() != cr->Offset())
00182     return FALSE;
00183 
00184   for (IDX_32 i=0; i< Kid_count(); i++) {
00185     if (!Opnd(i)->Same_bitpos(cr->Opnd(i)))
00186       return FALSE;
00187   }
00188       }
00189       return TRUE; 
00190       
00191     case CK_CONST:
00192     case CK_RCONST:
00193     case CK_LDA:
00194       return this == cr;
00195     default:
00196       Is_True(FALSE, ("CR kind not handled."));
00197       break;
00198     }
00199   }
00200   return FALSE;
00201 }
00202 
00203 
00204 //----------------------------------------------------------------------------
00205 // search both LHS and RHS for cr
00206 // searches only the given BB
00207 //
00208 CODEREP *
00209 BB_NODE::Find_cr(const CODEREP *cr)
00210 {
00211   CODEREP *retcr, *lhs;
00212   STMTREP *stmt;
00213   STMTREP_ITER stmt_iter(Stmtlist());
00214 
00215   FOR_ALL_NODE_REVERSE(stmt,stmt_iter,Init()) {
00216 
00217     // check RHS first
00218     if (stmt->Rhs()) {
00219       retcr = stmt->Rhs()->Find_cr(cr);
00220       if (retcr)
00221   return retcr;
00222     }
00223 
00224     // check LHS for DEF of this CR
00225     lhs = stmt->Lhs();
00226     if (lhs) {
00227       switch (stmt->Opr()) {
00228         case OPR_STID:
00229         case OPR_STBITS:
00230     if (cr->Compare_bitpos(lhs))
00231       return lhs;
00232           break;
00233   case OPR_ISTORE:
00234         case OPR_ISTBITS:
00235     retcr = lhs->Istr_base()->Find_cr(cr);
00236     if (retcr)
00237       return retcr;
00238     break;
00239   case OPR_MSTORE:
00240     retcr = lhs->Istr_base()->Find_cr(cr);
00241     if (retcr)
00242       return retcr;
00243     retcr = lhs->Mstore_size()->Find_cr(cr);
00244     if (retcr)
00245       return retcr;
00246     break;
00247   default:
00248     break;
00249       }
00250     }
00251     
00252     // check CHI node
00253     if (stmt->Has_chi()) {
00254       CHI_LIST_ITER chi_iter;
00255       CHI_NODE *cnode;
00256       FOR_ALL_NODE(cnode,chi_iter,Init(stmt->Chi_list())) {
00257   if (cnode->Live()) {
00258     retcr = cnode->RESULT();
00259     if (retcr && cr->Same_bitpos(retcr))
00260       return retcr;
00261   }
00262       }
00263     }
00264   } // FOR_ALL_NODE_REVERSE
00265 
00266   // check PHI node
00267   PHI_LIST_ITER phi_iter;
00268   PHI_NODE *pnode;
00269   FOR_ALL_ELEM(pnode,phi_iter,Init(Phi_list())) {
00270     if (!pnode->Dce_dead()) {
00271       if ((retcr = pnode->RESULT()) != NULL)
00272   if (retcr->Bitpos() != ILLEGAL_BP) 
00273     if (cr->Same_bitpos(retcr))
00274       return retcr;
00275     }
00276   }
00277   
00278   return NULL;    // not found
00279 }
00280 
00281 //----------------------------------------------------------------------------
00282 // Find the coderep with the same var bitpos as 'cr'.
00283 // This routine is recursive.
00284 //
00285 CODEREP*
00286 CODEREP::Find_cr(const CODEREP *cr)
00287 {
00288   INT i;
00289   CODEREP *retval = NULL;
00290 
00291   switch (Kind()) {
00292     case CK_VAR:
00293       if (Compare_bitpos(cr))
00294         return this;
00295       break;
00296     case CK_OP:
00297       for (i=0; i<Kid_count(); i++) {
00298   retval = Opnd(i)->Find_cr(cr);
00299   if (retval)
00300     return retval;
00301       }
00302       break;
00303     case CK_IVAR:
00304       retval = (Ilod_base()) ? Ilod_base()->Find_cr(cr) :
00305                                Istr_base()->Find_cr(cr);
00306       if (retval)
00307   return retval;
00308       if (OPCODE_operator(Op()) == OPR_MLOAD)
00309   return Mload_size()->Find_cr(cr);
00310       else if (OPCODE_operator(Op()) == OPR_ILOADX)
00311   return Index()->Find_cr(cr);
00312       break;
00313   }
00314   return retval;
00315 }
00316 
00317 //----------------------------------------------------------------------------
00318 // search LHS for definition point
00319 // searches this BB and all dominator BBs until found
00320 //
00321 //  Returns NULL if a dead phi is found.
00322 //
00323 CODEREP *
00324 BB_NODE::Find_def(const CODEREP *cr)
00325 {
00326   CODEREP *retcr, *lhs;
00327   BB_NODE *bb;
00328 
00329   // are there cr's that will never have a def?
00330   if ( cr->Kind() == CK_IVAR ) {
00331     if ( cr->Opr() == OPR_PARM ) 
00332       return NULL;
00333   }
00334 
00335   for (bb = this; bb != NULL; bb = bb->Idom()) {
00336 
00337     STMTREP *stmt;
00338     STMTREP_ITER stmt_iter(bb->Stmtlist());
00339     FOR_ALL_NODE_REVERSE(stmt,stmt_iter,Init()) {
00340 
00341       // check CHI node
00342       if (stmt->Has_chi()) {
00343   CHI_LIST_ITER chi_iter;
00344   CHI_NODE *cnode;
00345   FOR_ALL_NODE(cnode,chi_iter,Init(stmt->Chi_list())) {
00346     if (cnode->Live()) {
00347       retcr = cnode->RESULT();
00348       if (retcr && cr->Same_bitpos(retcr)) {
00349               if (retcr->Dsctyp() == MTYPE_UNKNOWN ||
00350       retcr->Is_flag_set(CF_MADEUP_TYPE)) {
00351                 retcr->Set_dtyp(cr->Dtyp());
00352                 retcr->Set_dsctyp(cr->Dsctyp()); 
00353                 retcr->Set_lod_ty(MTYPE_To_TY(cr->Dsctyp()));
00354     retcr->Set_sign_extension_flag();
00355     retcr->Reset_flag(CF_MADEUP_TYPE);
00356               }
00357         return retcr;
00358             }
00359     }
00360   }
00361       }
00362 
00363       // check LHS for DEF of this CR
00364       lhs = stmt->Lhs();
00365       if (lhs) {
00366   switch (stmt->Opr()) {
00367         case OPR_STID:
00368   case OPR_STBITS:
00369     if (cr->Compare_bitpos(lhs))
00370       return lhs;
00371           break;
00372   case OPR_ISTORE:
00373   case OPR_ISTBITS:
00374     retcr = lhs->Istr_base()->Find_cr(cr);
00375     if (retcr)
00376       return retcr;
00377     break;
00378   case OPR_MSTORE:
00379     retcr = lhs->Istr_base()->Find_cr(cr);
00380     if (retcr)
00381       return retcr;
00382     retcr = lhs->Mstore_size()->Find_cr(cr);
00383     if (retcr)
00384       return retcr;
00385     break;
00386   case OPR_ISTOREX:
00387     retcr = lhs->Istr_base()->Find_cr(cr);
00388     if (retcr)
00389       return retcr;
00390     retcr = lhs->Index()->Find_cr(cr);
00391     if (retcr)
00392       return retcr;
00393     break;
00394   default:
00395     Is_True(0,("BB_NODE::Find_def, unknown case"));
00396     break;
00397   }
00398       }
00399     
00400     } // stmt loop
00401 
00402     // check PHI node
00403     PHI_LIST_ITER phi_iter;
00404     PHI_NODE *pnode;
00405     FOR_ALL_ELEM(pnode,phi_iter,Init(bb->Phi_list())) {
00406       if (!pnode->Dse_dead() && !pnode->Dce_dead() && (retcr = pnode->RESULT()) != NULL) {
00407     if (cr->Same_bitpos(retcr)) {
00408             if (retcr->Dsctyp() == MTYPE_UNKNOWN ||
00409     retcr->Is_flag_set(CF_MADEUP_TYPE)) {
00410               retcr->Set_dtyp(cr->Dtyp());
00411               retcr->Set_dsctyp(cr->Dsctyp()); 
00412               retcr->Set_lod_ty(MTYPE_To_TY(cr->Dsctyp()));
00413         retcr->Set_sign_extension_flag();
00414         retcr->Reset_flag(CF_MADEUP_TYPE);
00415             }
00416       return retcr;
00417           }
00418       } else 
00419   return NULL;
00420     } // phi loop
00421   } // bb loop
00422 
00423   return NULL;    // not found
00424 }
00425 
00426 // CODEREP::Create_exp_in_bb
00427 //   find or create the CODEREP for 'this' exprep with current version
00428 //   in the 'bb'.
00429 //
00430 CODEREP *
00431 CODEREP::Create_exp_in_bb(BB_NODE *bb, CODEMAP *htable)
00432 {
00433   CODEREP *retv;
00434   switch (Kind()) {
00435   case CK_LDA:
00436   case CK_CONST:
00437   case CK_RCONST:
00438     return this;
00439   case CK_VAR:
00440   case CK_IVAR:
00441     retv = bb->Find_def(this);
00442     if (retv)
00443       retv->Set_Bitpos(this->Bitpos());
00444     return retv;
00445   case CK_OP:
00446     {
00447       CODEREP *cr = Alloc_stack_cr(Extra_ptrs_used());
00448       INT i;
00449       BOOL need_rehash = FALSE;
00450       cr->Copy(*this);
00451       for (i=0; i<Kid_count(); i++) {
00452         CODEREP *opnd = Opnd(i);
00453         retv = opnd->Create_exp_in_bb(bb, htable);
00454 
00455         // cannot find current version down the tree
00456         if (retv == NULL) return NULL;
00457 
00458         retv->Set_Bitpos(opnd->Bitpos());
00459         cr->Set_opnd(i, retv);
00460         if (opnd != retv)
00461           need_rehash = TRUE;
00462       }
00463       if (!need_rehash)
00464         return this;
00465       retv = htable->Rehash(cr);
00466 
00467       if (retv->Bitpos() == ILLEGAL_BP)
00468         retv->Set_Bitpos(this->Bitpos());
00469 
00470       Is_True(retv->Bitpos() ==  this->Bitpos(),
00471               ("CODEREP::Create_exp_in_bb: two bitpos, %d and %d, are merged", retv->Bitpos(), Bitpos()));
00472 
00473       return retv;
00474     }
00475   }
00476   return this;
00477 }
00478 
00479 
00480 class DEFREP {
00481 private:
00482   typedef enum {
00483     DEF_IS_NONE,
00484     DEF_IS_STMT,
00485     DEF_IS_PHI,
00486     DEF_IS_CHI
00487   } DEF_KIND;
00488 
00489   BOOL     _tracing;
00490   DEF_KIND _kind;
00491   union {
00492     STMTREP  *_stmt;
00493     PHI_NODE *_phi;
00494     struct {
00495       CHI_NODE *_chi;
00496       STMTREP  *_chi_stmt;
00497     } _chi_info;
00498   };
00499 
00500 public:
00501   DEFREP(const BOOL tracing,
00502    STMTREP *stmt,
00503    BB_NODE *bb,
00504    const CODEREP *cr)
00505     { _tracing = tracing; 
00506       Find_def_stmt_in_same_bb(stmt, bb, cr);
00507       if (_kind == DEF_IS_NONE) 
00508   Find_def_stmt(bb->Idom(), cr);
00509     }
00510 
00511   DEFREP(const BOOL tracing,
00512          BB_NODE *bb,
00513    const CODEREP *cr)
00514     { _tracing = tracing;
00515       Find_def_stmt(bb, cr); }
00516 
00517   ~DEFREP(void) {}
00518 
00519   void Find_def_stmt(BB_NODE *, const CODEREP *);
00520 
00521   void Find_def_stmt_in_same_bb(STMTREP *, BB_NODE *bb, const CODEREP *);
00522 
00523   BOOL      Tracing(void) const { return _tracing; }
00524 
00525   DEF_KIND  Kind(void) const    { return _kind; }
00526 
00527   void      Set_kind(DEF_KIND kind)
00528     { _kind = kind; }
00529 
00530   void      Set_stmt(STMTREP *stmt)
00531     {
00532       Set_kind(DEF_IS_STMT);
00533       _stmt = stmt;
00534     }
00535 
00536   void      Set_phi(PHI_NODE *phi)
00537     {
00538       Set_kind(DEF_IS_PHI);
00539       _phi = phi;
00540     }
00541 
00542   void      Set_chi(CHI_NODE *chi)
00543     {
00544       Set_kind(DEF_IS_CHI);
00545       _chi_info._chi = chi;
00546     }
00547 
00548   void      Set_chi_stmt(STMTREP *stmt)
00549     {
00550       Is_True(Is_chi_node(),
00551         ("def must be by chi"));
00552       _chi_info._chi_stmt = stmt;
00553     }
00554 
00555   BOOL      Is_stmt_node(void) const
00556     { return Kind() == DEF_IS_STMT; }
00557 
00558   BOOL      Is_phi_node(void)  const
00559     { return Kind() == DEF_IS_PHI; }
00560 
00561   BOOL      Is_chi_node(void)  const
00562     { return Kind() == DEF_IS_CHI; }
00563 
00564   STMTREP  *Stmt(void)     const { return _stmt; }
00565   PHI_NODE *Phi(void)      const { return _phi; }
00566   CHI_NODE *Chi(void)      const { return _chi_info._chi; }
00567   STMTREP  *Chi_stmt(void) const { return _chi_info._chi_stmt; }
00568 
00569   CODEREP  *Result(void) const
00570     {
00571       if (Is_chi_node())
00572   return Chi()->RESULT();
00573       else if (Is_phi_node())
00574   return Phi()->RESULT();
00575       else {
00576   FmtAssert(Is_stmt_node(),
00577       ("Unknown DEFREP kind"));
00578   return Stmt()->Lhs();
00579       }
00580     }
00581 
00582   void      Set_result(CODEREP *cr)
00583     {
00584       if (Is_chi_node()) {
00585   Chi()->Set_RESULT(cr);
00586   // The following is something of a hack, based on the fact
00587   // that we never set the DEFREP result to a zero-version
00588   // coderep.
00589   if (!cr->Is_flag_set(CF_IS_ZERO_VERSION)) {
00590     Chi_stmt()->Recompute_has_zver();
00591   }
00592       }
00593       else if (Is_phi_node()) {
00594   Phi()->Set_result(cr);
00595       }
00596       else {
00597   FmtAssert(Is_stmt_node(),
00598       ("Unknown DEFREP kind"));
00599   Stmt()->Set_lhs(cr);
00600       }
00601     }
00602 
00603   // Annotate_defined_coderep should probably be a member of class
00604   // CODEREP, since it encapsulates the maintenance of invariants
00605   // about CODEREP instances, not really about DEFREPs.
00606 
00607   void Annotate_defined_coderep(CODEREP *cr, CODEMAP *htable)
00608     {
00609       // Adjust fields of *cr to reflect its definition by *this.
00610       if (Is_phi_node()) {
00611   cr->Set_defphi(Phi());
00612   cr->Set_flag(CF_DEF_BY_PHI);
00613   cr->Set_flag(CF_INCOMPLETE_USES);
00614   Is_Trace(Tracing(), (TFile, "phi:\n"));
00615   Is_Trace_cmd(Tracing(), Phi()->Print(Phi()->Size(), TFile));
00616       }
00617       else if (Is_chi_node()) {
00618   cr->Set_defchi(Chi());
00619   cr->Set_defstmt(Chi_stmt());
00620   cr->Set_flag(CF_DEF_BY_CHI);
00621   cr->Set_flag(CF_INCOMPLETE_USES);
00622   Is_Trace(Tracing(), (TFile, "chi:\n"));
00623   Is_Trace_cmd(Tracing(), Chi()->Print(TFile));
00624       }
00625       else {
00626   Is_True(Is_stmt_node(),
00627     ("DEFREP::Annotate_defined_coderep: Illegal DEFREP kind"));
00628   cr->Set_defstmt(Stmt());
00629   Is_Trace(Tracing(), (TFile, "stmt:\n"));
00630   Is_Trace_cmd(Tracing(), Stmt()->Print(TFile));
00631       }
00632       Is_Trace_cmd(Tracing(), cr->Print(2, TFile));
00633     }
00634 };
00635 
00636 // Find_def_stmt finds the statement defining the given coderep.
00637 void
00638 DEFREP::Find_def_stmt(      BB_NODE *bb,
00639           const CODEREP *cr)
00640 {
00641   for (; bb != NULL; bb = bb->Idom()) {
00642     // First check for definition by a real statement.
00643     STMTREP      *stmt;
00644     STMTREP_ITER stmt_iter(bb->Stmtlist());
00645 
00646     FOR_ALL_NODE_REVERSE(stmt, stmt_iter, Init()) {
00647       if (OPERATOR_is_scalar_store (stmt->Opr())) {
00648   if (stmt->Lhs()->Aux_id() == cr->Aux_id()) {
00649     Set_stmt(stmt);
00650     Is_Trace(Tracing(), (TFile, "Found def by stmt in BB:\n"));
00651     Is_Trace_cmd(Tracing(), bb->Print(TFile));
00652     return;
00653   }
00654       }
00655       if (stmt->Has_chi()) {
00656   CHI_LIST_ITER  chi_iter;
00657   CHI_NODE      *cnode;
00658   FOR_ALL_NODE(cnode, chi_iter, Init(stmt->Chi_list())) {
00659     if (cnode->Live() &&
00660         cnode->RESULT()->Aux_id() == cr->Aux_id()) {
00661       Set_chi(cnode);
00662       Set_chi_stmt(stmt);
00663       Is_Trace(Tracing(), (TFile, "Found def by chi in BB:\n"));
00664       Is_Trace_cmd(Tracing(), bb->Print(TFile));
00665       return;
00666     }
00667   }
00668       }
00669     }
00670 
00671     PHI_LIST_ITER  phi_iter;
00672     PHI_NODE      *phi;
00673 
00674     FOR_ALL_ELEM(phi, phi_iter, Init(bb->Phi_list())) {
00675       CODEREP *res = phi->RESULT();
00676       if (phi->Aux_id() == cr->Aux_id()) {
00677   Set_phi(phi);
00678   Is_Trace(Tracing(), (TFile, "Found def by phi in BB:\n"));
00679   Is_Trace_cmd(Tracing(), bb->Print(TFile));
00680   return;
00681       }
00682     }
00683   }
00684 
00685   _kind = DEF_IS_NONE;
00686   _stmt = NULL;
00687 }
00688 
00689 
00690 // Find_def_stmt finds the statement defining the given coderep.
00691 void
00692 DEFREP::Find_def_stmt_in_same_bb(STMTREP *stmt, BB_NODE *bb, const CODEREP *cr)
00693 {
00694   for (; stmt != NULL; stmt = stmt->Prev()) {
00695     if (OPERATOR_is_scalar_store (stmt->Opr())) {
00696       if (stmt->Lhs()->Aux_id() == cr->Aux_id()) {
00697   Set_stmt(stmt);
00698   Is_Trace(Tracing(), (TFile, "Found def by stmt in BB:\n"));
00699   Is_Trace_cmd(Tracing(), bb->Print(TFile));
00700   return;
00701       }
00702     }
00703     if (stmt->Has_chi()) {
00704       CHI_LIST_ITER  chi_iter;
00705       CHI_NODE      *cnode;
00706       FOR_ALL_NODE(cnode, chi_iter, Init(stmt->Chi_list())) {
00707   if (cnode->Live() &&
00708       cnode->RESULT()->Aux_id() == cr->Aux_id()) {
00709     Set_chi(cnode);
00710     Set_chi_stmt(stmt);
00711     Is_Trace(Tracing(), (TFile, "Found def by chi in BB:\n"));
00712     Is_Trace_cmd(Tracing(), bb->Print(TFile));
00713     return;
00714   }
00715       }
00716     }
00717   }
00718 
00719   PHI_LIST_ITER  phi_iter;
00720   PHI_NODE      *phi;
00721 
00722   FOR_ALL_ELEM(phi, phi_iter, Init(bb->Phi_list())) {
00723     CODEREP *res = phi->RESULT();
00724     if (phi->Aux_id() == cr->Aux_id()) {
00725       Set_phi(phi);
00726       Is_Trace(Tracing(), (TFile, "Found def by phi in BB:\n"));
00727       Is_Trace_cmd(Tracing(), bb->Print(TFile));
00728       return;
00729     }
00730   }
00731 
00732   _kind = DEF_IS_NONE;
00733   _stmt = NULL;
00734 }
00735 
00736 
00737 //  Replace the phi opnd with a non-zero version.
00738 //
00739 void
00740 CODEMAP::Fix_zero_version(PHI_NODE *phi, INT opnd_idx, bool allow_real_or_no_def)
00741 {
00742   CODEREP *retval = phi->OPND(opnd_idx);
00743   Is_True(retval->Is_flag_set(CF_IS_ZERO_VERSION),
00744     ("CODEMAP::Fix_zero_version: not a zero version."));
00745 
00746   Is_Trace(Tracing(),
00747      (TFile, "CODEMAP::Fix_zero_version aux-id %d, bb %d, opnd %d\n",
00748       phi->Aux_id(), phi->Bb()->Id(), opnd_idx));
00749 
00750   // Constructor for def_stmt will perform the find-def operation
00751   // (by aux_id) and set the fields of def_stmt accordingly.
00752 
00753   DEFREP def_stmt(Tracing(), phi->Bb()->Nth_pred(opnd_idx), retval);
00754 
00755   // The following assertion is too strong because a zero-version
00756   // might be defined by real assignment, after a conditional
00757   // branch becomes an unconditional branch.   Consider this situation.
00758   // real def --> phi1  --> phi2.    phi1 defines a zero version.
00759   // phi1 is removed after converting a conditional into unconditional br.
00760   // Then opnd of phi2 is defined by a real stmt.
00761   //
00762   if (!allow_real_or_no_def) {
00763     Is_True(def_stmt.Is_phi_node() || def_stmt.Is_chi_node(),
00764       ("Zero version def should be phi or chi"));
00765   } else {
00766     // Fix 630415: in Insert_delete_phi of second renaming,
00767     //  it might not possible to find the defintion of a zero-version 
00768     //  if the "defining" phi has been removed (e.g., because of different opnd count)
00769     //  In that case, there is no need to fix the zero version because deletion of
00770     //  the "defining" phi guarantees that the definitions of its operands
00771     //  are not zero-versions.
00772     if (!def_stmt.Is_phi_node() && 
00773   !def_stmt.Is_chi_node() &&
00774   !def_stmt.Is_stmt_node()) {
00775       Is_Trace(Tracing(),
00776          (TFile, "CODEMAP::Fix_zero_version: cannot fix aux-id %d, bb %d, opnd %d\n",
00777     phi->Aux_id(), phi->Bb()->Id(), opnd_idx));
00778       return;
00779     }
00780   }
00781 
00782   if ((def_stmt.Is_phi_node() && 
00783        (!def_stmt.Phi()->Live() ||
00784   def_stmt.Phi()->Dse_dead() ||
00785   def_stmt.Phi()->Dce_dead())) ||
00786       def_stmt.Result()->Is_flag_set(CF_IS_ZERO_VERSION)) {
00787 
00788     // Add the new definition to the htable; this coderep can no
00789     // longer be zero version.
00790     Is_Trace(Tracing(),
00791        (TFile, " zero version defined by another zero version\n"));
00792 
00793     const CODEREP *phi_res = phi->RESULT();
00794     retval = Add_def(phi_res->Aux_id(),
00795          -1,   /* dummy version number */
00796          NULL, /* defstmt placeholder; will set later */
00797          phi_res->Dtyp(),
00798          phi_res->Dsctyp(),
00799          phi_res->Offset(),
00800          phi_res->Lod_ty(),
00801          phi_res->Field_id(),
00802          TRUE);
00803 
00804     if (phi_res->Is_flag_set(CF_MADEUP_TYPE))
00805       retval->Set_flag(CF_MADEUP_TYPE);
00806 
00807       // Fix 815093: Set volatile flag
00808      if ( Opt_stab()->Is_volatile( phi_res->Aux_id() ) ) {
00809        retval->Set_is_volatile();
00810      }
00811     
00812     // TODO: Probably need to set a bunch of *retval's fields
00813     // here. See opt_ivr.cxx for examples.
00814     
00815     def_stmt.Set_result(retval);
00816     def_stmt.Annotate_defined_coderep(retval, this);
00817   } else {
00818     Is_Trace(Tracing(),
00819        (TFile, "   var_phi opnd defined by nonzero version\n"));
00820     retval = def_stmt.Result();
00821   }
00822 
00823   // *retval is now guaranteed to be non-zero-version. Replace the
00824   // zero version use with a use of the non-zero-version def we
00825   // found.
00826   Is_True(!retval->Is_flag_set(CF_IS_ZERO_VERSION),
00827     ("Defining coderep must not be zero version"));
00828 
00829   phi->Set_opnd(opnd_idx, retval);
00830 }
00831 
00832 
00833 //  Replace the mu opnd with a non-zero version.
00834 //
00835 void
00836 CODEMAP::Fix_zero_version(CHI_NODE *chi, STMTREP *stmt)
00837 {
00838   CODEREP *retval;
00839 
00840   Is_True(chi->OPND()->Is_flag_set(CF_IS_ZERO_VERSION),
00841     ("CODEMAP::Fix_zero_version: not a zero version."));
00842 
00843   Is_Trace(Tracing(),
00844      (TFile, "CODEMAP::Fix_zero_version mu-node aux-id %d, bb %d\n",
00845       chi->OPND()->Aux_id(), stmt->Bb()->Id()));
00846 
00847   // Constructor for def_stmt will perform the find-def operation
00848   // (by aux_id) and set the fields of def_stmt accordingly.
00849 
00850   DEFREP def_stmt(Tracing(), stmt->Prev(), stmt->Bb(), chi->OPND());
00851 
00852   Is_True(def_stmt.Is_phi_node() || def_stmt.Is_chi_node(),
00853     ("Zero version def should be phi or chi"));
00854 
00855   if ((def_stmt.Is_phi_node() && 
00856        (!def_stmt.Phi()->Live() ||
00857   def_stmt.Phi()->Dse_dead() ||
00858   def_stmt.Phi()->Dce_dead())) ||
00859       def_stmt.Result()->Is_flag_set(CF_IS_ZERO_VERSION)) {
00860 
00861     // Add the new definition to the htable; this coderep can no
00862     // longer be zero version.
00863     Is_Trace(Tracing(),
00864        (TFile, " zero version defined by another zero version\n"));
00865 
00866     const CODEREP *chi_opnd = chi->OPND();
00867     retval = Add_def(chi_opnd->Aux_id(),
00868          -1,   /* dummy version number */
00869          NULL, /* defstmt placeholder; will set later */
00870          chi_opnd->Dtyp(),
00871          chi_opnd->Dsctyp(),
00872          chi_opnd->Offset(),
00873          chi_opnd->Lod_ty(),
00874          chi_opnd->Field_id(),
00875          TRUE);
00876 
00877      // Fix 815093: Set volatile flag
00878      if ( Opt_stab()->Is_volatile( chi_opnd->Aux_id() ) ) {
00879        retval->Set_is_volatile();
00880      }
00881 
00882     // TODO: Probably need to set a bunch of *retval's fields
00883     // here. See opt_ivr.cxx for examples.
00884     
00885     def_stmt.Set_result(retval);
00886     def_stmt.Annotate_defined_coderep(retval, this);
00887   } else {
00888     Is_Trace(Tracing(),
00889        (TFile, "   mu opnd defined by nonzero version\n"));
00890     retval = def_stmt.Result();
00891   }
00892 
00893   // *retval is now guaranteed to be non-zero-version. Replace the
00894   // zero version use with a use of the non-zero-version def we
00895   // found.
00896   Is_True(!retval->Is_flag_set(CF_IS_ZERO_VERSION),
00897     ("Defining coderep must not be zero version"));
00898 
00899   chi->Set_OPND(retval);
00900 }
00901