Open64: osprey/be/cg/sched/sched

00001 /* -*-Mode: c++;-*- (Tell emacs to use c++ mode) */
00002 
00003 /*
00004  *  Copyright (C) 2000-2003, Intel Corporation
00005  *  All rights reserved.
00006  *  
00007  *  Redistribution and use in source and binary forms, with or without modification,
00008  *  are permitted provided that the following conditions are met:
00009  *  
00010  *  Redistributions of source code must retain the above copyright notice, this list
00011  *  of conditions and the following disclaimer. 
00012  *  
00013  *  Redistributions in binary form must reproduce the above copyright notice, this list
00014  *  of conditions and the following disclaimer in the documentation and/or other materials
00015  *  provided with the distribution. 
00016  *
00017  *  Neither the name of the owner nor the names of its contributors may be used to endorse or
00018  *  promote products derived from this software without specific prior written permission. 
00019  *
00020  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
00021  *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
00022  *  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR
00023  *  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
00024  *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
00025  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
00026  *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
00027  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00028  *
00029  */
00030 
00031  /* =========================================================================
00032   * =========================================================================
00033   * 
00034   * Module: sched_dump.h
00035   *
00036   * $Revision: 1.1 $
00037   * $Date: 2005/12/30 01:50:22 $
00038   * $Author: weitang $
00039   * $Source: /depot/CVSROOT/javi/src/sw/cmplr/be/cg/sched/sched_dump.cxx,v $
00040   *
00041   * Description:
00042   * ============
00043   * 
00044   * Most of dump-routines implemented in this file. since dump routines 
00045   * are rarely used. We concentrate them in one place to reduce the working-
00046   * set of our compiler
00047   *
00048   * =========================================================================
00049   * =========================================================================
00050   */
00051 #include "tracing.h"
00052 #include "scheduler.h"
00053 #include "stdarg.h"
00054 #include "sched_rgn_info.h"
00055 #include "sched_cflow.h"
00056 
00057 #define DUMP_OP_SUMMARY(o,f)  { fprintf ((f), "[OP%3d][BB%3d][%-7s]", \
00058                                 OP_map_idx((o)), BB_id(OP_bb((o))), \
00059                                 TOP_Name(OP_code(o))); }        
00060 
00061 #define BEGIN_WITH_NEW_LINE(f) { fprintf (f,"\n") ; } 
00062 
00063 char * sched_dump_indent = "   " ; 
00064 char * caption_l_bar = "=========>" ; 
00065 char * caption_r_bar = "<=========" ;
00066 
00067     /* each line of dumpped content do not exceed this very much
00068      */
00069 enum { LINE_MAX_WIDTH = 75, };
00070 
00071 /* ===============================================================
00072  *
00073  *      Dump a individual CANDIDATE 
00074  * 
00075  * ==============================================================
00076  */
00077 void
00078 CANDIDATE :: Dump (FILE *f, BOOL verbose,
00079                       FAVOR_DELAY_HEUR * heur) {
00080 
00081     if (!Op()) {
00082         fprintf (f,"CANDIDATE(%p)'s corresponding OP is NULL", this);
00083         return ;
00084     }
00085 
00086     if (verbose) {
00087         DUMP_OP_SUMMARY(Op(),f) ; 
00088     }
00089 
00090     /* We should print out the cached _e_time field, the up-to-date
00091      * e-time is print by 'Dump_OP_Heur_Info()'
00092      */
00093     fprintf (f, " %-9s %s ", 
00094                  spec_text[_spec_type],
00095                  Is_P_Ready () ? "PREADY" : "MREADY");
00096 
00097     /* print the heuristic stuff associated with this candidate
00098      */
00099     if (heur) {
00100        heur->Dump_OP_Heur_Info (_op,f,FALSE);
00101     }
00102 }
00103 
00104     /* ==============================================================
00105      *
00106      * tagRGN_INFO :: Dump 
00107      * 
00108      * Dump the status of RGN_INFO 
00109      * 
00110      * =============================================================
00111      */
00112 void
00113 RGN_INFO :: Dump (FILE * f) {
00114 
00115     if (!rgn) {
00116         fprintf (f,"REGION:(NULL)\n");
00117         return ;
00118     }
00119 
00120     char * s = NULL ;
00121 
00122     switch (skip_reason) {
00123     case SKIP_RGN_NONE:
00124         s = "(Need Scheduling)" ;
00125         break ;
00126 
00127     case SKIP_RGN_IMPROPER:
00128         s = "(Improper Region)" ;
00129         break ;
00130 
00131     case SKIP_RGN_NON_SEME:
00132         s = "(Non-SEME Region)" ;
00133         break ;
00134 
00135     case SKIP_RGN_CRITICAL_EDGE:
00136         s = "(Critical Edge present)";
00137         break ;
00138 
00139     case SKIP_RGN_DEBUG:
00140         s = "(Skip scheduling for debugging purpose)";
00141         break ;
00142 
00143     case SKIP_RGN_NO_FURTHER_OPT:
00144         s = "(Need no further opt)";
00145         break ;
00146     
00147     default:
00148         FmtAssert (FALSE,
00149             ("Unknown SKIP_SCHED_RGN_REASON (%d)", skip_reason));
00150     }
00151 
00152     fprintf (f, " %s, %s\n", s, 
00153                  in_abnormal_loop ? "In abnormal loop" : "");
00154     
00155     if (summary) { 
00156         summary->Dump (); 
00157     } else { 
00158         fprintf (f," summary : NULL") ; 
00159     }
00160 
00161     fprintf (f, "\n");
00162 }
00163 
00164 
00165 /* ==========================================================
00166  *
00167  *      Dump a whole candidate list
00168  *
00169  * =========================================================
00170  */
00171 void
00172 CAND_LIST :: Dump (FILE * f, BOOL verbose, FAVOR_DELAY_HEUR * heur) {
00173 
00174     if (verbose) {
00175         fprintf (f, "%sCANDIDATE LIST %d IN TOTAL "
00176                     "(%d TRIED)%s\n", 
00177              caption_l_bar,
00178              _total, _tried_cand_num,
00179              caption_r_bar) ;
00180     } else {
00181         BEGIN_WITH_NEW_LINE (f);
00182     }
00183 
00184     for (CAND_LIST_ITER iter(this) ; !iter.done(); iter.step ()) {
00185 
00186         CANDIDATE* cand = iter.cur ();
00187 
00188             /* we should distinguish each candidate, if its dumpped
00189              * text is terse, it may be illegible.
00190              */
00191         cand->Dump (f, TRUE, heur);
00192         fprintf (f,Cand_Has_Been_Tried (cand) ? "  TRIED":" NONTRY");
00193 
00194         BEGIN_WITH_NEW_LINE (f);
00195     }
00196 }
00197 
00198 #ifdef Is_True_On
00199 
00200 void
00201 CAND_LIST :: gdb_dump (FAVOR_DELAY_HEUR * heur) {
00202     Dump (stderr, TRUE, heur);    
00203 }
00204 
00205 #endif
00206 
00207 
00208 void
00209 SRC_BB_MGR::Dump (FILE *f) {
00210 
00211     if (!_targ) return ;
00212         
00213     fprintf (f, "SOURCE BBs OF BB:%d\n", BB_id(_targ));
00214 
00215     for (SRC_BB_INFO_ITER iter = _src_info_vect.begin () ; 
00216         iter != _src_info_vect.end() ; iter++) {
00217 
00218         SRC_BB_INFO* info = *iter ;
00219         fprintf (f, "\t====> SRC BB:%3d cutting set:", 
00220                  BB_id(info->Source_BB ()));
00221         
00222         BB_VECTOR* bbv = info->Get_Cutting_Set ();
00223         for (BB_VECTOR_ITER cs_iter = bbv->begin() ; 
00224              cs_iter != bbv->end() ; cs_iter ++) {
00225             fprintf (f,"BB:%3d ", BB_id(*cs_iter));
00226         }
00227 
00228         bbv = info->Move_Across_Or_Around_BBs ();
00229         fprintf (f, "\n\t    BBs between src BB and cutting-set:");
00230         for (BB_VECTOR_ITER tmp_iter = bbv->begin() ;
00231              tmp_iter != bbv->end() ; 
00232              tmp_iter++) {
00233 
00234             fprintf (f,"BB:%3d ", BB_id(*tmp_iter));
00235 
00236         }
00237 
00238         fprintf (f, "\n\t    Nested REGIONs between src BB and cutting-set:");
00239         REGION_VECTOR* rv = info->Move_Across_Or_Around_Nested_Rgns ();
00240         for (REGION_VECTOR_ITER rgn_iter = rv->begin ();
00241              rgn_iter != rv->end ();
00242              rgn_iter ++) {
00243 
00244             fprintf (f, "RGN:%3d ", (*rgn_iter)->Id());
00245 
00246         }
00247 
00248         fprintf (f,"\n");
00249     }
00250 
00251 }
00252 
00253 #ifdef Is_True_On
00254 
00255 void
00256 SRC_BB_MGR :: gdb_dump (void) {
00257     Dump (stderr);
00258 }
00259 
00260 #endif 
00261 
00262     /* =======================================================
00263      *
00264      *   Dump SCHED_BB_ANNOT structure's content 
00265      *
00266      * =======================================================
00267      */
00268 void
00269 SCHED_BB_ANNOT::Dump (FILE *f) {
00270 
00271     fprintf (f,"\n===========BB:%d===========\n", BB_id(_bb));
00272 
00273     if (!_1st_append_op)
00274         fprintf (f, "no appended op,") ; 
00275     else 
00276         fprintf (f, "1st appended op[%d],", OP_map_idx(_1st_append_op));
00277 
00278 
00279     if (!_last_prepend_op) 
00280         fprintf (f, "no prepend op,") ;
00281     else
00282         fprintf (f, "last prepend op[%d],", OP_map_idx(_last_prepend_op));
00283 
00284     fprintf (f, "\n");
00285 
00286     OP * op ;
00287     SCHED_OP_ANNOT * op_annot ; 
00288 
00289     FOR_ALL_BB_OPs (_bb, op) {
00290         op_annot = Get_OP_Annot(op) ;
00291         if (!op_annot) fprintf (f, "[OP:%d] NULL\n", OP_map_idx(op));
00292         else op_annot->Dump(f);
00293     }
00294 
00295 }
00296 
00297      /* =======================================================
00298       *
00299       *   Dump SCHED_RGN_ANNOT structure's status 
00300       * 
00301       * =======================================================
00302       */
00303 void
00304 SCHED_RGN_ANNOT::Dump (FILE *f) {
00305     fprintf (f, "RGN %d\n", _rgn->Id()); 
00306 }
00307 
00308     /* =====================================================
00309      *
00310      *   Dump SCHED_OP_ANNOT structure's status
00311      *
00312      * =====================================================
00313      */
00314 void
00315 SCHED_OP_ANNOT::Dump(FILE* f) {
00316     
00317     fprintf (f, 
00318         "OP[%d] %s, original home BB BB:%d, current home BB BB:%d, ext-flag:%#X\n", 
00319                  OP_map_idx(_op), TOP_Name(OP_code(_op)),
00320                  BB_id (_org_home_bb), BB_id(OP_bb(_op)),
00321                  _ext_flags);
00322 }
00323 
00324     /* ====================================================
00325      *
00326      *  Dump the content of CFG_NODE_MAP
00327      *
00328      * ===================================================
00329      */
00330 void
00331 CFG_NODE_MAP :: Dump (FILE *f) {
00332 
00333     char buf[LINE_MAX_WIDTH * 2], *next;
00334     
00335     if (_bb_map_vect.size()) {
00336         
00337         next = &buf[0]; *next = '\0';
00338         BOOL first_elem = TRUE;
00339 
00340         for (_PAIR_VECT_ITER iter = _bb_map_vect.begin () ;
00341              iter != _bb_map_vect.end ();
00342              iter ++) {
00343 
00344             next += sprintf (next, "%s<BB:%d,%p>", 
00345                                     first_elem ? "" : ", ",
00346                                     (*iter).node_id, 
00347                                     (*iter).value);
00348 
00349             if (next - &buf[0] >= LINE_MAX_WIDTH) {
00350                 fprintf (f,"%s\n", buf);
00351                 next = &buf[0];
00352             }
00353             
00354             first_elem = FALSE;
00355         }
00356         fprintf (f,"%s\n", buf);
00357     }
00358 
00359     if (_rgn_map_vect.size()) {
00360 
00361         next = &buf[0]; *next = '\0';
00362         BOOL first_elem = TRUE;
00363 
00364         for (_PAIR_VECT_ITER iter = _rgn_map_vect.begin () ;
00365              iter != _bb_map_vect.end ();
00366              iter ++) {
00367 
00368             next += sprintf (next, "%s<RGN:%d,%p>", 
00369                                     first_elem ? "" : ",",
00370                                     (*iter).node_id, 
00371                                     (*iter).value);
00372 
00373             if (next - &buf[0] >= LINE_MAX_WIDTH) {
00374                 fprintf (f, "%s\n", buf);
00375                 next = &buf[0];
00376             }
00377 
00378             first_elem = FALSE;
00379         }
00380 
00381         fprintf (f, "%s\n", buf);
00382     }
00383 }
00384 
00385 #ifdef Is_True_On
00386 
00387 void
00388 CFG_NODE_MAP :: gdb_dump (void) {
00389     Dump (stderr) ; fflush (stderr); 
00390 }
00391 
00392 #endif
00393 
00394     /* ========================================================
00395      * 
00396      *   Dump a paticular OP_HEUR_INFO structure
00397      * 
00398      * =======================================================
00399      */
00400 void
00401 FAVOR_DELAY_HEUR::tagOP_HEUR_INFO::Dump (FILE *f,BOOL verbose) {
00402 
00403     if (verbose) {
00404         DUMP_OP_SUMMARY(_op,f);
00405     }
00406 
00407     fprintf (f," FOUT %2d E_TIM %3d ISSUE_PORT_# %2d DELAY %f",
00408                 _fan_out, _e_time, 
00409                 _issuable_port_num,_delay);
00410 }
00411 
00412    /* ========================================================
00413     *
00414     *    Dump heuristic information associated with 
00415     *    the given OP
00416     *
00417     * ========================================================
00418     */
00419 void
00420 FAVOR_DELAY_HEUR :: Dump_OP_Heur_Info 
00421     (OP * op, FILE *f, BOOL verbose) {
00422    
00423     OP_HEUR_INFO * info = Get_OP_Heur_Info (op);
00424     if (info) {
00425         info->Dump (f, verbose);
00426     } else {
00427         if (verbose) DUMP_OP_SUMMARY(op,f);
00428         fprintf (f, " (NULL)");
00429     }
00430 }
00431 
00432     /* =======================================================
00433      *
00434      *   Dump heuristic information associated with OPs 
00435      *   reside in <bb>
00436      * 
00437      * =======================================================
00438      */
00439 void
00440 FAVOR_DELAY_HEUR :: Dump_OP_Heur_Info 
00441     (BB * bb, FILE *f,BOOL verbose) {
00442 
00443     if (verbose) {
00444         fprintf (f,"%sHeuritics Infor OPs Reside in BB:%d%s\n", 
00445              caption_l_bar,
00446              BB_id(bb),
00447              caption_r_bar);
00448     }
00449 
00450     OP * op ;
00451     FOR_ALL_BB_OPs(bb, op) {
00452 
00453         /* It is make no sense to dump nop's heuristic (actually
00454          * there is no heuristic stuff bound to nop.
00455          */
00456         if (OP_noop(op)) continue ;
00457 
00458         Dump_OP_Heur_Info (op,f,TRUE);
00459         BEGIN_WITH_NEW_LINE (f);
00460     }
00461 }
00462 
00463 
00464  /* ===============================================================
00465   *
00466   *    Dump the status of class FAVOR_DELAY_HEUR
00467   *
00468   * ==============================================================
00469   */
00470 void
00471 FAVOR_DELAY_HEUR::Dump (FILE * f,BOOL verbose) {
00472 
00473     if (verbose) {
00474         fprintf (f,"%s FAVOR_DELAY_HEUR status %s\n",
00475                     caption_l_bar, caption_r_bar);
00476     }
00477 
00478     if (_bb_scope) {
00479 
00480        Dump_OP_Heur_Info (_bb_scope, f, verbose);
00481 
00482     } else {
00483 
00484         for (TOPOLOGICAL_REGIONAL_CFG_ITER 
00485              iter (_rgn_scope -> Regional_Cfg()) ; iter != 0 ; ++ iter) {
00486             
00487             if ((*iter)->Is_Region ()) continue ;
00488             BB * bb = (*iter)->BB_Node ();
00489             if (BB_entry(bb) || BB_exit(bb)) { continue ; } ;
00490 
00491             Dump_OP_Heur_Info (bb, f,verbose);
00492 
00493         } /* end of for-loop */
00494     }
00495 }
00496 
00497 #ifdef Is_True_On
00498 
00499 void
00500 FAVOR_DELAY_HEUR::gdb_dump (void) {
00501     Dump (stderr, TRUE);
00502 }
00503 
00504 #endif  /* Is_True_On */
00505 
00506     /* ==========================================================
00507      *
00508      *     Trace candidate selection process 
00509      *
00510      * =========================================================
00511      */
00512 void
00513 FAVOR_DELAY_HEUR::Enable_Trace_Cand_Sel_Process (FILE* f) {
00514 
00515     _trace_cand_sel = TRUE;
00516     _trace_file = f ;
00517     
00518 }
00519 
00520 void
00521 FAVOR_DELAY_HEUR :: Disable_Trace_Cand_Sel_Process (void) {
00522     
00523     _trace_cand_sel = FALSE;
00524 
00525     if (_trace_file) {
00526        _trace_file = NULL ;
00527     }
00528 }
00529 
00530 
00531 void 
00532 FAVOR_DELAY_HEUR :: Trace_Cand_Sel_Process (const char * fmt, ...) {
00533 
00534     Is_True (_trace_cand_sel, 
00535             ("We have not enable tracing candidate selection process yet!"));
00536 
00537     va_list ap ;
00538 
00539     va_start(ap, fmt);
00540     vfprintf (_trace_file, fmt, ap);
00541     va_end(ap);
00542 }
00543 
00544 
00545 
00546 
00547 
00548  /* =====================================================
00549   * =====================================================
00550   * 
00551   *  Dumping routines used directly by SCHEDULER
00552   *
00553   * =====================================================
00554   * =====================================================
00555   */
00556 
00557 
00558  /* =====================================================
00559   *
00560   *   Dump verbose information for a given OP 
00561   * 
00562   * =====================================================
00563   */
00564 void
00565 SCHEDULER::Dump_OP_Verbose_Info (OP* op, FILE * f) {
00566 
00567         /* 1. print the <op> itself 
00568          */
00569     DUMP_OP_SUMMARY(op,f);
00570     BEGIN_WITH_NEW_LINE(f);
00571 
00572     Set_Trace_File_internal (f);
00573     Print_OP_No_SrcLine (op);
00574     Set_Trace_File_internal (TFile);
00575 
00576     if (OP_Scheduled (op)) {
00577        fprintf (f,"ISSUE CYCLE: %3d ", OP_scycle(op));  
00578     }
00579 
00580         /*2. dump heuristic info */
00581     _heur_mgr.Dump_OP_Heur_Info (op, f,FALSE);
00582     
00583         /*3. dump its associated CADIDATE structure if any
00584          */
00585     CANDIDATE* cand = _cand_mgr.Get_Candidate (op) ;
00586     if (cand) { cand->Dump (f,FALSE); }
00587 
00588         /* ??? this should be put into cg_dep_graph.cxx */
00589 
00590     static char *arc_txt[] = {
00591         "REGIN", "REGOUT", "REGANTI", "MEMIN", "MEMOUT", "MEMANTI", 
00592         "MEMVOL", "MEMREAD", "SPILLIN", "PREFIN", "PREFOUT", "PREBR", 
00593         "POSTBR", "SCC", "PRECHK", "POSTCHK", "CTLSPEC", "MISC"
00594     };
00595 
00596         /*4. dump predecessors */
00597     fprintf (f, "\nPREDECESSORS:\n");
00598 
00599     for (ARC_LIST* arcs = OP_preds(op); 
00600          arcs != NULL; arcs = ARC_LIST_rest(arcs)) {
00601 
00602         ARC *arc = ARC_LIST_first(arcs) ;
00603         OP * pred = ARC_pred(arc) ;
00604 
00605         DUMP_OP_SUMMARY(pred,f);
00606         fprintf (f, "%-8s LAT %2d %s %-5s ", 
00607                 arc_txt[ARC_kind(arc)], 
00608                     ARC_latency(arc),
00609               ARC_is_dotted(arc)   ? "Dotted" : "Strict", 
00610               ARC_is_definite(arc) ? "Def" : "Indef");
00611         
00612         _heur_mgr.Dump_OP_Heur_Info (pred,f,FALSE); 
00613         if (OP_Scheduled(pred)) { fprintf (f," SCH") ; }
00614         BEGIN_WITH_NEW_LINE(f);
00615     }
00616 
00617         /*5. dump succs 
00618          */
00619     fprintf (f,"\nSuccessors:\n") ; 
00620     for (ARC_LIST* arcs = OP_succs(op); 
00621          arcs != NULL; arcs = ARC_LIST_rest(arcs)) {
00622         
00623         ARC * arc = ARC_LIST_first(arcs) ;
00624         OP  * succ = ARC_succ(arc);
00625 
00626         DUMP_OP_SUMMARY(succ,f);
00627         fprintf (f, "%-9s LATENCY %3d %-8s %s ", 
00628                 arc_txt[ARC_kind(arc)], 
00629                     ARC_latency(arc),
00630               ARC_is_dotted(arc)   ? "Dotted" : "Strict", 
00631               ARC_is_definite(arc) ? "Def" : "Indef");
00632 
00633         _heur_mgr.Dump_OP_Heur_Info (succ,f,FALSE); 
00634         if (OP_Scheduled(succ)) { fprintf (f," SCH") ; }
00635 
00636         BEGIN_WITH_NEW_LINE(f);
00637     }
00638 }
00639 
00640 
00641 /* ====================================================================
00642  *
00643  * SCHEDULER::Dump_IR (void)
00644  * 
00645  * We does not encourage dumping IR in this way. use SCHED_Dump_IR 
00646  * instead. 
00647  * 
00648  * ===================================================================
00649  */
00650 void
00651 SCHEDULER :: Dump_IR (FILE *f) {
00652 
00653     FmtAssert (FALSE,
00654         ("Please Use 'SCHED_Dump_IR' to dump IR instead!"));
00655 }
00656 
00657 /* ===================================================================
00658  *
00659  *  SCHEDULER::Dump_DAG ()
00660  * 
00661  * dump the dependence DAG into file <f>   
00662  * 
00663  * ==================================================================
00664  */
00665 void
00666 SCHEDULER :: Dump_DAG (FILE *f) {
00667 
00668     if (_global) {
00669 
00670         for (TOPOLOGICAL_REGIONAL_CFG_ITER cfg_iter(_region->Regional_Cfg()); 
00671              cfg_iter != 0; 
00672              ++cfg_iter) {
00673 
00674             if ((*cfg_iter)->Is_Region ())  continue ;
00675 
00676             BB * b = (*cfg_iter)->BB_Node ();
00677             if (BB_entry(b) || BB_exit(b))  continue ;
00678 
00679             CG_DEP_Trace_Graph(b);
00680         } /* end of for(TOPOLOGICAL...) */
00681 
00682     } else { 
00683 
00684         CG_DEP_Trace_Graph(_target_bb);
00685 
00686     }
00687 }
00688 
00689 
00690 /* ====================================================================
00691  *
00692  *  SCHEDULER::Dump ()
00693  * 
00694  *  Dump IR, candidate list, DAG etc.
00695  *
00696  * ===================================================================
00697  */
00698 void
00699 SCHEDULER::Dump (FILE *f) {
00700     
00701     FmtAssert (FALSE,
00702         ("SCHEDULER::Dump () has yet implemented!"));
00703 }
00704 
00705 
00706     /* ===============================================================
00707      *
00708      *   SCHED_Dump_IR 
00709      *
00710      *  dump IR of OPs in current code motion scope 
00711      * 
00712      *  prepass:    before or after register allocation
00713      *  bef_sched:  indicate whether IR is dumpped before 
00714      *              code motion occurs or after it 
00715      *  gcm:        global or local code motion 
00716      *  f:          it is self-descriptive
00717      *
00718      * ===============================================================
00719      */
00720 void
00721 SCHED_Dump_IR (BOOL prepass, BOOL bef_sched, BOOL gcm,FILE *f) {
00722 
00723     FILE * ftmp = TFile ;
00724     Set_Trace_File_internal (f);
00725 
00726     /* print header */
00727     fprintf (f, "\n%s\n IR %s ORC %s %s CODE MOTION (BEGIN)\n\n%s\n",
00728                 DBar,  
00729                 bef_sched ? "before"  : "after", 
00730                 prepass   ? "PREPASS" : "POSTPASS", 
00731                 gcm       ? "GLOBAL"  : "LOCAL",
00732                 DBar);
00733 
00734  
00735     for (BB* bb = REGION_First_BB; bb; bb = BB_next(bb)) {
00736         Print_BB_No_Srclines (bb);
00737 
00738         /* extra empty line to ease the navigation in vi */
00739         fprintf (f, "\n");
00740     }
00741  
00742     fprintf (f, "\n%s\n IR %s ORC %s %s CODE MOTION (END)\n\n%s\n",
00743                 DBar,  
00744                 bef_sched ? "before"  : "after", 
00745                 prepass   ? "PREPASS" : "POSTPASS", 
00746                 gcm       ? "GLOBAL"  : "LOCAL",
00747                 DBar);
00748 
00749     Set_Trace_File_internal (ftmp); 
00750 }
00751 
00752 
00753     /* ==========================================================
00754      * ==========================================================
00755      *
00756      *      Tracing routines of sched_rgn_info.cxx package 
00757      *
00758      * ==========================================================
00759      * ==========================================================
00760      */
00761 
00762 void
00763 RGN_SUMMARY::Dump (FILE * f, BOOL verbose) {
00764 
00765     if (verbose) {
00766         fprintf (f, "REGION %d", _rgn->Id());
00767     }
00768     
00769     if (!_summary_is_valid) {
00770         fprintf (f, "Invalid summary of REGION:%d\n", 
00771                     _rgn->Id());
00772         return ;
00773     }
00774 
00775     fprintf (f,"killed defs:\n");
00776     TN_SET_Print (_killed_def,f);
00777 }
00778 
00779 void
00780 REGION_INFO_MGR :: Dump (FILE *f, BOOL verbose) {
00781 
00782     for (INNERMOST_REGION_FIRST_ITER iter(_rgn_tree);
00783          iter != 0 ; ++iter) {
00784     
00785         fprintf (f,SBar);
00786         RGN_INFO * rgn_info = Get_Rgn_Info (*iter) ;
00787         rgn_info->Dump (f) ;
00788         fprintf (f, "%s\n", SBar);
00789     }
00790 }
00791 
00792 #ifdef Is_True_On 
00793 void
00794 RGN_SUMMARY::gdb_dump (void) {
00795     Dump (stderr, TRUE);
00796 }
00797 #endif
00798 
00799 
00800     /* =======================================================
00801      * =======================================================
00802      *
00803      * 
00804      *      Traceing routines of EXEC_PATH, EXEC_PATH_SET,
00805      *      and EXEC_PATH_MGR.
00806      *
00807      * ======================================================
00808      * ======================================================
00809      */
00810 
00811     /* dump the content of EXEC_PATH 
00812      */
00813 void
00814 EXEC_PATH :: Dump (FILE *f) {
00815     
00816         /* format e.g :
00817          *  path:5 {
00818          *       3,4,r5,7, 9
00819          *  }
00820          */
00821     fprintf (f, "path:%d{\n", Id ());
00822    
00823     char buf[LINE_MAX_WIDTH * 2];
00824     char *p = buf; *p = '\0';
00825 
00826     BOOL first_elem = TRUE;
00827 
00828     for (PATH_NODE_INFO_VECT_ITER iter = _path_node_seq.begin () ;
00829          iter != _path_node_seq.end ();
00830          iter ++) {
00831 
00832         PATH_NODE_INFO ni = *iter;
00833         
00834         if (!first_elem) { *p++ = ','; } else { first_elem = FALSE; }
00835 
00836         if (ni.Node()->Is_Region ()) {
00837             p += sprintf (p, "r%d(%f)", 
00838                           ni.Node()->Region_Node()->Id(),
00839                           ni.Prob_From_Root ());
00840         } else {
00841             p += sprintf (p, "%d(%f)", 
00842                           BB_id(ni.Node()->BB_Node()),
00843                           ni.Prob_From_Root ());
00844         }
00845 
00846         if (p - &buf[0] >= LINE_MAX_WIDTH) {
00847             fprintf (f,"%s",buf); p = &buf[0]; *p = '\0';
00848             fprintf (f, "\n");
00849         }
00850     }
00851 
00852     fprintf (f, "%s\n}\n", buf);
00853 }
00854 
00855     /* =======================================================
00856      *
00857      * EXEC_PATH_SET::Dump
00858      * 
00859      * Dump the content of EXEC_PATH_SET. 
00860      * <dump_path_id_range> is the supporting routine to Dump.
00861      *
00862      * =======================================================
00863      */
00864 static void
00865 dump_path_id_range 
00866     (FILE *f, EXEC_PATH_ID begin, EXEC_PATH_ID end, BOOL* first_range) {
00867    
00868     if (!*first_range) { fprintf (f,","); }
00869     if (end == begin) { fprintf (f, "%d", begin); }
00870     else if (end > begin) {
00871         fprintf (f, "%d-%d", begin, end);
00872     } else if (end < begin) {
00873         FmtAssert (FALSE, 
00874             ("<begin>(%d) is expected no greater than <end>(%d)",
00875              begin, end));
00876     }
00877     
00878     * first_range = FALSE ;
00879 }
00880 
00881 void
00882 EXEC_PATH_SET :: Dump (FILE *f) {
00883    
00884     BOOL first_range = TRUE;
00885     fprintf (f,"{ ");
00886     
00887     EXEC_PATH_ID  range_begin = First_Path_Id ();
00888 
00889     if (EXEC_PATH_ID_IS_INVALID(range_begin)) {
00890         fprintf (f,"}\n");
00891         return ;
00892     }
00893 
00894     EXEC_PATH_ID pid,last_pid=range_begin;
00895 
00896     while (!EXEC_PATH_ID_IS_INVALID(pid = Next_Path_Id (last_pid))) {
00897 
00898         if (pid != last_pid + 1) {
00899             /* continguity stop here 
00900              */
00901             dump_path_id_range (f, range_begin, last_pid,&first_range);
00902             range_begin = pid;
00903         }
00904         last_pid = pid;
00905     }
00906 
00907     dump_path_id_range (f, range_begin, last_pid, &first_range);
00908 
00909     fprintf (f,"}\n");
00910 }
00911 
00912     /* dump the content of EXEC_PATH_MGR 
00913      */
00914 void
00915 EXEC_PATH_MGR :: Dump (FILE *f) {
00916     
00917     if (!_region) {  return ; };
00918 
00919     fprintf (f, "EXEC PATH INFO OF REGION:%d\n", _region->Id());
00920     
00921     for (EXEC_PATH_VECT_ITER iter = _pathv.begin () ;
00922          iter != _pathv.end ();
00923          iter ++) {
00924         (*iter)->Dump (f); 
00925     }
00926 
00927     fprintf (f,"%s", DBar);
00928 }
00929 
00930 #ifdef Is_True_On 
00931 
00932 void
00933 EXEC_PATH :: gdb_dump (void) {
00934     Dump (stderr); fflush (stderr);
00935 }
00936 
00937 void
00938 EXEC_PATH_SET :: gdb_dump (void) {
00939     Dump (stderr); fflush (stderr);
00940 }
00941 
00942 void
00943 EXEC_PATH_MGR :: gdb_dump (void) {
00944     Dump (stderr); fflush (stderr);
00945 }
00946 
00947 #endif /* Is_True_On */
osprey/be/cg/sched/sched_dump.cxx
