Main Page | Class Hierarchy | Alphabetical List | Compound List | File List | Compound Members | File Members

dag_dependency.C

Go to the documentation of this file.
00001 // dag_dependency.C
00002 //
00003 // 2/11/98 WAH:  Broke away from Scheduler package; some renaming.
00004 // 3/23/98 WAH:  Added RemoveUndefPredecessors.
00005 // 3/30/98 WAH:  Removed pointless calls to RegisterInfo constructors;
00006 //               did a little rework on RemoveUndefPredecessors.
00007 // 4/19/98 MDJ:  When pointless calls to RegisterInfo constructors are 
00008 //               removed, initialization must be added or spurious 
00009 //               dependencies result
00010 // 11/4/98 MDJ:  Added support for BRL source parameter passing. We now catch 
00011 //               deps for the up to four MACRO regs passed. Other parameters 
00012 //               passed through memory (I am depending on existing memory deps 
00013 //               to keep these accurate)
00014 // 11/4/98 MDJ:  Fixed bug to include predicate register in UpdateUseStatus()
00015 
00016 //#define _DEBUG_TABLE_
00017 
00018 #define CreateDagHashKey(W,X,Y,Z)       sprintf( (Z), "%d-", (W) );     \
00019                                 sprintf( (Y), "%d", (X) );      \
00020                                 Z = strcat( (Z), (Y) )
00021 
00022 #define CreateDagWriteHashKey(X,Y)      FunctionName = "CreateDagWriteHashKey()";       \
00023                                 WriteHashKey = new char[Hash_Key_Size]; \
00024                                 WriteHashReg = new char[Hash_Reg_Size]; \
00025                                 HashKeyList.push_back( WriteHashKey );  \
00026                                 sprintf( WriteHashKey, "%d-", (X) );    \
00027                                 sprintf( WriteHashReg, "%d", (Y) );     \
00028                                 WriteHashKey=strcat(WriteHashKey,WriteHashReg); \
00029                                 delete[] WriteHashReg
00030 
00031 // Determine if two bit vectors that represent "paths" through a HB have 
00032 // have any common paths. Only InDependent if common paths do not exist. 
00033 //      
00034 int dag::AreVectorsIndependent(bitvector *vector1, bitvector *vector2, int vector_size)
00035 {
00036 
00037   // make sure vectors are the same size
00038   if (vector1->GetSize() != vector2->GetSize())
00039     return FALSE;
00040   
00041   for (int i = 0; i < vector_size; i++) {
00042     // Not independent if both vectors have the same bit set
00043     if (vector1->Read(i))
00044       if (vector2->Read(i))
00045         return FALSE; 
00046   }
00047   
00048   return TRUE;
00049 
00050 }
00051 
00052 
00053 // Determine if there can be dependencies between these two ops based on 
00054 // their PredVectors                    
00055 int dag::AreOpsDependent(legoOp *Op1, legoOp *Op2)
00056 {
00057   bitvector *Op1vector, *Op2vector; 
00058   int Op1treeId, Op2treeId, required_size; 
00059   attrs *a;
00060 
00061   Op1treeId = ((legoRegion *)Op1->GetParentBlockPtr())->GetRegionId();
00062   Op2treeId = ((legoRegion *)Op2->GetParentBlockPtr())->GetRegionId();
00063   
00064   dderr ("Op1treeId = " << Op1treeId << ", Op2treeId = " << Op2treeId << "\n");
00065 
00066   if (Op1treeId == Op2treeId) {
00067     Op1vector = Op1->GetPredVectorPtr(); 
00068     Op2vector = Op2->GetPredVectorPtr(); 
00069     if ((Op1vector != NULL) &&  (Op2vector != NULL)) {
00070       dderr ("Op1vector is :\n");
00071 #ifdef _SHOW_VECTORS_
00072       Op1vector->Show(); 
00073 #endif
00074       dderr ("\nOp2vector is :\n");
00075 #ifdef _SHOW_VECTORS_
00076       Op2vector->Show(); 
00077 #endif
00078       dderr ("\n");
00079       int vector_size = FindLcAttribute("pred_vector_size", 
00080                                         (legoRegion *)Op1->GetParentBlockPtr())
00081         ->GetAttrOprdPtr()->GetLiteralInteger();
00082       if (AreVectorsIndependent(Op1vector, Op2vector, vector_size)) {
00083         dderr ("return FALSE (independent)\n");
00084         return FALSE;
00085       }
00086     }
00087   }
00088   
00089   dderr ("return TRUE (dependent)\n");
00090   return TRUE;
00091   
00092 }
00093 
00094 // FindOprd: given a a ptr to an Oprd and a regid, search oprdList for
00095 //    an Oprd that has a matching regid
00096 // wah: made FindOprd static
00097 static legoOprd *FindOprd( legoOprd *oprdList, int regid )
00098 {
00099    legoOprd *list;
00100 
00101 
00102    derr( ">> FindOprd: target reg " << regid << "\n" );
00103    for ( list = oprdList; list != NULL; list = list->GetNextOprdPtr() ) {
00104       if ( list->GetOprdType() == OT_REG && regid == list->GetOprdRegNum() ) {
00105          derr( "** Reg " << list->GetOprdRegNum() << "**\n" );
00106          derr( "<< FindOprd\n" );
00107          return list;
00108       }
00109    }
00110 
00111    derr( "<< FindOprd\n" );
00112    return NULL;
00113 }
00114 
00115 
00116 /* Determining OUTPUT dependencies. */
00117 
00118 /***************** BEGIN *****************/
00119 
00120 // OutputDeps: detect and create edges for output dependencies for curOp.
00121 //    rc=1 means a dep was detected, rc=0 means otherwise.
00122 int dag::OutputDeps( legoOprd *Oprd,
00123                      MainList::iterator curOp )
00124 {
00125    legoOprd *tableOprd;
00126    int regid,
00127        reg_file_type,
00128        NumRegOprds = 0,
00129        rc = 0;
00130    MainList::iterator opPtr;
00131 
00132 
00133    derr( ">> OutputDeps\n");
00134 
00135    regid = Oprd->GetOprdRegNum();
00136    if ( Oprd->GetOprdType() == OT_MACRO ) reg_file_type = -1;
00137    else reg_file_type = Oprd->GetOprdFileType();
00138 
00139    derr( "   Reg " << regid << "\n" );
00140 
00141 #if 0
00142    CreateReadHashKey( regid, reg_file_type );
00143 #else
00144    CreateDagHashKey( regid, reg_file_type, ReadHashReg, ReadHashKey );
00145 #endif
00146    derr( "   Initial Hash key --> " << ReadHashKey << " <--\n" );
00147 
00148    LookupIter = Table.find( ReadHashKey );
00149    ReadElement = (*LookupIter).second;
00150 
00151    if ( LookupIter == Table.end() || ReadElement.DefiningOpId == -1 ) {
00152 
00153       // The rc depends on if an entry exists at all, even if it doesn't
00154       // specify a defining op.
00155       rc = LookupIter == Table.end() ? 0 : 1;
00156       derr( "...no dep exists\n" );
00157       // ReadElement.PrintInfo();
00158    }
00159 
00160    // If the table lookup was successful AND a defining OP exists,
00161    // a dependency *definitely* exists.
00162    else if ( LookupIter != Table.end() && ReadElement.DefiningOpId != -1 ) {
00163      
00164      rc = 1;
00165      
00166      // Loop through all of the Ops preceding the one with which the
00167      // output-dep exists. For all ET_LINKDEST edges, if the edge was placed
00168      // because of this specific dest operand, add an output-dep edge.
00169      for ( opPtr = ReadElement.DefiningOp; opPtr != NULL; ) {
00170        
00171        vector < SmallListElement >::iterator Front, Back;
00172        int match = 0;
00173        attrs *a;
00174        legoOprd *attrOprd;
00175        int ortho_reg_numb1, ortho_reg_numb2;
00176 
00177        if (AreOpsDependent((*curOp).GetOp(), (*opPtr).GetOp())) {
00178          
00179          // Print out the defining Op's Opid
00180          dderr( "** Output-dep w/Op " << (*opPtr).GetOp()->GetOpId() << "\n" );
00181          
00182          // Add an edge from curOp to opPtr to indicate that curOp is
00183          // is dependent on opPtr
00184          (*curOp).AddPredecessor( ET_REGOUT, (*opPtr).GetOp(), &(*opPtr) );
00185          
00186          // Add an edge from opPtr to curOp to indicate that opPtr
00187          // 'enables' curOp.
00188          (*opPtr).AddSuccessor( ET_REGOUT, (*curOp).GetOp(), &(*curOp) );
00189          
00190          InternalNodes += 2;
00191        }
00192        else {
00193          dderr( "** Output-dep w/Op " << (*opPtr).GetOp()->GetOpId()
00194               << " skipped because PredVectors show independence\n" );
00195        }
00196        
00197        dderr( "   Searching " << (*opPtr).GetOp()->GetOpId()
00198             << "'s predecessors\n" );
00199        
00200        // Search through all of this Op's predecessors. For any that
00201        // have an ET_LINKDEST edge with the same value as the current
00202        // operand hash key, set it to opPtr.
00203        for ( match = 0, Front = (*opPtr).Predecessors->begin(),
00204             Back = (*opPtr).Predecessors->end();
00205             Front != Back && match == 0; Front++ ) {
00206          derr( "   Examine Op " << (*Front).GetOp()->GetOpId() << "\n" );
00207          if ( (*Front).GetDependencyType() == ET_LINKDEST ) {
00208            
00209            legoOprd *Oprd;
00210            
00211            opPtr = (*Front).GetDagEntry();
00212            Oprd = (*opPtr).GetOp()->GetDestOprdPtr();
00213            while ( Oprd != NULL ) {
00214              
00215              int OprdType = Oprd->GetOprdType();
00216              
00217              if ( OprdType == OT_REG || OprdType == OT_MACRO ) {
00218                
00219                char *Key = new char[ Hash_Key_Size ];
00220                
00221                regid = Oprd->GetOprdRegNum();
00222                derr( "   Reg " << regid );
00223                if ( Oprd->GetOprdType() == OT_MACRO ) reg_file_type = -1;
00224                else reg_file_type = Oprd->GetOprdFileType();
00225                CreateDagHashKey( regid, reg_file_type, ReadHashReg, Key );
00226                derr( "   Hash key --> " << Key << " <--\n" );
00227                if ( strcmp( Key, ReadHashKey ) == 0 ) {
00228                  derr( "   Found: >" << Key << "<\n" );
00229                  match = 1;
00230                } // if - match, add an output-dep edge
00231                delete [] Key;
00232              } // if - examine only macro and register operands
00233              Oprd = Oprd->GetNextOprdPtr();
00234            } // while - check all of the pred's dest operands
00235 
00236 
00237            if (((*opPtr).GetOp()->IsBRLOp()) && 
00238                (match == 0)) {
00239             if(inp_start == 0 && inp_end == 0 && ret_start == 0 && ret_end == 0) //HZ:   
00240             {
00241              // Need to assume that BRLs define all INT_P*'s, FLT_P*'s, 
00242              // DBL_P*'s and *_RET's. 
00243              reg_file_type = -1;
00244              for (regid = INT_P1; regid <= DBL_RET; regid++) {
00245                derr( "   Reg " << regid );
00246                char *Key = new char[ Hash_Key_Size ];
00247                CreateDagHashKey( regid, reg_file_type, ReadHashReg, Key );
00248                derr( "   Hash key --> " << Key << " <--\n" );
00249                if ( strcmp( Key, ReadHashKey ) == 0 ) {
00250                  derr( "   Found: >" << Key << "<\n" );
00251                  match = 1;
00252                } // if - match, add an output-dep edge
00253                delete [] Key;
00254              }
00255             } //end of if(inp_start == 0 ...
00256             else
00257             {
00258              reg_file_type = FT_GPR;
00259              for (regid = inp_start; regid <= inp_end; regid++) {
00260                derr( "   Reg " << regid );
00261                char *Key = new char[ Hash_Key_Size ];
00262                CreateDagHashKey( regid, reg_file_type, ReadHashReg, Key );
00263                derr( "   Hash key --> " << Key << " <--\n" );
00264                if ( strcmp( Key, ReadHashKey ) == 0 ) {
00265                  derr( "   Found: >" << Key << "<\n" );
00266                  match = 1;
00267                } // if - match, add an output-dep edge
00268                delete [] Key;
00269              } //end of for(regid = inp_start...
00270              
00271              reg_file_type = FT_GPR;
00272              for (regid = ret_start; regid <= ret_end; regid++) {
00273                derr( "   Reg " << regid );
00274                char *Key = new char[ Hash_Key_Size ];
00275                CreateDagHashKey( regid, reg_file_type, ReadHashReg, Key );
00276                derr( "   Hash key --> " << Key << " <--\n" );
00277                if ( strcmp( Key, ReadHashKey ) == 0 ) {
00278                  derr( "   Found: >" << Key << "<\n" );
00279                  match = 1;
00280                } // if - match, add an output-dep edge
00281                delete [] Key;
00282              } //end of for(regid = ret_start...
00283              
00284              reg_file_type = FT_FPR;
00285              for (regid = fp_ret_start; regid <= fp_ret_end; regid++) {
00286                derr( "   Reg " << regid );
00287                char *Key = new char[ Hash_Key_Size ];
00288                CreateDagHashKey( regid, reg_file_type, ReadHashReg, Key );
00289                derr( "   Hash key --> " << Key << " <--\n" );
00290                if ( strcmp( Key, ReadHashKey ) == 0 ) {
00291                  derr( "   Found: >" << Key << "<\n" );
00292                  match = 1;
00293                } // if - match, add an output-dep edge
00294                delete [] Key;
00295              } //end of for(regid = fp_ret_start...
00296                 
00297             } // end of else of if (inp_start == 0 ...
00298            }
00299          } // if = examine any ET_LINKDEST edge
00300        } // for - examine all of opPtr's predecessors
00301        if ( match == 0 ) opPtr = NULL;
00302      }
00303    } // if
00304    
00305    derr( "<< OutputDeps\n");
00306    return rc;
00307 }
00308 
00309 /****************** END ******************/
00310 
00311 
00312 /* Determining ANTI dependencies. */
00313 
00314 /***************** BEGIN *****************/
00315 
00316 // AntiDeps: detect and create edges for anti-dependencices for curOp
00317 //    rc=1 means a dep was detected, rc=0 means otherwise.
00318 int dag::AntiDeps( legoOprd *Oprd, MainList::iterator curOp )
00319 {
00320   legoOprd *tableOprd;
00321   int regid,
00322   reg_file_type,
00323   NumRegOprds = 0,
00324   rc = 0;
00325   MainList::iterator opPtr;
00326   
00327   
00328   derr( ">> AntiDeps\n");
00329   regid = Oprd->GetOprdRegNum();
00330   derr( "   Reg " << regid );
00331   if ( Oprd->GetOprdType() == OT_MACRO ) reg_file_type = -1;
00332   else reg_file_type = Oprd->GetOprdFileType();
00333   
00334 #if 0
00335   CreateReadHashKey( regid, reg_file_type );
00336 #else
00337   CreateDagHashKey( regid, reg_file_type, ReadHashReg, ReadHashKey );
00338 #endif
00339   derr( "   Hash key --> " << ReadHashKey << " <--\n" );
00340   
00341   LookupIter = Table.find( ReadHashKey );
00342   ReadElement = (*LookupIter).second;
00343   
00344   if ( LookupIter == Table.end() || ReadElement.UsingOpId == -1 ) {
00345       rc = 0;
00346       derr( "   No dep exists\n" );
00347       // ReadElement.PrintInfo();
00348     }
00349   
00350   // If the table lookup was successful AND a using Op exists,
00351   // a dependency *definitely* exists.
00352   else if ( LookupIter != Table.end() && ReadElement.UsingOpId != -1 
00353            && ReadElement.UsingOpId != (*curOp).GetOp()->GetOpId() ) {
00354     rc = 1;
00355     // Loop through all of the Ops preceding the one with which the
00356     // anti-dep exists. For all ET_LINKSRC edges, if the edge was placed
00357     // because of this specific src operand, add an anti-dep edge.
00358     for ( opPtr = ReadElement.UsingOp; opPtr != NULL; ) {
00359       
00360       vector < SmallListElement >::iterator Front, Back;
00361       int match = 0;
00362       attrs *a;
00363       legoOprd *attrOprd;
00364       int ortho_reg_numb1, ortho_reg_numb2;
00365       
00366       if (AreOpsDependent((*curOp).GetOp(), (*opPtr).GetOp())) {
00367         
00368         // Print out the using Op's Opid
00369         dderr( "** Anti-dep w/Op " << (*opPtr).GetOp()->GetOpId() << "\n" );
00370         
00371         // Add an edge from curOp to opPtr to indicate that curOp is
00372         // is dependent on opPtr
00373         (*curOp).AddPredecessor( ET_REGANTI, (*opPtr).GetOp(), &(*opPtr) );
00374         
00375         // Add an edge from opPtr to curOp to indicate that opPtr
00376         (*opPtr).AddSuccessor( ET_REGANTI, (*curOp).GetOp(), &(*curOp) );
00377         
00378         InternalNodes += 2;
00379       }
00380       else {
00381         dderr( "** Anti-dep w/Op " << (*opPtr).GetOp()->GetOpId()
00382              << " skipped because PredVectors show independence\n" );
00383       }
00384       
00385       dderr( "   Searching " << (*opPtr).GetOp()->GetOpId()
00386            << "'s predecessors\n" );
00387       
00388       // Search through all of this Op's predecessors. For any that
00389       // have an ET_LINKSRC edge with the same value as the current
00390       // operand hash key, set it to opPtr.
00391       for ( match = 0, Front = (*opPtr).Predecessors->begin(),
00392            Back = (*opPtr).Predecessors->end();
00393            Front != Back && match == 0; Front++ ) {
00394         derr( "   Examine Op " << (*Front).GetOp()->GetOpId() << "\n" );
00395         if ( (*Front).GetDependencyType() == ET_LINKSRC ) {
00396           
00397           legoOprd *Oprd;
00398           
00399           opPtr = (*Front).GetDagEntry();
00400           Oprd = (*opPtr).GetOp()->GetSrcOprdPtr();
00401           while ( Oprd != NULL ) {
00402             
00403             int OprdType = Oprd->GetOprdType();
00404             
00405             if ( OprdType == OT_REG || OprdType == OT_MACRO ) {
00406               
00407               char *Key = new char[ Hash_Key_Size ];
00408               
00409               regid = Oprd->GetOprdRegNum();
00410               derr( "   Reg " << regid );
00411               if ( Oprd->GetOprdType() == OT_MACRO ) reg_file_type = -1;
00412               else reg_file_type = Oprd->GetOprdFileType();
00413               CreateDagHashKey( regid, reg_file_type, ReadHashReg, Key );
00414               derr( "   Hash key --> " << Key << " <--\n" );
00415               if ( strcmp( Key, ReadHashKey ) == 0 ) {
00416                 derr( "   Found: >" << Key << "<\n" );
00417                 match = 1;
00418               } // if - match, add an anti-dep edge
00419               delete [] Key;
00420             } // if - examine only macro and register operands
00421             Oprd = Oprd->GetNextOprdPtr();
00422           } // while - check all of the pred's src operands
00423 
00424 
00425           if (((*opPtr).GetOp()->IsBRLOp()) && 
00426               (match == 0)) {
00427            if(inp_start == 0 && inp_end == 0 && ret_start == 0 && ret_end == 0) //HZ:
00428            {   
00429             // Need to assume that BRLs use all INT_P*'s, FLT_P*'s, DBL_P*'s. 
00430             reg_file_type = -1;
00431             for (regid = INT_P1; regid <= DBL_P2; regid++) {
00432               derr( "   Reg " << regid );
00433               char *Key = new char[ Hash_Key_Size ];
00434               CreateDagHashKey( regid, reg_file_type, ReadHashReg, Key );
00435               derr( "   Hash key --> " << Key << " <--\n" );
00436               if ( strcmp( Key, ReadHashKey ) == 0 ) {
00437                 derr( "   Found: >" << Key << "<\n" );
00438                 match = 1;
00439               } // if - match, add an output-dep edge
00440               delete [] Key;
00441             }
00442            }//end of if(inp_start == 0 ...
00443            else
00444            {
00445             reg_file_type = FT_GPR;
00446             for (regid = inp_start; regid <= inp_end; regid++) {
00447               derr( "   Reg " << regid );
00448               char *Key = new char[ Hash_Key_Size ];
00449               CreateDagHashKey( regid, reg_file_type, ReadHashReg, Key );
00450               derr( "   Hash key --> " << Key << " <--\n" );
00451               if ( strcmp( Key, ReadHashKey ) == 0 ) {
00452                 derr( "   Found: >" << Key << "<\n" );
00453                 match = 1;
00454               } // if - match, add an output-dep edge
00455               delete [] Key;
00456             }//end of for(regid = inp_start...
00457             reg_file_type = FT_GPR;
00458             for (regid = ret_start; regid <= ret_end; regid++) {
00459               derr( "   Reg " << regid );
00460               char *Key = new char[ Hash_Key_Size ];
00461               CreateDagHashKey( regid, reg_file_type, ReadHashReg, Key );
00462               derr( "   Hash key --> " << Key << " <--\n" );
00463               if ( strcmp( Key, ReadHashKey ) == 0 ) {
00464                 derr( "   Found: >" << Key << "<\n" );
00465                 match = 1;
00466               } // if - match, add an output-dep edge
00467               delete [] Key;
00468             }//end of for(regid = ret_start...
00469             reg_file_type = FT_FPR;
00470             for (regid = fp_ret_start; regid <= fp_ret_end; regid++) {
00471               derr( "   Reg " << regid );
00472               char *Key = new char[ Hash_Key_Size ];
00473               CreateDagHashKey( regid, reg_file_type, ReadHashReg, Key );
00474               derr( "   Hash key --> " << Key << " <--\n" );
00475               if ( strcmp( Key, ReadHashKey ) == 0 ) {
00476                 derr( "   Found: >" << Key << "<\n" );
00477                 match = 1;
00478               } // if - match, add an output-dep edge
00479               delete [] Key;
00480             }//end of for(regid = fp_ret_start...           
00481            } // end of else of if(inp_start == 0...
00482           }
00483           
00484               
00485         } // if = examine any ET_LINKSRC adge
00486       } // for - examine all of opPtr's predecessors
00487       if ( match == 0 ) opPtr = NULL;
00488     }
00489   }
00490   derr( "<< AntiDeps\n");
00491   return rc;
00492 }
00493 
00494 /****************** END ******************/
00495 
00496 
00497 // OutputAntiDeps: detect and create edges for OUTPUT & ANTI dependencices for
00498 //    the curOp
00499 void dag::OutputAntiDeps( MainList::iterator curOp, BigListElement *Element )
00500 {
00501    legoOprd *Oprd, *PredOprd;
00502    DagHashTable::iterator TableIter;
00503    int regid,
00504        rc,
00505        OprdType,
00506        reg_file_type;
00507    MainList::iterator Front;
00508 
00509 
00510    derr( ">> OutputAntiDeps: Op " << (*curOp).GetOp()->GetOpId() << "\n" );
00511 
00512 #ifdef _DAG_DEBUG_
00513    if ( (*curOp).GetOp()->GetDestOprdPtr() == NULL ) {
00514       derr( "   NULL operand ptr\n" );
00515    }
00516 #endif
00517    if ( (*curOp).GetOp()->GetDestOprdPtr() != NULL ) {
00518       for ( Oprd=(*curOp).GetOp()->GetDestOprdPtr(); Oprd != NULL;
00519             Oprd = Oprd->GetNextOprdPtr() ) {
00520 
00521          if ( (OprdType=Oprd->GetOprdType()) == OT_REG
00522              || OprdType == OT_MACRO ) {
00523 
00524             if ( OprdType == OT_MACRO ) reg_file_type = -1;
00525             else reg_file_type = Oprd->GetOprdFileType();
00526 
00527             regid = Oprd->GetOprdRegNum();
00528             rc = OutputDeps( Oprd, curOp );
00529 
00530             // Annotate that this register is defined here.
00531             derr( "...def-" << regid << "\n" );
00532 
00533             // Prepare for update to hash table
00534             WriteElement.RFType = reg_file_type;
00535             WriteElement.Regid = regid;
00536             WriteElement.DefiningOpId = (*curOp).GetOp()->GetOpId();
00537             WriteElement.DefiningOp = curOp;
00538             WriteElement.DefOp = (*curOp).GetOp();
00539 
00540             // Table update/insert
00541             if ( rc == 1 ) {    // Not a new entry
00542 #if 0
00543                CreateReadHashKey( regid, reg_file_type );
00544 #else
00545                CreateDagHashKey( regid, reg_file_type, ReadHashReg, ReadHashKey );
00546 #endif
00547 
00548                // Find the entry in the table
00549                TableIter = Table.find( ReadHashKey );
00550                ReadElement = (*TableIter).second;
00551 
00552                // If curOp's predicate is not TRUE, must link with prev def 
00553                PredOprd = (*curOp).GetOp()->GetPredOprdPtr();
00554                if (PredOprd != NULL) {
00555                  if (PredOprd->GetOprdType() != OT_LITERAL_P ||
00556                      PredOprd->GetLiteralPredicate() != TRUE ) {
00557                    // We need to chain the previous def to this def so that 
00558                    // correct flow and output deps can be created. This is 
00559                    // necessary for utilizing hammock conversion in treegions
00560                    derr("Def predicated with non-TRUE predicate. Must link with prev def\n");
00561                    
00562                    if (ReadElement.DefiningOpId != -1) {
00563                      
00564                      MainList::iterator PrevDefiningOp = ReadElement.DefiningOp;
00565                      
00566                      dderr( "   Prev def found, linking w/op "
00567                           << (*PrevDefiningOp).GetOp()->GetOpId() << "\n" );
00568                      (*curOp).AddPredecessor( ET_LINKDEST, (*PrevDefiningOp).GetOp(),
00569                                              &(*PrevDefiningOp) );
00570                    }
00571                  }
00572                }
00573                // Maintain the 'old' use values
00574                WriteElement.UsingOpId = ReadElement.UsingOpId;
00575                WriteElement.UsingOp = ReadElement.UsingOp;
00576                WriteElement.UseOp = ReadElement.UseOp;
00577 
00578                // Update the table
00579                derr( "   Read Hash key --> " << ReadHashKey << " <--\n" );
00580                derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
00581                Table[ ReadHashKey ] = WriteElement;
00582             }
00583             else {
00584 
00585                // mdj 4/19/98
00586                // Initialize use values
00587                WriteElement.UsingOpId = -1;
00588                WriteElement.UsingOp = 0;
00589                WriteElement.UseOp = NULL;
00590 
00591                CreateDagWriteHashKey( regid, reg_file_type );
00592                derr( "   Write Hash key --> " << WriteHashKey << " <--\n" );
00593                derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
00594                Table[ WriteHashKey ] = WriteElement;
00595             }
00596 
00597 #ifdef _DEBUG_TABLE_
00598             // Test code for lookups
00599             if ( ( (LookupIter=Table.find( ReadHashKey )) == Table.end()
00600                  && rc == 0 ) ||
00601                  ( (LookupIter=Table.find( WriteHashKey )) == Table.end()
00602                  && rc == 1) )
00603                { derr( "*** Bad key insertion!! ***\n" );}
00604             else {
00605                MainListIter = Table[ ReadHashKey ].DefiningOp;
00606                derr( "*** Key insertion successful for Op " );
00607                derr( "" << (*MainListIter).GetOp()->GetOpId() << "\n" );
00608             }
00609 #endif
00610             AntiDeps( Oprd, curOp );
00611          } // if
00612       } // for
00613    } // if
00614 
00615    if ( (*curOp).GetOp()->IsBRLOp()) {
00616     if(inp_start == 0 && inp_end == 0 && ret_start == 0 && ret_end == 0) //HZ:
00617     {   
00618      // Need to assume that BRLs define all INT_P*'s, FLT_P*'s, DBL_P*'s
00619      // and all *_RET's. 
00620      derr( "   BRL found, Opid " << (*curOp).GetOp()->GetOpId()
00621           << "\n" );
00622      
00623      // these should always be MACRO regs
00624      reg_file_type = -1;
00625      Oprd = new legoOprd(); 
00626      Oprd->SetOprdType(OT_MACRO);
00627      for (regid = INT_P1; regid <= DBL_RET; regid++) {
00628        Oprd->SetOprdRegNum(regid);
00629        
00630        rc = OutputDeps( Oprd, curOp );
00631        
00632        // Annotate that this register is defined here.
00633        derr( "...def-" << regid << "\n" );
00634        
00635        // Prepare for update to hash table
00636        WriteElement.RFType = reg_file_type;
00637        WriteElement.Regid = regid;
00638        WriteElement.DefiningOpId = (*curOp).GetOp()->GetOpId();
00639        WriteElement.DefiningOp = curOp;
00640        WriteElement.DefOp = (*curOp).GetOp();
00641        
00642        // Table update/insert
00643        if ( rc == 1 ) { // Not a new entry
00644 #if 0
00645          CreateReadHashKey( regid, reg_file_type );
00646 #else
00647          CreateDagHashKey( regid, reg_file_type, ReadHashReg, ReadHashKey );
00648 #endif
00649          
00650          // Find the entry in the table
00651          TableIter = Table.find( ReadHashKey );
00652          ReadElement = (*TableIter).second;
00653          
00654          // If curOp's predicate is not TRUE, must link with prev def 
00655          PredOprd = (*curOp).GetOp()->GetPredOprdPtr();
00656          if (PredOprd != NULL) {
00657            if (PredOprd->GetOprdType() != OT_LITERAL_P ||
00658                PredOprd->GetLiteralPredicate() != TRUE ) {
00659              // We need to chain the previous def to this def so that 
00660              // correct flow and output deps can be created. This is 
00661              // necessary for utilizing hammock conversion in treegions
00662              derr("Def predicated with non-TRUE predicate. Must link with prev def\n");
00663              
00664              if (ReadElement.DefiningOpId != -1) {
00665                
00666                MainList::iterator PrevDefiningOp = ReadElement.DefiningOp;
00667                
00668                dderr( "   Prev def found, linking w/op "
00669                     << (*PrevDefiningOp).GetOp()->GetOpId() << "\n" );
00670                (*curOp).AddPredecessor( ET_LINKDEST, (*PrevDefiningOp).GetOp(),
00671                                        &(*PrevDefiningOp) );
00672              }
00673            }
00674          }
00675          // Maintain the 'old' use values
00676          WriteElement.UsingOpId = ReadElement.UsingOpId;
00677          WriteElement.UsingOp = ReadElement.UsingOp;
00678          WriteElement.UseOp = ReadElement.UseOp;
00679          
00680          // Update the table
00681          derr( "   Read Hash key --> " << ReadHashKey << " <--\n" );
00682          derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
00683          Table[ ReadHashKey ] = WriteElement;
00684        }
00685        else {
00686          
00687          // mdj 4/19/98
00688          // Initialize use values
00689          WriteElement.UsingOpId = -1;
00690          WriteElement.UsingOp = 0;
00691          WriteElement.UseOp = NULL;
00692          
00693          CreateDagWriteHashKey( regid, reg_file_type );
00694          derr( "   Write Hash key --> " << WriteHashKey << " <--\n" );
00695          derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
00696          Table[ WriteHashKey ] = WriteElement;
00697        }
00698        
00699 #ifdef _DEBUG_TABLE_
00700        // Test code for lookups
00701        if ( ( (LookupIter=Table.find( ReadHashKey )) == Table.end()
00702              && rc == 0 ) ||
00703            ( (LookupIter=Table.find( WriteHashKey )) == Table.end()
00704             && rc == 1) )
00705          { derr( "*** Bad key insertion!! ***\n" );}
00706        else {
00707          MainListIter = Table[ ReadHashKey ].DefiningOp;
00708          derr( "*** Key insertion successful for Op " );
00709          derr( "" << (*MainListIter).GetOp()->GetOpId() << "\n" );
00710        }
00711 #endif
00712        AntiDeps( Oprd, curOp );
00713      } // for INT_P1 --> DBL_RET
00714      
00715      delete Oprd;
00716     }//end of if(inp_start == 0 ...
00717     else
00718     {
00719      derr( "   BRL found, Opid " << (*curOp).GetOp()->GetOpId()
00720           << "\n" );
00721      
00722      // these should always be MACRO regs
00723      Oprd = new legoOprd(); 
00724      Oprd->SetOprdType(OT_REG);
00725      Oprd->SetOprdRegType(RT_R);
00726      Oprd->SetOprdDataType(DT_I);
00727      Oprd->SetOprdFileType(FT_GPR);
00728      reg_file_type = FT_GPR;
00729      for (regid = inp_start; regid <= inp_end; regid++) {
00730        Oprd->SetOprdRegNum(regid);
00731        
00732        rc = OutputDeps( Oprd, curOp );
00733        
00734        // Annotate that this register is defined here.
00735        derr( "...def-" << regid << "\n" );
00736        
00737        // Prepare for update to hash table
00738        WriteElement.RFType = reg_file_type;
00739        WriteElement.Regid = regid;
00740        WriteElement.DefiningOpId = (*curOp).GetOp()->GetOpId();
00741        WriteElement.DefiningOp = curOp;
00742        WriteElement.DefOp = (*curOp).GetOp();
00743        
00744        // Table update/insert
00745        if ( rc == 1 ) { // Not a new entry
00746 #if 0
00747          CreateReadHashKey( regid, reg_file_type );
00748 #else
00749          CreateDagHashKey( regid, reg_file_type, ReadHashReg, ReadHashKey );
00750 #endif
00751          
00752          // Find the entry in the table
00753          TableIter = Table.find( ReadHashKey );
00754          ReadElement = (*TableIter).second;
00755          
00756          // If curOp's predicate is not TRUE, must link with prev def 
00757          PredOprd = (*curOp).GetOp()->GetPredOprdPtr();
00758          if (PredOprd != NULL) {
00759            if (PredOprd->GetOprdType() != OT_LITERAL_P ||
00760                PredOprd->GetLiteralPredicate() != TRUE ) {
00761              // We need to chain the previous def to this def so that 
00762              // correct flow and output deps can be created. This is 
00763              // necessary for utilizing hammock conversion in treegions
00764              derr("Def predicated with non-TRUE predicate. Must link with prev def\n");
00765              
00766              if (ReadElement.DefiningOpId != -1) {
00767                
00768                MainList::iterator PrevDefiningOp = ReadElement.DefiningOp;
00769                
00770                dderr( "   Prev def found, linking w/op "
00771                     << (*PrevDefiningOp).GetOp()->GetOpId() << "\n" );
00772                (*curOp).AddPredecessor( ET_LINKDEST, (*PrevDefiningOp).GetOp(),
00773                                        &(*PrevDefiningOp) );
00774              }
00775            }
00776          }
00777          // Maintain the 'old' use values
00778          WriteElement.UsingOpId = ReadElement.UsingOpId;
00779          WriteElement.UsingOp = ReadElement.UsingOp;
00780          WriteElement.UseOp = ReadElement.UseOp;
00781          
00782          // Update the table
00783          derr( "   Read Hash key --> " << ReadHashKey << " <--\n" );
00784          derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
00785          Table[ ReadHashKey ] = WriteElement;
00786        }
00787        else {
00788          
00789          // mdj 4/19/98
00790          // Initialize use values
00791          WriteElement.UsingOpId = -1;
00792          WriteElement.UsingOp = 0;
00793          WriteElement.UseOp = NULL;
00794          
00795          CreateDagWriteHashKey( regid, reg_file_type );
00796          derr( "   Write Hash key --> " << WriteHashKey << " <--\n" );
00797          derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
00798          Table[ WriteHashKey ] = WriteElement;
00799        }
00800        
00801 #ifdef _DEBUG_TABLE_
00802        // Test code for lookups
00803        if ( ( (LookupIter=Table.find( ReadHashKey )) == Table.end()
00804              && rc == 0 ) ||
00805            ( (LookupIter=Table.find( WriteHashKey )) == Table.end()
00806             && rc == 1) )
00807          { derr( "*** Bad key insertion!! ***\n" );}
00808        else {
00809          MainListIter = Table[ ReadHashKey ].DefiningOp;
00810          derr( "*** Key insertion successful for Op " );
00811          derr( "" << (*MainListIter).GetOp()->GetOpId() << "\n" );
00812        }
00813 #endif
00814        AntiDeps( Oprd, curOp );
00815      } // for inp_start --> inp_end
00816      
00817      Oprd->SetOprdDataType(DT_I);
00818      Oprd->SetOprdFileType(FT_GPR);
00819      reg_file_type = FT_GPR;
00820      for (regid = ret_start; regid <= ret_end; regid++) {
00821        Oprd->SetOprdRegNum(regid);
00822        
00823        rc = OutputDeps( Oprd, curOp );
00824        
00825        // Annotate that this register is defined here.
00826        derr( "...def-" << regid << "\n" );
00827        
00828        // Prepare for update to hash table
00829        WriteElement.RFType = reg_file_type;
00830        WriteElement.Regid = regid;
00831        WriteElement.DefiningOpId = (*curOp).GetOp()->GetOpId();
00832        WriteElement.DefiningOp = curOp;
00833        WriteElement.DefOp = (*curOp).GetOp();
00834        
00835        // Table update/insert
00836        if ( rc == 1 ) { // Not a new entry
00837 #if 0
00838          CreateReadHashKey( regid, reg_file_type );
00839 #else
00840          CreateDagHashKey( regid, reg_file_type, ReadHashReg, ReadHashKey );
00841 #endif
00842          
00843          // Find the entry in the table
00844          TableIter = Table.find( ReadHashKey );
00845          ReadElement = (*TableIter).second;
00846          
00847          // If curOp's predicate is not TRUE, must link with prev def 
00848          PredOprd = (*curOp).GetOp()->GetPredOprdPtr();
00849          if (PredOprd != NULL) {
00850            if (PredOprd->GetOprdType() != OT_LITERAL_P ||
00851                PredOprd->GetLiteralPredicate() != TRUE ) {
00852              // We need to chain the previous def to this def so that 
00853              // correct flow and output deps can be created. This is 
00854              // necessary for utilizing hammock conversion in treegions
00855              derr("Def predicated with non-TRUE predicate. Must link with prev def\n");
00856              
00857              if (ReadElement.DefiningOpId != -1) {
00858                
00859                MainList::iterator PrevDefiningOp = ReadElement.DefiningOp;
00860                
00861                dderr( "   Prev def found, linking w/op "
00862                     << (*PrevDefiningOp).GetOp()->GetOpId() << "\n" );
00863                (*curOp).AddPredecessor( ET_LINKDEST, (*PrevDefiningOp).GetOp(),
00864                                        &(*PrevDefiningOp) );
00865              }
00866            }
00867          }
00868          // Maintain the 'old' use values
00869          WriteElement.UsingOpId = ReadElement.UsingOpId;
00870          WriteElement.UsingOp = ReadElement.UsingOp;
00871          WriteElement.UseOp = ReadElement.UseOp;
00872          
00873          // Update the table
00874          derr( "   Read Hash key --> " << ReadHashKey << " <--\n" );
00875          derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
00876          Table[ ReadHashKey ] = WriteElement;
00877        }
00878        else {
00879          
00880          // mdj 4/19/98
00881          // Initialize use values
00882          WriteElement.UsingOpId = -1;
00883          WriteElement.UsingOp = 0;
00884          WriteElement.UseOp = NULL;
00885          
00886          CreateDagWriteHashKey( regid, reg_file_type );
00887          derr( "   Write Hash key --> " << WriteHashKey << " <--\n" );
00888          derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
00889          Table[ WriteHashKey ] = WriteElement;
00890        }
00891        
00892 #ifdef _DEBUG_TABLE_
00893        // Test code for lookups
00894        if ( ( (LookupIter=Table.find( ReadHashKey )) == Table.end()
00895              && rc == 0 ) ||
00896            ( (LookupIter=Table.find( WriteHashKey )) == Table.end()
00897             && rc == 1) )
00898          { derr( "*** Bad key insertion!! ***\n" );}
00899        else {
00900          MainListIter = Table[ ReadHashKey ].DefiningOp;
00901          derr( "*** Key insertion successful for Op " );
00902          derr( "" << (*MainListIter).GetOp()->GetOpId() << "\n" );
00903        }
00904 #endif
00905        AntiDeps( Oprd, curOp );
00906      } // for ret_start --> ret_end
00907      
00908      Oprd->SetOprdDataType(DT_D);
00909      Oprd->SetOprdFileType(FT_FPR);
00910      reg_file_type = FT_FPR;
00911      for (regid = fp_ret_start; regid <= fp_ret_end; regid++) {
00912        Oprd->SetOprdRegNum(regid);
00913        
00914        rc = OutputDeps( Oprd, curOp );
00915        
00916        // Annotate that this register is defined here.
00917        derr( "...def-" << regid << "\n" );
00918        
00919        // Prepare for update to hash table
00920        WriteElement.RFType = reg_file_type;
00921        WriteElement.Regid = regid;
00922        WriteElement.DefiningOpId = (*curOp).GetOp()->GetOpId();
00923        WriteElement.DefiningOp = curOp;
00924        WriteElement.DefOp = (*curOp).GetOp();
00925        
00926        // Table update/insert
00927        if ( rc == 1 ) { // Not a new entry
00928 #if 0
00929          CreateReadHashKey( regid, reg_file_type );
00930 #else
00931          CreateDagHashKey( regid, reg_file_type, ReadHashReg, ReadHashKey );
00932 #endif
00933          
00934          // Find the entry in the table
00935          TableIter = Table.find( ReadHashKey );
00936          ReadElement = (*TableIter).second;
00937          
00938          // If curOp's predicate is not TRUE, must link with prev def 
00939          PredOprd = (*curOp).GetOp()->GetPredOprdPtr();
00940          if (PredOprd != NULL) {
00941            if (PredOprd->GetOprdType() != OT_LITERAL_P ||
00942                PredOprd->GetLiteralPredicate() != TRUE ) {
00943              // We need to chain the previous def to this def so that 
00944              // correct flow and output deps can be created. This is 
00945              // necessary for utilizing hammock conversion in treegions
00946              derr("Def predicated with non-TRUE predicate. Must link with prev def\n");
00947              
00948              if (ReadElement.DefiningOpId != -1) {
00949                
00950                MainList::iterator PrevDefiningOp = ReadElement.DefiningOp;
00951                
00952                dderr( "   Prev def found, linking w/op "
00953                     << (*PrevDefiningOp).GetOp()->GetOpId() << "\n" );
00954                (*curOp).AddPredecessor( ET_LINKDEST, (*PrevDefiningOp).GetOp(),
00955                                        &(*PrevDefiningOp) );
00956              }
00957            }
00958          }
00959          // Maintain the 'old' use values
00960          WriteElement.UsingOpId = ReadElement.UsingOpId;
00961          WriteElement.UsingOp = ReadElement.UsingOp;
00962          WriteElement.UseOp = ReadElement.UseOp;
00963          
00964          // Update the table
00965          derr( "   Read Hash key --> " << ReadHashKey << " <--\n" );
00966          derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
00967          Table[ ReadHashKey ] = WriteElement;
00968        }
00969        else {
00970          
00971          // mdj 4/19/98
00972          // Initialize use values
00973          WriteElement.UsingOpId = -1;
00974          WriteElement.UsingOp = 0;
00975          WriteElement.UseOp = NULL;
00976          
00977          CreateDagWriteHashKey( regid, reg_file_type );
00978          derr( "   Write Hash key --> " << WriteHashKey << " <--\n" );
00979          derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
00980          Table[ WriteHashKey ] = WriteElement;
00981        }
00982        
00983 #ifdef _DEBUG_TABLE_
00984        // Test code for lookups
00985        if ( ( (LookupIter=Table.find( ReadHashKey )) == Table.end()
00986              && rc == 0 ) ||
00987            ( (LookupIter=Table.find( WriteHashKey )) == Table.end()
00988             && rc == 1) )
00989          { derr( "*** Bad key insertion!! ***\n" );}
00990        else {
00991          MainListIter = Table[ ReadHashKey ].DefiningOp;
00992          derr( "*** Key insertion successful for Op " );
00993          derr( "" << (*MainListIter).GetOp()->GetOpId() << "\n" );
00994        }
00995 #endif
00996        AntiDeps( Oprd, curOp );
00997      } // for fp_ret_start --> fp_ret_end
00998      
00999      delete Oprd;
01000         
01001     }//end of else of if(inp_start == 0 ...
01002    } // if Opcode == BRL
01003    
01004    if ( IsStoreOp( (*curOp).GetOp() ) ) {
01005       // Extra code to allow freedom in scheduling 'independent' store ops
01006       if ( FindLcAttribute( "mem_independent", (*curOp).GetOp()) != NULL ) {
01007        
01008         // This attribute does not now exist in source Rebel if it did, you
01009         // could take advantage of dis-ambiguation here
01010         
01011       } // special store Op
01012       else {
01013         // Insert the necessary edges
01014         for(vector <MainList::iterator>::const_iterator LookUpIter = StoreList.begin();
01015             LookUpIter != StoreList.end();
01016             LookUpIter++ ) {
01017           if (AreOpsDependent((*curOp).GetOp(), (*(*LookUpIter)).GetOp())) {
01018             rc = (*curOp).AddPredecessor( ET_MEM, (*(*LookUpIter)).GetOp(),
01019                                          &(*(*LookUpIter)) );
01020             rc = (*(*LookUpIter)).AddSuccessor( ET_MEM, (*curOp).GetOp(),
01021                                                &(*curOp) );
01022             dderr( ">> Inserted store barrier edge from "
01023                   << (*(*LookUpIter)).GetOp()->GetOpId() << " to "
01024                   << (*curOp).GetOp()->GetOpId() << " for this store op\n" );         
01025           }
01026         }
01027         for(vector <MainList::iterator>::const_iterator LookUpIter = LoadList.begin();
01028             LookUpIter != LoadList.end();
01029             LookUpIter++ ) {
01030           if (AreOpsDependent((*curOp).GetOp(), (*(*LookUpIter)).GetOp())) {
01031             rc = (*curOp).AddPredecessor( ET_MEM, (*(*LookUpIter)).GetOp(),
01032                                          &(*(*LookUpIter)) );
01033             rc = (*(*LookUpIter)).AddSuccessor( ET_MEM, (*curOp).GetOp(),
01034                                                &(*curOp) );
01035             dderr( ">> Inserted store barrier edge from "
01036                   << (*(*LookUpIter)).GetOp()->GetOpId() << " to "
01037                   << (*curOp).GetOp()->GetOpId() << " for this store op\n" );         
01038           }
01039         }
01040       } // normal store Op
01041     }
01042 
01043    // Need to make sure that Loads don't float above BRLs and the BRLs don't 
01044    // float above Loads/Stores, unless they are determined "mem_independent"
01045    if ( (*curOp).GetOp()->IsBRLOp() ) {
01046       if ( FindLcAttribute( "mem_independent", (*curOp).GetOp()) == NULL ) {
01047          // Insert the necessary edges
01048         for(vector <MainList::iterator>::const_iterator LookUpIter = StoreList.begin();
01049             LookUpIter != StoreList.end();
01050             LookUpIter++ ) {
01051           if (AreOpsDependent((*curOp).GetOp(), (*(*LookUpIter)).GetOp())) {
01052             rc = (*curOp).AddPredecessor( ET_MEM, (*(*LookUpIter)).GetOp(),
01053                                          &(*(*LookUpIter)) );
01054             rc = (*(*LookUpIter)).AddSuccessor( ET_MEM, (*curOp).GetOp(),
01055                                                &(*curOp) );
01056             dderr( ">> Inserted store barrier edge from "
01057                   << (*(*LookUpIter)).GetOp()->GetOpId() << " to "
01058                   << (*curOp).GetOp()->GetOpId() << " for this BRL op\n" );           
01059           }
01060         }
01061         for(vector <MainList::iterator>::const_iterator LookUpIter = LoadList.begin();
01062             LookUpIter != LoadList.end();
01063             LookUpIter++ ) {
01064           if (AreOpsDependent((*curOp).GetOp(), (*(*LookUpIter)).GetOp())) {
01065             rc = (*curOp).AddPredecessor( ET_MEM, (*(*LookUpIter)).GetOp(),
01066                                          &(*(*LookUpIter)) );
01067             rc = (*(*LookUpIter)).AddSuccessor( ET_MEM, (*curOp).GetOp(),
01068                                                &(*curOp) );
01069             dderr( ">> Inserted store barrier edge from "
01070                   << (*(*LookUpIter)).GetOp()->GetOpId() << " to "
01071                   << (*curOp).GetOp()->GetOpId() << " for this BRL op\n" );           
01072           }
01073         }
01074       } // normal BRL Op
01075     }
01076    derr( "<< OutputAntiDeps\n" );
01077 }
01078 
01079 /****************** END ******************/
01080 
01081 
01082 /* Determining flow dependencies. */
01083 
01084 /***************** BEGIN *****************/
01085 
01086 // AnalyzeFlowDep: checks flow deps for the given operand list
01087 void dag::AnalyzeFlowDep( legoOprd *Oprd,
01088                           MainList::iterator curOp )
01089 {
01090   legoOprd *tableOprd;
01091   int reg_file_type,
01092   regid,
01093   OprdType,
01094   NumRegOprds = 0,
01095   rc = 0;
01096   MainList::iterator opPtr;
01097   int true_predicate;
01098   
01099   
01100   if ( Oprd == NULL ) return;
01101   derr( "      >> AnalyzeFlowDep\n");
01102   
01103   while ( Oprd != NULL ) {
01104     rc = 0;
01105     if ( (OprdType=Oprd->GetOprdType()) == OT_REG || OprdType == OT_MACRO ) {
01106       
01107       NumRegOprds++;
01108       regid = Oprd->GetOprdRegNum();
01109       
01110       derr( "          Reg " << regid );
01111       
01112       // Below is the table lookup.  Look for 'regid' in the hash table.
01113       // GetOprdFileType() returns the same integer value for both
01114       // integer and macro operands. The lines below are to differentiate
01115       // between the 2 types.
01116       if ( OprdType == OT_MACRO ) reg_file_type = -1;
01117       else reg_file_type = Oprd->GetOprdFileType();
01118 #if 0
01119       CreateReadHashKey( regid, reg_file_type );
01120 #else
01121       CreateDagHashKey( regid, reg_file_type, ReadHashReg, ReadHashKey );
01122 #endif
01123       
01124       derr( "   Initial Hash key --> " << ReadHashKey << " <--\n" );
01125       
01126       LookupIter = Table.find( ReadHashKey );
01127       ReadElement = (*LookupIter).second;
01128       
01129       if ( ReadElement.DefiningOpId != -1 && LookupIter != Table.end() ) {
01130         MainListIter = ReadElement.DefiningOp;
01131         derr( "*** Def Op-id "
01132              << (*MainListIter).GetOp()->GetOpId() << "\n" );
01133       }
01134       
01135       // If the table lookup was unsuccessful OR a defining Op doesn't
01136       // exist, a dependency doesn't exist.
01137       if ( LookupIter == Table.end() || ReadElement.DefiningOpId == -1 )
01138         {derr( "...no dep exists" );}
01139       
01140       // If the table lookup was successful AND a defining OP exists,
01141       // a dependency *definitely* exists.
01142       else if ( LookupIter != Table.end()
01143                && ReadElement.DefiningOpId != -1 ) {
01144         
01145         true_predicate = TRUE; 
01146         legoOprd *PredOprd = (*ReadElement.DefiningOp).GetOp()->GetPredOprdPtr();
01147         if (PredOprd != NULL) 
01148           if (PredOprd->GetOprdType() != OT_LITERAL_P ||
01149               PredOprd->GetLiteralPredicate() != TRUE ) 
01150             true_predicate = FALSE; 
01151         
01152         // Loop through all of the Ops preceding the one with which the
01153         // flow-dep exists. For all ET_LINKDEST edges, if the edge was placed
01154         // because of this specific dest operand, add an flow-dep edge.
01155         for ( opPtr = ReadElement.DefiningOp; opPtr != NULL; ) {
01156           
01157           vector < SmallListElement >::iterator Front, Back;
01158           int match = 0;
01159           attrs *a;
01160           legoOprd *attrOprd;
01161           int ortho_reg_numb1, ortho_reg_numb2;
01162           
01163           if (AreOpsDependent((*curOp).GetOp(), (*opPtr).GetOp())) {
01164             
01165             // Print out the defining Op's Opid
01166             dderr( "** Flow-dep w/Op " << (*opPtr).GetOp()->GetOpId() << "\n" );
01167             
01168             // Add an edge from curOp to opPtr to indicate that curOp is
01169             // is dependent on opPtr
01170             rc = (*curOp).AddPredecessor( ET_REGFLOW, (*opPtr).GetOp(), &(*opPtr) );
01171             dderr( "** Op " << (*curOp).GetOp()->GetOpId() << ", # preds "
01172                  << rc << "\n" );
01173             
01174             // Add an edge from opPtr to curOp to indicate that opPtr
01175             // 'enables' curOp.
01176             rc = (*opPtr).AddSuccessor( ET_REGFLOW, (*curOp).GetOp(), &(*curOp) );
01177             dderr( "** Op " << (*opPtr).GetOp()->GetOpId() << ", # succs "
01178                  << rc << "\n" );
01179             
01180             InternalNodes += 2;
01181           }
01182           else {
01183             dderr( "** Flow-dep w/Op " << (*opPtr).GetOp()->GetOpId()
01184                  << " skipped because PredVectors show independence\n" );
01185           }
01186           
01187           dderr( "   Searching " << (*opPtr).GetOp()->GetOpId()
01188                << "'s predecessors\n" );
01189           
01190           // Search through all of this Op's predecessors. For any that
01191           // have an ET_LINKDEST edge with the same value as the current
01192           // operand hash key, set it to opPtr.
01193           for ( match = 0, Front = (*opPtr).Predecessors->begin(),
01194                Back = (*opPtr).Predecessors->end();
01195                Front != Back && match == 0; Front++ ) {
01196             derr( "   Examine Op " << (*Front).GetOp()->GetOpId() << "\n" );
01197             if ( (*Front).GetDependencyType() == ET_LINKDEST ) {
01198               
01199               legoOprd *Oprd;
01200               
01201               opPtr = (*Front).GetDagEntry();
01202               Oprd = (*opPtr).GetOp()->GetDestOprdPtr();
01203               while ( Oprd != NULL ) {
01204                 
01205                 int OprdType = Oprd->GetOprdType();
01206                 
01207                 if ( OprdType == OT_REG || OprdType == OT_MACRO ) {
01208                   
01209                   char *Key = new char[ Hash_Key_Size ];
01210                   
01211                   regid = Oprd->GetOprdRegNum();
01212                   derr( "   Reg " << regid );
01213                   if ( Oprd->GetOprdType() == OT_MACRO ) reg_file_type = -1;
01214                   else reg_file_type = Oprd->GetOprdFileType();
01215                   CreateDagHashKey( regid, reg_file_type, ReadHashReg, Key );
01216                   derr( "   Hash key --> " << Key << " <--\n" );
01217                   if ( strcmp( Key, ReadHashKey ) == 0 ) {
01218                     derr( "   Found: >" << Key << "<\n" );
01219                     match = 1;
01220                   } // if - match, add an flow-dep edge
01221                   delete [] Key;
01222                 } // if - examine only macro and register operands
01223                 Oprd = Oprd->GetNextOprdPtr();
01224               } // while - check all of the pred's dest operands
01225 
01226 
01227               if (((*opPtr).GetOp()->IsBRLOp()) && 
01228                   (match == 0)) {
01229                if(inp_start == 0 && inp_end == 0 && ret_start == 0 && ret_end == 0) //HZ:
01230                {                  
01231                 // Need to assume that BRLs define all INT_P*'s, FLT_P*'s, 
01232                 // DBL_P*'s, and *_RET's. 
01233                 reg_file_type = -1;
01234                 for (regid = INT_P1; regid <= DBL_RET; regid++) {
01235                   derr( "   Reg " << regid );
01236                   char *Key = new char[ Hash_Key_Size ];
01237                   CreateDagHashKey( regid, reg_file_type, ReadHashReg, Key );
01238                   derr( "   Hash key --> " << Key << " <--\n" );
01239                   if ( strcmp( Key, ReadHashKey ) == 0 ) {
01240                     derr( "   Found: >" << Key << "<\n" );
01241                     match = 1;
01242                   } // if - match, add an output-dep edge
01243                   delete [] Key;
01244                 }
01245                }//end of if(inp_start == 0 ...
01246                else
01247                {
01248                 reg_file_type = FT_GPR;
01249                 for (regid = inp_start; regid <= inp_end; regid++) {
01250                   derr( "   Reg " << regid );
01251                   char *Key = new char[ Hash_Key_Size ];
01252                   CreateDagHashKey( regid, reg_file_type, ReadHashReg, Key );
01253                   derr( "   Hash key --> " << Key << " <--\n" );
01254                   if ( strcmp( Key, ReadHashKey ) == 0 ) {
01255                     derr( "   Found: >" << Key << "<\n" );
01256                     match = 1;
01257                   } // if - match, add an output-dep edge
01258                   delete [] Key;
01259                 }//end of for(regid = inp_start ...
01260                 reg_file_type = FT_GPR;
01261                 for (regid = ret_start; regid <= ret_end; regid++) {
01262                   derr( "   Reg " << regid );
01263                   char *Key = new char[ Hash_Key_Size ];
01264                   CreateDagHashKey( regid, reg_file_type, ReadHashReg, Key );
01265                   derr( "   Hash key --> " << Key << " <--\n" );
01266                   if ( strcmp( Key, ReadHashKey ) == 0 ) {
01267                     derr( "   Found: >" << Key << "<\n" );
01268                     match = 1;
01269                   } // if - match, add an output-dep edge
01270                   delete [] Key;
01271                 }//end of for(regid = ret_start ...
01272                 reg_file_type = FT_FPR;
01273                 for (regid = fp_ret_start; regid <= fp_ret_end; regid++) {
01274                   derr( "   Reg " << regid );
01275                   char *Key = new char[ Hash_Key_Size ];
01276                   CreateDagHashKey( regid, reg_file_type, ReadHashReg, Key );
01277                   derr( "   Hash key --> " << Key << " <--\n" );
01278                   if ( strcmp( Key, ReadHashKey ) == 0 ) {
01279                     derr( "   Found: >" << Key << "<\n" );
01280                     match = 1;
01281                   } // if - match, add an output-dep edge
01282                   delete [] Key;
01283                 }//end of for(regid = ret_start ...
01284                 
01285                }//end of else of if(inp_start == 0 ...
01286               }
01287             } // if = examine any ET_LINKDEST adge
01288           } // for - examine all of opPtr's predecessors
01289           if ( match == 0 ) opPtr = NULL;
01290         }
01291       }
01292       
01293       // Annotate that this register is used
01294       derr( "...use-" << regid << "\n" );
01295       // If some prior Op uses this same reg value, might have to connect
01296       // curOp to a chain of using Ops. This helps w/anti-deps when
01297       // scheduling.
01298       if ( LookupIter != Table.end() && ReadElement.UsingOpId != -1 ) {
01299         
01300         vector < SmallListElement >::iterator Front, Back;
01301         MainList::iterator PrevUsingOp = ReadElement.UsingOp;
01302         int Found = 0;
01303         
01304         derr( "   Looking for prior `related` uses\n" );
01305         if ( (rc == 0) || (true_predicate == FALSE) ) {
01306           dderr( "   Prev use found, linking w/op "
01307                << (*PrevUsingOp).GetOp()->GetOpId() << "\n" );
01308           (*curOp).AddPredecessor( ET_LINKSRC, (*PrevUsingOp).GetOp(),
01309                                   &(*PrevUsingOp) );
01310         }
01311         else
01312           for ( Front = (*PrevUsingOp).Predecessors->begin(),
01313                Back = (*PrevUsingOp).Predecessors->end();
01314                Front != Back && Found == 0; Front++ ) {
01315             dderr( "   Examining op " << (*Front).GetOp()->GetOpId()
01316                  << "\n" );
01317             if ( (*Front).GetDependencyType() == ET_REGFLOW &&
01318                 (*Front).GetOp()->GetOpId()==ReadElement.DefiningOpId ) {
01319               dderr( "   Prev use found\n" );
01320               Found = 1;        // Flow-dep w/the same pred Op exists
01321               
01322               // Add an edge from curOp to Front to indicate that Front
01323               // uses the same src reg *and* is dependent on the same Op
01324               (*curOp).AddPredecessor( ET_LINKSRC,
01325                                       (*PrevUsingOp).GetOp(),
01326                                       &(*PrevUsingOp) );
01327             } // if - flow-dep exists
01328           } // for - all predecessors
01329         dderr( "   Done looking for `related` uses\n" );
01330         derr( "   Print out just-added entries\n" );
01331       } // if - flow-dep exists && prev use of reg exists
01332     }
01333     Oprd = Oprd->GetNextOprdPtr();
01334   } // while
01335   
01336   /*
01337    * Here's an anecdote for ya: [3/19/98]
01338    *
01339    * The following code dumps a message if there are no register operands,
01340    * and it uses the derr macro #defined in dag.C. If you uncomment the
01341    * code when derr is NOT defined (i.e., no debug messages are generated),
01342    * it will crash. As far as I (Bill) can tell, if the area between
01343    * the braces is empty (for whatever reason, even if the derr is
01344    * completely commented out), it crashes; otherwise, it's fine.
01345    * Just looking at it, everything is legal in C and C++ syntax.
01346    *
01347    * So, here's the $64,000 question: Why does it crash? A hint is that
01348    * when viewing the assembly, the particular conditional branch used
01349    * jumps to the fall-through (next) instruction, which is probably a
01350    * no-no.
01351    *
01352    * If you ever figure it out, please: hunt me down and tell me about it.
01353    * Tell Matt too, because he wants to know. Thank you.
01354    *
01355    * Epilouge [3/20/98]: Instead of commenting it out, I have protected it
01356    * with an #ifdef. That will it'll work when derr is defined.
01357    */  
01358 #ifdef _DAG_DEBUG_
01359   if ( NumRegOprds == 0 ) {derr( "          0 register operands" );}
01360 #endif
01361   
01362   derr("\n");
01363 }
01364 
01365 
01366 // FlowDeps: detect and create edges for FLOW dependencies for the curOp
01367 void dag::FlowDeps( MainList::iterator curOp, BigListElement *Element )
01368 {
01369   int rc;
01370   attrs *a;  
01371   
01372   derr( ">> FlowDeps: Op " << (*curOp).GetOp()->GetOpId() << "\n" );
01373   
01374   // Update the memory register for store ops
01375   if ( IsLoadOp( (*curOp).GetOp() ) ) {
01376     // Extra code to allow freedom in scheduling 'independent' load ops.
01377     // If we know that the load is NOT truly 'independent' (no mem-dep),
01378     // then enforce a mem-dep.
01379     if ( FindLcAttribute( "mem_independent", (*curOp).GetOp()) == NULL ) {
01380       
01381       // Insert the necessary edges
01382       for(vector <MainList::iterator>::const_iterator LookUpIter = StoreList.begin();
01383           LookUpIter != StoreList.end();
01384           LookUpIter++ ) {
01385         if ((IsStoreOp( (*(*LookUpIter)).GetOp() ) || 
01386              ((*(*LookUpIter)).GetOp()->IsBRLOp())) && 
01387             (AreOpsDependent((*curOp).GetOp(), (*(*LookUpIter)).GetOp()))) {
01388           rc = (*curOp).AddPredecessor( ET_MEM, (*(*LookUpIter)).GetOp(),
01389                                        &(*(*LookUpIter)) );
01390           rc = (*(*LookUpIter)).AddSuccessor( ET_MEM, (*curOp).GetOp(),
01391                                              &(*curOp) );
01392           dderr( ">> Inserted mem-dep edge between "
01393                 << (*(*LookUpIter)).GetOp()->GetOpId() << " and "
01394                 << (*curOp).GetOp()->GetOpId() << "\n" );             
01395         }
01396       }
01397     }
01398   }
01399   derr( "   >> Check src operands\n" );
01400   AnalyzeFlowDep( (*curOp).GetOp()->GetSrcOprdPtr(), curOp );
01401   derr( "   >> Check predicate operands\n" );
01402   AnalyzeFlowDep( (*curOp).GetOp()->GetPredOprdPtr(), curOp );
01403   
01404   // Need to assume that BRLs use all INT_P*'s, FLT_P*'s, DBL_P*'s. 
01405   if ( (*curOp).GetOp()->IsBRLOp() ) {
01406    if(inp_start == 0 && inp_end == 0 && ret_start == 0 && ret_end == 0)
01407    {   
01408     legoOprd *Oprd = new legoOprd(); 
01409     // these are always MACRO regs
01410     Oprd->SetOprdType(OT_MACRO);
01411     derr( "   >> Check MACRO sources used for BRL parameter passing \n" );
01412     for (int regid = INT_P1; regid <= DBL_P2; regid++) {
01413       Oprd->SetOprdRegNum(regid);
01414       AnalyzeFlowDep( Oprd, curOp );  
01415     }
01416     delete Oprd; 
01417    } //HZ: rebel specification of function call parameters & returns
01418    else
01419    {
01420        int regid;
01421        legoOprd * Oprd = new legoOprd;
01422        Oprd->SetOprdType(OT_REG);
01423        Oprd->SetOprdRegType(RT_R);
01424        Oprd->SetOprdDataType(DT_I);
01425        Oprd->SetOprdFileType(FT_GPR);
01426        //HZ; integer function call parameters
01427        for(regid = inp_start; regid <= inp_end; regid++)
01428        {
01429            Oprd->SetOprdRegNum(regid);
01430            AnalyzeFlowDep( Oprd, curOp );
01431        }
01432        Oprd->SetOprdDataType(DT_D);
01433        Oprd->SetOprdFileType(FT_FPR);
01434        //HZ: floating point function call parameters & returns (not
01435        //distinguished)
01436        for(regid = fp_ret_start; regid <= fp_ret_end; regid++)
01437        {
01438            Oprd->SetOprdRegNum(regid);
01439            AnalyzeFlowDep( Oprd, curOp );          
01440        }
01441        delete Oprd;
01442    }
01443   }
01444   derr( "<< FlowDeps\n" );
01445 }
01446 
01447 
01448 // UpdateUseStatus: updates the def-use table w/use status info
01449 void dag::UpdateUseStatus( MainList::iterator curOp, BigListElement *Element )
01450 {
01451   attrs *a;
01452   legoOprd *Oprd;
01453   int reg_file_type,
01454   regid,
01455   OprdType;
01456   MainList::iterator opPtr;
01457   
01458   
01459   derr( "      >> UpdateUseStatus\n");
01460   
01461   // First, update use info for the source operands
01462   Oprd = (*curOp).GetOp()->GetSrcOprdPtr();
01463   while ( Oprd != NULL ) {
01464     if ( (OprdType=Oprd->GetOprdType()) == OT_REG || OprdType == OT_MACRO ) {
01465       
01466       regid = Oprd->GetOprdRegNum();
01467       
01468       derr( "          Reg " << regid );
01469       
01470       // Below is the table lookup.  Look for 'regid' in the hash table.
01471       // GetOprdFileType() returns the same integer value for both
01472       // integer and macro operands. The lines below are to differentiate
01473       // between the 2 types.
01474       if ( OprdType == OT_MACRO ) reg_file_type = -1;
01475       else reg_file_type = Oprd->GetOprdFileType();
01476 #if 0
01477       CreateReadHashKey( regid, reg_file_type );
01478 #else
01479       CreateDagHashKey( regid, reg_file_type, ReadHashReg, ReadHashKey );
01480 #endif
01481       
01482       derr( "   Initial Hash key --> " << ReadHashKey << " <--\n" );
01483       
01484       LookupIter = Table.find( ReadHashKey );
01485       ReadElement = (*LookupIter).second;
01486       
01487       // Prepare for update to hash table
01488       WriteElement.RFType = reg_file_type;
01489       WriteElement.Regid = regid;
01490       WriteElement.UsingOpId = (*curOp).GetOp()->GetOpId();
01491       WriteElement.UsingOp = curOp;
01492       WriteElement.UseOp = (*curOp).GetOp();
01493       
01494       if ( LookupIter == Table.end() ) {        // New entry
01495         
01496         // mdj 4/19/98
01497         // Initialize def values
01498         WriteElement.DefiningOpId = -1;
01499         WriteElement.DefiningOp = 0;
01500         WriteElement.DefOp = NULL;
01501         
01502         // Create *write* hash key & insert info
01503         CreateDagWriteHashKey( regid, reg_file_type );
01504         derr( "   *Write* hash key --> " << WriteHashKey << " <--\n" );
01505         derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
01506         Table[ WriteHashKey ]  = WriteElement;
01507       }
01508       else {    // Update existing entry
01509         
01510         // Maintain the 'old' def values
01511         WriteElement.DefiningOpId = ReadElement.DefiningOpId;
01512         WriteElement.DefiningOp = ReadElement.DefiningOp;
01513         WriteElement.DefOp = ReadElement.DefOp;
01514         derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
01515         Table[ ReadHashKey ] = WriteElement;
01516       }
01517     }
01518     Oprd = Oprd->GetNextOprdPtr();
01519   } // while
01520   
01521   
01522   // mdj - 11/4/98: Also update use info for the Predicate operands
01523   Oprd = (*curOp).GetOp()->GetPredOprdPtr();
01524   while ( Oprd != NULL ) {
01525     if ( (OprdType=Oprd->GetOprdType()) == OT_REG || OprdType == OT_MACRO ) {
01526       
01527       regid = Oprd->GetOprdRegNum();
01528       
01529       derr( "          Reg " << regid );
01530       
01531       // Below is the table lookup.  Look for 'regid' in the hash table.
01532       // GetOprdFileType() returns the same integer value for both
01533       // integer and macro operands. The lines below are to differentiate
01534       // between the 2 types.
01535       if ( OprdType == OT_MACRO ) reg_file_type = -1;
01536       else reg_file_type = Oprd->GetOprdFileType();
01537 #if 0
01538       CreateReadHashKey( regid, reg_file_type );
01539 #else
01540       CreateDagHashKey( regid, reg_file_type, ReadHashReg, ReadHashKey );
01541 #endif
01542       
01543       derr( "   Initial Hash key --> " << ReadHashKey << " <--\n" );
01544       
01545       LookupIter = Table.find( ReadHashKey );
01546       ReadElement = (*LookupIter).second;
01547       
01548       // Prepare for update to hash table
01549       WriteElement.RFType = reg_file_type;
01550       WriteElement.Regid = regid;
01551       WriteElement.UsingOpId = (*curOp).GetOp()->GetOpId();
01552       WriteElement.UsingOp = curOp;
01553       WriteElement.UseOp = (*curOp).GetOp();
01554       
01555       if ( LookupIter == Table.end() ) {        // New entry
01556         
01557         // mdj 4/19/98
01558         // Initialize def values
01559         WriteElement.DefiningOpId = -1;
01560         WriteElement.DefiningOp = 0;
01561         WriteElement.DefOp = NULL;
01562         
01563         // Create *write* hash key & insert info
01564         CreateDagWriteHashKey( regid, reg_file_type );
01565         derr( "   *Write* hash key --> " << WriteHashKey << " <--\n" );
01566         derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
01567         Table[ WriteHashKey ]  = WriteElement;
01568       }
01569       else {    // Update existing entry
01570         
01571         // Maintain the 'old' def values
01572         WriteElement.DefiningOpId = ReadElement.DefiningOpId;
01573         WriteElement.DefiningOp = ReadElement.DefiningOp;
01574         WriteElement.DefOp = ReadElement.DefOp;
01575         derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
01576         Table[ ReadHashKey ] = WriteElement;
01577       }
01578     }
01579     Oprd = Oprd->GetNextOprdPtr();
01580   } // while
01581   
01582   // mdj - 11/4/98: Now we need to deal with BRL parameters
01583   if ( (*curOp).GetOp()->IsBRLOp() ) {
01584    if(inp_start == 0 && inp_end == 0 && ret_start == 0 && ret_end == 0) //HZ:
01585    {   
01586     for (regid = INT_P1; regid <= DBL_P2; regid++) {
01587       // these should always be MACRO regs
01588       reg_file_type = -1;
01589 #if 0
01590       CreateReadHashKey( regid, reg_file_type );
01591 #else
01592       CreateDagHashKey( regid, reg_file_type, ReadHashReg, ReadHashKey );
01593 #endif
01594       
01595       derr( "   Initial Hash key --> " << ReadHashKey << " <--\n" );
01596       
01597       LookupIter = Table.find( ReadHashKey );
01598       ReadElement = (*LookupIter).second;
01599       
01600       // Prepare for update to hash table
01601       WriteElement.RFType = reg_file_type;
01602       WriteElement.Regid = regid;
01603       WriteElement.UsingOpId = (*curOp).GetOp()->GetOpId();
01604       WriteElement.UsingOp = curOp;
01605       WriteElement.UseOp = (*curOp).GetOp();
01606       
01607       if ( LookupIter == Table.end() ) {        // New entry
01608         
01609         // mdj 4/19/98
01610         // Initialize def values
01611         WriteElement.DefiningOpId = -1;
01612         WriteElement.DefiningOp = 0;
01613         WriteElement.DefOp = NULL;
01614         
01615         // Create *write* hash key & insert info
01616         CreateDagWriteHashKey( regid, reg_file_type );
01617         derr( "   *Write* hash key --> " << WriteHashKey << " <--\n" );
01618         derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
01619         Table[ WriteHashKey ]  = WriteElement;
01620       }
01621       else {    // Update existing entry
01622         
01623         // Maintain the 'old' def values
01624         WriteElement.DefiningOpId = ReadElement.DefiningOpId;
01625         WriteElement.DefiningOp = ReadElement.DefiningOp;
01626         WriteElement.DefOp = ReadElement.DefOp;
01627         derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
01628         Table[ ReadHashKey ] = WriteElement;
01629       }
01630     } //end of for(regid = INT_P1; regid <= DBL_RET; ...
01631    }//end of if(inp_start == 0 ...     
01632    else
01633    {
01634     for (regid = inp_start; regid <= inp_end; regid++) {
01635       
01636       reg_file_type = FT_GPR;
01637 #if 0
01638       CreateReadHashKey( regid, reg_file_type );
01639 #else
01640       CreateDagHashKey( regid, reg_file_type, ReadHashReg, ReadHashKey );
01641 #endif
01642       
01643       derr( "   Initial Hash key --> " << ReadHashKey << " <--\n" );
01644       
01645       LookupIter = Table.find( ReadHashKey );
01646       ReadElement = (*LookupIter).second;
01647       
01648       // Prepare for update to hash table
01649       WriteElement.RFType = reg_file_type;
01650       WriteElement.Regid = regid;
01651       WriteElement.UsingOpId = (*curOp).GetOp()->GetOpId();
01652       WriteElement.UsingOp = curOp;
01653       WriteElement.UseOp = (*curOp).GetOp();
01654       
01655       if ( LookupIter == Table.end() ) {        // New entry
01656         
01657         // mdj 4/19/98
01658         // Initialize def values
01659         WriteElement.DefiningOpId = -1;
01660         WriteElement.DefiningOp = 0;
01661         WriteElement.DefOp = NULL;
01662         
01663         // Create *write* hash key & insert info
01664         CreateDagWriteHashKey( regid, reg_file_type );
01665         derr( "   *Write* hash key --> " << WriteHashKey << " <--\n" );
01666         derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
01667         Table[ WriteHashKey ]  = WriteElement;
01668       }
01669       else {    // Update existing entry
01670         
01671         // Maintain the 'old' def values
01672         WriteElement.DefiningOpId = ReadElement.DefiningOpId;
01673         WriteElement.DefiningOp = ReadElement.DefiningOp;
01674         WriteElement.DefOp = ReadElement.DefOp;
01675         derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
01676         Table[ ReadHashKey ] = WriteElement;
01677       }
01678     }//end of for(reg = inp_start; ...
01679     
01680     for (regid = ret_start; regid <= ret_end; regid++) {
01681       
01682       reg_file_type = FT_GPR;
01683 #if 0
01684       CreateReadHashKey( regid, reg_file_type );
01685 #else
01686       CreateDagHashKey( regid, reg_file_type, ReadHashReg, ReadHashKey );
01687 #endif
01688       
01689       derr( "   Initial Hash key --> " << ReadHashKey << " <--\n" );
01690       
01691       LookupIter = Table.find( ReadHashKey );
01692       ReadElement = (*LookupIter).second;
01693       
01694       // Prepare for update to hash table
01695       WriteElement.RFType = reg_file_type;
01696       WriteElement.Regid = regid;
01697       WriteElement.UsingOpId = (*curOp).GetOp()->GetOpId();
01698       WriteElement.UsingOp = curOp;
01699       WriteElement.UseOp = (*curOp).GetOp();
01700       
01701       if ( LookupIter == Table.end() ) {        // New entry
01702         
01703         // mdj 4/19/98
01704         // Initialize def values
01705         WriteElement.DefiningOpId = -1;
01706         WriteElement.DefiningOp = 0;
01707         WriteElement.DefOp = NULL;
01708         
01709         // Create *write* hash key & insert info
01710         CreateDagWriteHashKey( regid, reg_file_type );
01711         derr( "   *Write* hash key --> " << WriteHashKey << " <--\n" );
01712         derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
01713         Table[ WriteHashKey ]  = WriteElement;
01714       }
01715       else {    // Update existing entry
01716         
01717         // Maintain the 'old' def values
01718         WriteElement.DefiningOpId = ReadElement.DefiningOpId;
01719         WriteElement.DefiningOp = ReadElement.DefiningOp;
01720         WriteElement.DefOp = ReadElement.DefOp;
01721         derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
01722         Table[ ReadHashKey ] = WriteElement;
01723       }
01724     }//end of for(reg = ret_start; ...
01725     
01726     for (regid = fp_ret_start; regid <= fp_ret_end; regid++) {
01727       
01728       reg_file_type = FT_FPR;
01729 #if 0
01730       CreateReadHashKey( regid, reg_file_type );
01731 #else
01732       CreateDagHashKey( regid, reg_file_type, ReadHashReg, ReadHashKey );
01733 #endif
01734       
01735       derr( "   Initial Hash key --> " << ReadHashKey << " <--\n" );
01736       
01737       LookupIter = Table.find( ReadHashKey );
01738       ReadElement = (*LookupIter).second;
01739       
01740       // Prepare for update to hash table
01741       WriteElement.RFType = reg_file_type;
01742       WriteElement.Regid = regid;
01743       WriteElement.UsingOpId = (*curOp).GetOp()->GetOpId();
01744       WriteElement.UsingOp = curOp;
01745       WriteElement.UseOp = (*curOp).GetOp();
01746       
01747       if ( LookupIter == Table.end() ) {        // New entry
01748         
01749         // mdj 4/19/98
01750         // Initialize def values
01751         WriteElement.DefiningOpId = -1;
01752         WriteElement.DefiningOp = 0;
01753         WriteElement.DefOp = NULL;
01754         
01755         // Create *write* hash key & insert info
01756         CreateDagWriteHashKey( regid, reg_file_type );
01757         derr( "   *Write* hash key --> " << WriteHashKey << " <--\n" );
01758         derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
01759         Table[ WriteHashKey ]  = WriteElement;
01760       }
01761       else {    // Update existing entry
01762         
01763         // Maintain the 'old' def values
01764         WriteElement.DefiningOpId = ReadElement.DefiningOpId;
01765         WriteElement.DefiningOp = ReadElement.DefiningOp;
01766         WriteElement.DefOp = ReadElement.DefOp;
01767         derr( "DagHashTable being updated with:\n" << "DefiningOpId = " << WriteElement.DefiningOpId << "\n" << "DefOp = " << WriteElement.DefOp << "\n" << "UsingOpId = " << WriteElement.UsingOpId << "\n" << "UseOp = " << WriteElement.UseOp << "\n" );
01768         Table[ ReadHashKey ] = WriteElement;
01769       }
01770     }//end of for(reg = fp_ret_start; ...
01771     
01772    }//end of else of if(inp_start == 0...
01773   }
01774   
01775   derr( "      << UpdateUseStatus\n");
01776 }
01777 
01778 
01779 void dag::RemoveUndefPredecessors ( void )
01780 {
01781   MainList::iterator Front, Back;
01782   BigListElement *CurNode;
01783   vector < SmallListElement >::iterator pFront, pBack;
01784   int something_eliminated;
01785 
01786   derr( "      << RemoveUndefPredecessors\n" );
01787   for ( Front = MasterList.begin(), Back = MasterList.end();
01788         Front != Back; Front++ )
01789     {
01790       CurNode = &(*Front);
01791       derr( "         Node " << CurNode->GetOp()->GetOpId() );
01792       something_eliminated = 1;
01793       while (something_eliminated)
01794         {
01795           something_eliminated = 0;
01796 
01797           // Reset iterators before each sweep (because Predecessors
01798           // is an STL vector - see BigListElement::RemovePredecessor).
01799           for ( pFront = CurNode->Predecessors->begin(),
01800                   pBack = CurNode->Predecessors->end();
01801                 pFront != pBack; pFront++ ) {
01802             if ( pFront->GetDependencyType() == ET_LINKSRC )
01803               {
01804                 derr( " " << pFront->GetOp()->GetOpId() );
01805                 CurNode->RemovePredecessor ( ET_LINKSRC, pFront->GetOp(),
01806                                              pFront->GetDagEntry() );
01807                 SetVectorPtrs (CurNode->Predecessors);
01808                 something_eliminated = 1;
01809                 break;
01810               } // end if 
01811             if ( pFront->GetDependencyType() == ET_LINKDEST )
01812               {
01813                 derr( " " << pFront->GetOp()->GetOpId() );
01814                 CurNode->RemovePredecessor ( ET_LINKDEST, pFront->GetOp(),
01815                                              pFront->GetDagEntry() );
01816                 SetVectorPtrs (CurNode->Predecessors);
01817                 something_eliminated = 1;
01818                 break;
01819               } // end if 
01820           } // end for
01821             //    if (pFront == pBack) something_eliminated = 0;  // done with this one
01822         } // end while
01823 
01824       derr ("\n");
01825     } // end for (, for)
01826   return;
01827 }
01828 /****************** END ******************/
Generated on Mon Jul 21 20:24:07 2003 for TINKER LEGO DOC by doxygen 1.3.2