Open64: osprey/be/com/ipa_lno_summary.cxx Source File

00001 /*
00002 
00003   Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00004 
00005   This program is free software; you can redistribute it and/or modify it
00006   under the terms of version 2 of the GNU General Public License as
00007   published by the Free Software Foundation.
00008 
00009   This program is distributed in the hope that it would be useful, but
00010   WITHOUT ANY WARRANTY; without even the implied warranty of
00011   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00012 
00013   Further, this software is distributed without any warranty that it is
00014   free of the rightful claim of any third person regarding infringement 
00015   or the like.  Any license provided herein, whether implied or 
00016   otherwise, applies only to this software file.  Patent licenses, if 
00017   any, provided herein do not apply to combinations of this program with 
00018   other software, or any other product whatsoever.  
00019 
00020   You should have received a copy of the GNU General Public License along
00021   with this program; if not, write the Free Software Foundation, Inc., 59
00022   Temple Place - Suite 330, Boston MA 02111-1307, USA.
00023 
00024   Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00025   Mountain View, CA 94043, or:
00026 
00027   http://www.sgi.com
00028 
00029   For further information regarding this notice, see:
00030 
00031   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00032 
00033 */
00034 
00035 
00036 #include <stdio.h>
00037 #include "defs.h"
00038 #include "symtab.h"
00039 #include "ipa_lno_summary.h"
00040 #include "ipa_section.h" 
00041 #include "ipa_lno_file.h"
00042 
00043 //-----------------------------------------------------------------------
00044 // NAME: IPA_LNO_SUMMARY_PROCEDURE::IPA_LNO_Print
00045 // FUNCTION: Print the IPA_LNO_SUMMARY_PROCEDURE, assuming that it appears
00046 //   at PROCEDURE index 'procedure_index'. 
00047 //-----------------------------------------------------------------------
00048 
00049 void IPA_LNO_SUMMARY_PROCEDURE::Print(FILE* fp,
00050               INT procedure_index)
00051 {
00052   if (procedure_index == -1)
00053     fprintf(fp, "PROCEDURE: %s", ST_name(St_Idx()));
00054   else 
00055     fprintf(fp, "PROCEDURE[%d]: %s ", procedure_index, ST_name(St_Idx()));
00056   if (Has_Incomplete_Array_Info()) { 
00057     fprintf(fp, "INCOMPLETE_ARRAY_INFO ");
00058   } else {
00059     fprintf(fp, "FORMALS[%d:%d] GLOBALS[%d:%d] \n", 
00060       _formal_index, _formal_count, _global_index, _global_count);
00061     fprintf(fp, "  VALUE[%d:%d] EXPR[%d:%d] ", _value_index, _value_count, 
00062       _expr_index, _expr_count);
00063   } 
00064   fprintf(fp, "\n");
00065 }
00066 
00067 //-----------------------------------------------------------------------
00068 // NAME: IPA_LNO_SUMMARY_FORMAL::Print
00069 // FUNCTION: Print the IPA_LNO_SUMMARY_FORMAL, assuming that it appears
00070 //   at FORMAL index 'formal_index'. 
00071 //-----------------------------------------------------------------------
00072 
00073 void IPA_LNO_SUMMARY_FORMAL::Print(FILE* fp,
00074            INT formal_index)
00075 {
00076   if (formal_index == -1)
00077     fprintf(stdout, "FORMAL: ");
00078   else 
00079     fprintf(stdout, "FORMAL[%d]: ", formal_index);
00080   if (Is_Scalar()) {
00081     fprintf(fp, "POSITION(%d) Scalar  MOD[%s] REF[%s] MTYPE(%s)\n", 
00082       _position, Is_May_Kill() ? "T" : "F", Is_Use() ? "T" : "F", 
00083       MTYPE_name(_machine_type));
00084   } else if (Is_Array()) {
00085     fprintf(fp, "POSITION(%d) Array   MOD[%d] REF[%d] DECL[%d] ",
00086       _position, _mod_array_section_index, _ref_array_section_index, 
00087       _decl_array_section_index);
00088     fprintf(fp, "MTYPE(%s) \n", MTYPE_name(_machine_type));
00089   } else {
00090     fprintf(fp, "POSITION(%d) Unknown \n", _position);
00091   } 
00092 }
00093 
00094 //-----------------------------------------------------------------------
00095 // NAME: IPA_LNO_SUMMARY_GLOBAL::Print
00096 // FUNCTION: Print the IPA_LNO_SUMMARY_GLOBAL, assuming that it appears
00097 //   at GLOBAL index 'global_index'. 
00098 //-----------------------------------------------------------------------
00099 
00100 void IPA_LNO_SUMMARY_GLOBAL::Print(FILE* fp,
00101            INT global_index)
00102 { 
00103   if (global_index == -1) 
00104     fprintf(stdout, "GLOBAL: ");
00105   else 
00106     fprintf(stdout, "GLOBAL[%d] ", global_index);
00107   if (Is_Scalar()) 
00108     fprintf(fp, "Scalar %s MOD[%s] REF[%s]\n", 
00109       ST_name(St_Idx()), Is_May_Kill() ? "T" : "F", Is_Use() ? "T" : "F");
00110   else 
00111     fprintf(fp, "Array  %s MOD[%d] REF[%d]\n",
00112       ST_name(St_Idx()), Mod_Array_Section_Index(), Ref_Array_Section_Index());
00113 } 
00114 
00115 //-----------------------------------------------------------------------
00116 // NAME: IVAR::IPA_LNO_Print
00117 // FUNCTION: Print the IVAR, assuming it is in "memory" format.
00118 //-----------------------------------------------------------------------
00119 
00120 void IVAR::IPA_LNO_Print(FILE* fp,
00121                          IPA_LNO_READ_FILE* IPA_LNO_File)
00122 {
00123   if (Is_Formal()) {
00124     fprintf(fp, "FORMAL_POSITION = %d, OFFSET = %d, MTYPE = %s\n",
00125             Formal_Position(), Offset(), Machine_Types[Mtype()].name);
00126   }
00127   else {
00128     fprintf(fp, "GLOBAL %s, OFFSET = %d, MTYPE = %s\n",
00129             ST_name(St_Idx()), Offset(), Machine_Types[Mtype()].name);
00130   }
00131 }
00132 
00133 //-----------------------------------------------------------------------
00134 // NAME: TERM::IPA_LNO_Print
00135 // FUNCTION: Print the TERM, assuming it is in "memory" format.
00136 //-----------------------------------------------------------------------
00137 
00138 void TERM::IPA_LNO_Print(FILE* fp,
00139                          IPA_LNO_READ_FILE* IPA_LNO_File)
00140 {
00141   switch (Get_type()) {
00142   case LTKIND_NONE:
00143     fprintf(fp, "NONE ");
00144     break;
00145   case LTKIND_CONST:
00146     fprintf(fp, "CONST(%d) \n", Get_coeff());
00147     break;
00148   case LTKIND_LINDEX:
00149     fprintf(fp, "LINDEX(%d) * (%d) \n", Get_desc(), Get_coeff());
00150     break;
00151   case LTKIND_SUBSCR:
00152     fprintf(fp, "SUBSCR(%d) * (%d) \n", Get_desc(), Get_coeff());
00153     break;
00154   case LTKIND_IV:
00155     fprintf(fp, "IVAR[%d] * (%d): ", Get_desc(), Get_coeff());
00156     break;
00157   default:
00158     fprintf(fp, "<UNKNOWN> \n");
00159     break;
00160   }
00161 }
00162 
00163 //-----------------------------------------------------------------------
00164 // NAME: PROJECTED_NODE::IPA_LNO_Print
00165 // FUNCTION: Print the PROJECTED_NODE, assuming it is in "memory" format.
00166 //-----------------------------------------------------------------------
00167 
00168 void PROJECTED_NODE::IPA_LNO_Print(FILE* fp,
00169                                    IPA_LNO_READ_FILE* IPA_LNO_File)
00170 {
00171   fprintf(fp, "++++++PROJECTED_NODE_START++++++\n");
00172   if (Is_unprojected()) {
00173     fprintf(fp, "<UNPROJECTED> \n");
00174     if (Is_messy_lb()) {
00175       fprintf(fp, "LB <MESSY> \n");
00176       LINEX* lx = Get_lower_linex();
00177       for (INT i = 0; i <= lx->Num_terms(); i++) {
00178         TERM* tm = lx->Get_term(i);
00179         tm->IPA_LNO_Print(fp, IPA_LNO_File);
00180       }
00181     } else {
00182       fprintf(fp, "LB: ");
00183       LINEX* lx = Get_lower_linex();
00184       for (INT i = 0; i <= lx->Num_terms(); i++) {
00185         TERM* tm = lx->Get_term(i);
00186         tm->IPA_LNO_Print(fp, IPA_LNO_File);
00187       }
00188     }
00189   } else {
00190     if (Is_messy_lb()) {
00191       fprintf(fp, "LB <MESSY> \n");
00192       LINEX* lx = Get_lower_linex();
00193       for (INT i = 0; i <= lx->Num_terms(); i++) {
00194         TERM* tm = lx->Get_term(i);
00195         tm->IPA_LNO_Print(fp, IPA_LNO_File);
00196       }
00197     } else {
00198       fprintf(fp, "LB: ");
00199       LINEX* lx = Get_lower_linex();
00200       for (INT i = 0; i <= lx->Num_terms(); i++) {
00201         TERM* tm = lx->Get_term(i);
00202         tm->IPA_LNO_Print(fp, IPA_LNO_File);
00203       }
00204     }
00205     if (Is_messy_ub()) {
00206       fprintf(fp, "UB <MESSY> \n");
00207     } else {
00208       fprintf(fp, "UB: ");
00209       LINEX* lx = Get_upper_linex();
00210       for (INT i = 0; i <= lx->Num_terms(); i++) {
00211         TERM* tm = lx->Get_term(i);
00212         tm->IPA_LNO_Print(fp, IPA_LNO_File);
00213       }
00214     }
00215     if (Is_messy_step()) {
00216       fprintf(fp, "STEP <MESSY> \n");
00217     } else {
00218       fprintf(fp, "STEP: ");
00219       LINEX* lx = Get_step_linex();
00220       for (INT i = 0; i <= lx->Num_terms(); i++) {
00221         TERM* tm = lx->Get_term(i);
00222         tm->IPA_LNO_Print(fp, IPA_LNO_File);
00223       }
00224     }
00225     if (Get_segment_length_linex() != NULL) { 
00226       fprintf(fp, "STEP: ");
00227       LINEX* lx = Get_segment_length_linex();
00228       for (INT i = 0; i <= lx->Num_terms(); i++) {
00229         TERM* tm = lx->Get_term(i);
00230         tm->IPA_LNO_Print(fp, IPA_LNO_File);
00231       }
00232     }   
00233     if (Get_segment_stride_linex() != NULL) { 
00234       fprintf(fp, "STEP: ");
00235       LINEX* lx = Get_segment_stride_linex();
00236       for (INT i = 0; i <= lx->Num_terms(); i++) {
00237         TERM* tm = lx->Get_term(i);
00238         tm->IPA_LNO_Print(fp, IPA_LNO_File);
00239       }
00240     }   
00241   }
00242   if (Is_assumed_shape())
00243     fprintf(fp, "<ASSUMED_SHAPE> \n");
00244   fprintf(fp, "++++++PROJECTED_NODE_FINISHED++++++\n");
00245 }
00246 
00247 //-----------------------------------------------------------------------
00248 // NAME: PROJECTED_REGION::IPA_LNO_Print
00249 // FUNCTION: Print the PROJECTED_REGION, assuming it is in "memory" format.
00250 //-----------------------------------------------------------------------
00251 
00252 void PROJECTED_REGION::IPA_LNO_Print(FILE* fp,
00253                                      IPA_LNO_READ_FILE* IPA_LNO_File)
00254 {
00255   fprintf(fp, "++++++++PROJECTED_REGION_START+++++++++\n");
00256   for (INT i = 0; i < Get_num_dims(); i++) {
00257     PROJECTED_NODE* pn = Get_projected_node(i);
00258     pn->IPA_LNO_Print(fp, IPA_LNO_File);
00259   }
00260   fprintf(fp, "DEPTH(%d) ", Get_depth());
00261   if (Is_messy_region())
00262     fprintf(fp, "<MESSY> ");
00263   if (Is_unprojected_region())
00264     fprintf(fp, "<UNPROJECTED> ");
00265   if (Is_may_kill()) {
00266     fprintf(fp, "MAY_KILL ");
00267   } else if (Is_may_use()) {
00268     fprintf(fp, "MAY_USE ");
00269   } else if (Is_passed()) {
00270     fprintf(fp, "                  ");
00271     fprintf(fp, "\n");
00272     fprintf(fp, "PASSED ");
00273     fprintf(fp, "ACTUAL_POSITION(%d) ",  Get_actual_id());
00274   } else if (Is_formal()) {
00275     fprintf(fp, "FORMAL ");
00276   }
00277   fprintf(fp, "\n");
00278   fprintf(fp, "++++++++PROJECTED_REGION_FINISHED+++++++++\n");
00279 }
00280