Open64: osprey/ipa/local/ipl_bread

00001 /*
00002  * Copyright 2003, 2004, 2005, 2006 PathScale, Inc.  All Rights Reserved.
00003  */
00004 
00005 /*
00006 
00007   Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00008 
00009   This program is free software; you can redistribute it and/or modify it
00010   under the terms of version 2 of the GNU General Public License as
00011   published by the Free Software Foundation.
00012 
00013   This program is distributed in the hope that it would be useful, but
00014   WITHOUT ANY WARRANTY; without even the implied warranty of
00015   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00016 
00017   Further, this software is distributed without any warranty that it is
00018   free of the rightful claim of any third person regarding infringement 
00019   or the like.  Any license provided herein, whether implied or 
00020   otherwise, applies only to this software file.  Patent licenses, if 
00021   any, provided herein do not apply to combinations of this program with 
00022   other software, or any other product whatsoever.  
00023 
00024   You should have received a copy of the GNU General Public License along
00025   with this program; if not, write the Free Software Foundation, Inc., 59
00026   Temple Place - Suite 330, Boston MA 02111-1307, USA.
00027 
00028   Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00029   Mountain View, CA 94043, or:
00030 
00031   http://www.sgi.com
00032 
00033   For further information regarding this notice, see:
00034 
00035   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00036 
00037 */
00038 
00039 
00040 /* -*-Mode: c++;-*- (Tell emacs to use c++ mode) */
00041 
00042 #define __STDC_LIMIT_MACROS
00043 #include <stdint.h>
00044 #if defined(BUILD_OS_DARWIN)
00045 #include <darwin_elf.h>                        // Elf64_Word
00046 #else /* defined(BUILD_OS_DARWIN) */
00047 #include <elf.h>                        // Elf64_Word
00048 #endif /* defined(BUILD_OS_DARWIN) */
00049 #include <sys/elf_whirl.h>              // WT_IPA_SUMMARY
00050 #include <sys/types.h>                  // ir_bwrite.h needs it
00051 
00052 #include "defs.h"
00053 #include "wn.h"                         // ir_bwrite.h needs it
00054 #include "pu_info.h"                    // ir_bwrite.h needs it
00055 #include "ir_bwrite.h"                  // Output_File
00056 #include "ir_bcom.h"                    // ir_b_save_buf
00057 #include "ipl_main.h"                   // Do_Par, DoPreopt, ...
00058 #include "ipl_summary.h"    // SUMMARY_* classes
00059 #include "ipl_summarize.h"              // SUMMARY class
00060 #include "ipl_array_bread_write.h"      // ARRAY_SUMMARY_OUTPUT
00061 #include "ipl_bread_write.h"            // C linkage
00062 
00063 
00064 extern mUINT8 Optlevel;                 // from ipl_main.cxx
00065 
00066 
00067 #define SUMMARY_HEADER_ADDR(offset) \
00068     ((SUMMARY_FILE_HEADER*)(fl->map_addr + offset))
00069 
00070 #define HEADER_ADDR(offset) \
00071  ((Elf64_Word*)(fl->map_addr + offset))
00072 
00073 static SUMMARY_FILE_HEADER header;
00074 
00075 // if we are not computing array section information, atleast
00076 // fill in the necessary header fields
00077 static void
00078 init_array_size_fields(SUMMARY_FILE_HEADER *header_addr)
00079 {
00080   header_addr->Set_cfg_node_size(0);
00081   header_addr->Set_regions_array_size(0);
00082   header_addr->Set_projected_region_size(0);
00083   header_addr->Set_projected_array_size(0);
00084   header_addr->Set_term_array_size(0);
00085   header_addr->Set_ivar_size(0);
00086   header_addr->Set_loopinfo_size(0);
00087   header_addr->Set_scalar_node_size(0);
00088 }
00089 
00090 void
00091 IPA_irb_write_summary(Output_File *fl)
00092 {
00093     INT size, offset, idx, header_loc;
00094     INT offset_sym, offset_proc, offset_feedback, offset_call;
00095     INT offset_formal, offset_actual, offset_value, offset_expr;
00096     INT offset_phi, offset_chi, offset_global;
00097     INT offset_stmt, offset_ctrl_dep, offset_global_stid;
00098     INT cur_sec_disp, offset_common, offset_common_shape;
00099     INT offset_struct_access;
00100 #ifdef KEY
00101     INT offset_ty_info = 0;
00102 #endif
00103 
00104     Elf64_Word temp;
00105     offset_sym = offset_proc = offset_feedback = offset_call = 0;
00106     offset_formal = offset_actual = offset_value = offset_expr = 0;
00107     offset_phi = offset_chi = offset_stmt = offset_ctrl_dep = 0;
00108     offset_global = 0; offset_common = 0; offset_common_shape = 0;
00109     offset_global_stid = 0;offset_struct_access=0;
00110 
00111     cur_sec_disp = fl->file_size;
00112 
00113     // store the offset of the header structure in this field
00114     header_loc = (INT) ir_b_save_buf(&temp, sizeof(Elf64_Word),
00115              sizeof(INT64),0,fl);
00116     
00117 
00118     if (Summary->Has_symbol_entry ()) {
00119   size = (Summary->Get_symbol_idx () + 1) * sizeof(SUMMARY_SYMBOL);
00120 
00121   offset_sym  = (INT) ir_b_save_buf (Summary->Get_symbol (0),
00122               size, sizeof(INT64), 0, fl);
00123   
00124   offset_sym = offset_sym - cur_sec_disp;
00125     }
00126 
00127     if (Summary->Has_value_entry ()) {
00128   size = (Summary->Get_value_idx() + 1) * sizeof(SUMMARY_VALUE);
00129 
00130   offset_value = (INT) ir_b_save_buf (Summary->Get_value (0),
00131               size, sizeof(INT64), 0, fl);
00132 
00133   offset_value = offset_value - cur_sec_disp;
00134     }
00135 
00136     if (Summary->Has_procedure_entry ()) {
00137   size = (Summary->Get_procedure_idx () + 1) *
00138       sizeof(SUMMARY_PROCEDURE);
00139 
00140   offset_proc  = (INT) ir_b_save_buf (Summary->Get_procedure (0),
00141               size, sizeof(INT64), 0, fl);
00142 
00143   offset_proc = offset_proc - cur_sec_disp;
00144     }
00145 
00146     if (Summary->Has_feedback_entry ()) {
00147   size = (Summary->Get_feedback_idx () + 1) * sizeof(SUMMARY_FEEDBACK);
00148 
00149   offset_feedback  = (INT) ir_b_save_buf (Summary->Get_feedback (0),
00150             size, sizeof(INT64), 0, fl);
00151 
00152   offset_feedback = offset_feedback - cur_sec_disp;
00153     }
00154 
00155     if (Summary->Has_callsite_entry ()) {
00156   size = (Summary->Get_callsite_idx() + 1) * sizeof(SUMMARY_CALLSITE);
00157 
00158   offset_call = (INT) ir_b_save_buf (Summary->Get_callsite (0),
00159              size, sizeof(INT64), 0, fl);
00160 
00161   offset_call = offset_call - cur_sec_disp;
00162     }
00163 
00164     if (Summary->Has_actual_entry ()) {
00165   size = (Summary->Get_actual_idx() + 1) * sizeof(SUMMARY_ACTUAL);
00166 
00167   offset_actual = (INT) ir_b_save_buf (Summary->Get_actual (0),
00168                size, sizeof(INT64), 0, fl);
00169 
00170   offset_actual = offset_actual - cur_sec_disp;
00171     }
00172 
00173     if (Summary->Has_expr_entry ()) {
00174   size = (Summary->Get_expr_idx() + 1) * sizeof(SUMMARY_EXPR);
00175 
00176   offset_expr = (INT) ir_b_save_buf (Summary->Get_expr (0),
00177              size, sizeof(INT64), 0, fl);
00178 
00179   offset_expr = offset_expr - cur_sec_disp;
00180     }
00181 
00182     if (Summary->Has_phi_entry ()) {
00183   size = (Summary->Get_phi_idx() + 1) * sizeof(SUMMARY_PHI);
00184 
00185   offset_phi = (INT) ir_b_save_buf (Summary->Get_phi (0),
00186             size, sizeof(INT64), 0, fl);
00187 
00188   offset_phi = offset_phi - cur_sec_disp;
00189     }
00190 
00191     if (Summary->Has_chi_entry ()) {
00192   size = (Summary->Get_chi_idx() + 1) * sizeof(SUMMARY_CHI);
00193 
00194   offset_chi = (INT) ir_b_save_buf (Summary->Get_chi (0),
00195             size, sizeof(INT64), 0, fl);
00196 
00197   offset_chi = offset_chi - cur_sec_disp;
00198     }
00199 
00200     if (Summary->Has_stmt_entry ()) {
00201   size = (Summary->Get_stmt_idx() + 1) * sizeof(SUMMARY_STMT);
00202 
00203   offset_stmt = (INT) ir_b_save_buf (Summary->Get_stmt (0),
00204              size, sizeof(INT64), 0, fl);
00205 
00206   offset_stmt = offset_stmt - cur_sec_disp;
00207     }
00208 
00209     if (Summary->Has_ctrl_dep_entry ()) {
00210   size = (Summary->Get_ctrl_dep_idx() + 1) *
00211       sizeof(SUMMARY_CONTROL_DEPENDENCE);
00212 
00213   offset_ctrl_dep = (INT) ir_b_save_buf (Summary->Get_ctrl_dep (0),
00214              size, sizeof(INT64), 0, fl);
00215 
00216   offset_ctrl_dep = offset_ctrl_dep - cur_sec_disp;
00217     }
00218 
00219     if (Summary->Has_formal_entry ()) {
00220   size = (Summary->Get_formal_idx () + 1) * sizeof(SUMMARY_FORMAL);
00221   
00222   offset_formal = (INT) ir_b_save_buf (Summary->Get_formal (0),
00223                size, sizeof(INT64), 0, fl);
00224 
00225   offset_formal = offset_formal - cur_sec_disp;
00226     } 
00227 
00228     if (Summary->Has_global_entry ()) {
00229   size = (Summary->Get_global_idx () + 1) * sizeof(SUMMARY_GLOBAL);
00230   
00231   offset_global = (INT) ir_b_save_buf (Summary->Get_global (0),
00232                size, sizeof(INT64), 0, fl);
00233 
00234   offset_global = offset_global - cur_sec_disp;
00235     } 
00236 
00237 
00238 
00239     if (Summary->Has_common_entry ()) {
00240   size = (Summary->Get_common_idx () + 1) * sizeof(SUMMARY_COMMON);
00241   
00242   offset_common = (INT) ir_b_save_buf (Summary->Get_common (0),
00243                size, sizeof(INT64), 0, fl);
00244 
00245   offset_common = offset_common - cur_sec_disp;
00246     } 
00247 
00248     if (Summary->Has_common_shape_entry ()) {
00249   size = (Summary->Get_common_shape_idx () + 1) *
00250       sizeof(SUMMARY_COMMON_SHAPE);
00251   
00252   offset_common_shape = (INT)
00253       ir_b_save_buf (Summary->Get_common_shape (0), size,
00254          sizeof(INT64), 0, fl); 
00255 
00256   offset_common_shape = offset_common_shape - cur_sec_disp;
00257     } 
00258 
00259 
00260     if (Summary->Has_global_stid_entry ()) {
00261       size = (Summary->Get_global_stid_idx () + 1) * sizeof(SUMMARY_STID);
00262       
00263       offset_global_stid = (INT) ir_b_save_buf (Summary->Get_global_stid (0),
00264             size, sizeof(INT64), 0, fl);
00265       
00266       offset_global_stid = offset_global_stid - cur_sec_disp;
00267     } 
00268     if (Summary->Has_struct_access_entry ()) {
00269       size = (Summary->Get_struct_access_idx () + 1) * sizeof(SUMMARY_STRUCT_ACCESS);
00270       
00271       offset_struct_access = (INT) ir_b_save_buf (Summary->Get_struct_access (0),
00272             size, sizeof(INT64), 0, fl);
00273       
00274       offset_struct_access = offset_struct_access - cur_sec_disp;
00275     } 
00276 #ifdef KEY
00277     if (Summary->Has_ty_info_entry ()) {
00278       size = (Summary->Get_ty_info_idx () + 1) * sizeof(SUMMARY_TY_INFO);
00279 
00280       offset_ty_info = (INT) ir_b_save_buf (Summary->Get_ty_info (0),
00281                                             size, sizeof(INT64), 0, fl);
00282 
00283       offset_ty_info = offset_ty_info - cur_sec_disp;
00284     } 
00285 #endif
00286 
00287     if (Do_Par)
00288      Array_Summary_Output->Write_summary(fl, cur_sec_disp);
00289     
00290     offset = (INT)ir_b_save_buf(&header, sizeof(SUMMARY_FILE_HEADER),
00291         sizeof(INT64), 0, fl);
00292 
00293     
00294     *(HEADER_ADDR(header_loc)) = offset - cur_sec_disp;
00295     SUMMARY_FILE_HEADER *header_addr = SUMMARY_HEADER_ADDR(offset);
00296 
00297     if (Do_Par) {
00298       Array_Summary_Output->Update_array_sect_header(header_addr);
00299       header_addr->Set_AutoPar();
00300     }
00301     else {
00302       init_array_size_fields(header_addr);
00303     }
00304 
00305     // use opt level to represent that splitting is needed. So set
00306     // it to 3 if Optlevel=3 or Reorg_Common = ON 
00307     // if Reorg_Common is off and Optlevel is 3 then don't set it to 3
00308     if ((Optlevel == 3 && Do_Split_Commons) || (Do_Split_Commons_Set))
00309       Optlevel = 3;
00310     else
00311       Optlevel = 1;
00312 
00313     header_addr->Set_opt_level(Optlevel);
00314     header_addr->Set_version_number(IPA_SUMMARY_REVISION);
00315     header_addr->Set_minor_version_number(IPA_SUMMARY_MINOR_REVISION);
00316     header_addr->Set_symbol_offset(offset_sym);
00317     header_addr->Set_proc_offset(offset_proc);
00318     header_addr->Set_feedback_offset(offset_feedback);
00319     header_addr->Set_callsite_offset(offset_call);
00320     header_addr->Set_actual_offset(offset_actual);
00321     header_addr->Set_value_offset(offset_value);
00322     header_addr->Set_expr_offset(offset_expr);
00323     header_addr->Set_phi_offset(offset_phi);
00324     header_addr->Set_chi_offset(offset_chi);
00325     header_addr->Set_stmt_offset(offset_stmt);
00326     header_addr->Set_ctrl_dep_offset(offset_ctrl_dep);
00327     header_addr->Set_formal_offset(offset_formal);
00328     header_addr->Set_global_offset(offset_global);
00329     header_addr->Set_common_offset(offset_common);
00330     header_addr->Set_common_shape_offset(offset_common_shape);
00331     header_addr->Set_global_stid_offset(offset_global_stid);
00332     header_addr->Set_struct_access_offset(offset_struct_access);
00333 #ifdef KEY
00334     header_addr->Set_ty_info_offset(offset_ty_info);
00335 #endif
00336 
00337     header_addr->Set_symbol_size(Summary->Get_symbol_idx() + 1);
00338     header_addr->Set_proc_size(Summary->Get_procedure_idx() + 1);
00339     header_addr->Set_feedback_size(Summary->Get_feedback_idx() + 1);
00340     header_addr->Set_callsite_size(Summary->Get_callsite_idx() + 1);
00341     header_addr->Set_actual_size(Summary->Get_actual_idx() + 1);
00342     header_addr->Set_value_size(Summary->Get_value_idx() + 1);
00343     header_addr->Set_expr_size(Summary->Get_expr_idx() + 1);
00344     header_addr->Set_phi_size(Summary->Get_phi_idx() + 1);
00345     header_addr->Set_chi_size(Summary->Get_chi_idx() + 1);
00346     header_addr->Set_stmt_size(Summary->Get_stmt_idx() + 1);
00347     header_addr->Set_ctrl_dep_size(Summary->Get_ctrl_dep_idx() + 1);
00348     header_addr->Set_formal_size(Summary->Get_formal_idx() + 1);
00349     header_addr->Set_global_size(Summary->Get_global_idx() + 1);
00350     header_addr->Set_common_size(Summary->Get_common_idx() + 1);
00351     header_addr->Set_common_shape_size(Summary->Get_common_shape_idx() + 1);
00352     header_addr->Set_global_stid_size(Summary->Get_global_stid_idx() + 1);
00353   header_addr->Set_struct_access_size(Summary->Get_struct_access_idx() + 1);
00354 #ifdef KEY
00355     header_addr->Set_ty_info_size(Summary->Get_ty_info_idx() + 1);
00356 #endif
00357  
00358     header_addr->Set_symbol_entry_size(sizeof(SUMMARY_SYMBOL));
00359     header_addr->Set_proc_entry_size(sizeof(SUMMARY_PROCEDURE));
00360     header_addr->Set_feedback_entry_size(sizeof(SUMMARY_FEEDBACK));
00361     header_addr->Set_callsite_entry_size(sizeof(SUMMARY_CALLSITE));
00362     header_addr->Set_actual_entry_size(sizeof(SUMMARY_ACTUAL));
00363     header_addr->Set_value_entry_size(sizeof(SUMMARY_VALUE));
00364     header_addr->Set_expr_entry_size(sizeof(SUMMARY_EXPR));
00365     header_addr->Set_phi_entry_size(sizeof(SUMMARY_PHI));
00366     header_addr->Set_chi_entry_size(sizeof(SUMMARY_CHI));
00367     header_addr->Set_stmt_entry_size(sizeof(SUMMARY_STMT));
00368     header_addr->Set_ctrl_dep_entry_size(sizeof(SUMMARY_CONTROL_DEPENDENCE));
00369     header_addr->Set_formal_entry_size(sizeof(SUMMARY_FORMAL));
00370     header_addr->Set_global_entry_size(sizeof(SUMMARY_GLOBAL));
00371     header_addr->Set_common_entry_size(sizeof(SUMMARY_COMMON));
00372     header_addr->Set_common_shape_entry_size(sizeof(SUMMARY_COMMON_SHAPE));
00373     header_addr->Set_common_shape_entry_size(sizeof(SUMMARY_COMMON_SHAPE));
00374     header_addr->Set_global_stid_entry_size(sizeof(SUMMARY_STID));
00375     header_addr->Set_struct_access_entry_size(sizeof(SUMMARY_STRUCT_ACCESS));
00376 #ifdef KEY
00377     header_addr->Set_ty_info_entry_size(sizeof(SUMMARY_TY_INFO));
00378 #endif
00379 }
00380 
00381 
00382 void
00383 IPA_Trace_Summary_Section (FILE *f,   // File to trace to
00384          const void *sbase,
00385          DYN_ARRAY<char*>* symbol_names, 
00386          DYN_ARRAY<char*>* function_names)  
00387            // Handle for section
00388 {
00389     SUMMARY_FILE_HEADER *file_header;
00390     SUMMARY_SYMBOL *sym_array;
00391     SUMMARY_PROCEDURE  *proc_array;
00392     SUMMARY_FEEDBACK *feedback_array;
00393     SUMMARY_CALLSITE *callsite_array;
00394     SUMMARY_VALUE *value_array;
00395     SUMMARY_EXPR *expr_array;
00396     SUMMARY_PHI *phi_array;
00397     SUMMARY_CHI *chi_array;
00398     SUMMARY_STMT *stmt_array;
00399     SUMMARY_CONTROL_DEPENDENCE *ctrl_dep_array;
00400     SUMMARY_FORMAL *formal_array;
00401     SUMMARY_ACTUAL *actual_array;
00402     SUMMARY_GLOBAL *global_array;
00403     SUMMARY_STID *global_stid_array;
00404     SUMMARY_COMMON *common_array;
00405     SUMMARY_COMMON_SHAPE *common_shape_array;
00406     SUMMARY_STRUCT_ACCESS * struct_access_array;
00407 #ifdef KEY
00408     SUMMARY_TY_INFO * ty_info_array;
00409 #endif
00410 
00411     ARRAY_SUMMARY_OUTPUT array_summary(Malloc_Mem_Pool);
00412 
00413     const char *section_base = (char *)sbase;
00414 
00415     Elf64_Word* offset = (Elf64_Word*)section_base;
00416 
00417     file_header = (SUMMARY_FILE_HEADER*)(section_base + *offset);
00418     
00419     if (file_header == 0)
00420   return;
00421 
00422     fprintf ( (FILE *)f, "IPA SUMMARY REVISION -- %d.%d \n\n", 
00423     file_header->Get_version_number(), file_header->Get_minor_version_number() );
00424 
00425     fprintf ( (FILE*)f, "OPT LEVEL-- O%d \n", file_header->Get_opt_level() );
00426 
00427     fprintf (f, "      Summary type        offset             size\n\n");
00428 
00429     const char * const format = "%-24s 0x%06x   0x%06x * %-5d\t= 0x%08x\n";
00430 
00431     if (file_header->Get_symbol_size () != 0)
00432   fprintf (f, format, "SYMBOL",
00433      file_header->Get_symbol_offset (),
00434      file_header->Get_symbol_entry_size (),
00435      file_header->Get_symbol_size(),
00436      file_header->Get_symbol_entry_size () *
00437      file_header->Get_symbol_size ());
00438     
00439     if (file_header->Get_proc_size ())
00440   fprintf (f, format, "PROCEDURE",
00441      file_header->Get_proc_offset (),
00442      file_header->Get_proc_entry_size (),
00443      file_header->Get_proc_size(),
00444      file_header->Get_proc_entry_size () *
00445      file_header->Get_proc_size ());
00446     
00447     if (file_header->Get_feedback_size ())
00448   fprintf (f, format, "FEEDBACK",
00449      file_header->Get_feedback_offset (),
00450      file_header->Get_feedback_entry_size (),
00451      file_header->Get_feedback_size(),
00452      file_header->Get_feedback_entry_size () *
00453      file_header->Get_feedback_size ());
00454     
00455     if (file_header->Get_callsite_size ())
00456   fprintf (f, format, "CALLSITE",
00457      file_header->Get_callsite_offset (),
00458      file_header->Get_callsite_entry_size (),
00459      file_header->Get_callsite_size(),
00460      file_header->Get_callsite_entry_size () *
00461      file_header->Get_callsite_size ());
00462     
00463     if (file_header->Get_stmt_size ())
00464   fprintf (f, format, "STMT",
00465      file_header->Get_stmt_offset (),
00466      file_header->Get_stmt_entry_size (),
00467      file_header->Get_stmt_size(),
00468      file_header->Get_stmt_entry_size () *
00469      file_header->Get_stmt_size ());
00470     
00471     if (file_header->Get_ctrl_dep_size ())
00472   fprintf (f, format, "CTRL_DEP",
00473      file_header->Get_ctrl_dep_offset (),
00474      file_header->Get_ctrl_dep_entry_size (),
00475      file_header->Get_ctrl_dep_size(),
00476      file_header->Get_ctrl_dep_entry_size () *
00477      file_header->Get_ctrl_dep_size ());
00478     
00479     if (file_header->Get_formal_size ())
00480   fprintf (f, format, "FORMAL",
00481      file_header->Get_formal_offset (),
00482      file_header->Get_formal_entry_size (),
00483      file_header->Get_formal_size(),
00484      file_header->Get_formal_entry_size () *
00485      file_header->Get_formal_size ());
00486     
00487     if (file_header->Get_actual_size ())
00488   fprintf (f, format, "ACTUAL",
00489      file_header->Get_actual_offset (),
00490      file_header->Get_actual_entry_size (),
00491      file_header->Get_actual_size(),
00492      file_header->Get_actual_entry_size () *
00493      file_header->Get_actual_size ());
00494     
00495     if (file_header->Get_value_size ())
00496   fprintf (f, format, "VALUE",
00497      file_header->Get_value_offset (),
00498      file_header->Get_value_entry_size (),
00499      file_header->Get_value_size(),
00500      file_header->Get_value_entry_size () *
00501      file_header->Get_value_size ());
00502     
00503     if (file_header->Get_expr_size ())
00504   fprintf (f, format, "EXPR",
00505      file_header->Get_expr_offset (),
00506      file_header->Get_expr_entry_size (),
00507      file_header->Get_expr_size(),
00508      file_header->Get_expr_entry_size () *
00509      file_header->Get_expr_size ());
00510     
00511     if (file_header->Get_phi_size ())
00512   fprintf (f, format, "PHI",
00513      file_header->Get_phi_offset (),
00514      file_header->Get_phi_entry_size (),
00515      file_header->Get_phi_size(),
00516      file_header->Get_phi_entry_size () *
00517      file_header->Get_phi_size ());
00518     
00519     if (file_header->Get_chi_size ())
00520   fprintf (f, format, "CHI",
00521      file_header->Get_chi_offset (),
00522      file_header->Get_chi_entry_size (),
00523      file_header->Get_chi_size(),
00524      file_header->Get_chi_entry_size () *
00525      file_header->Get_chi_size ());
00526     
00527     if (file_header->Get_global_size ())
00528   fprintf (f, format, "GLOBAL",
00529      file_header->Get_global_offset (),
00530      file_header->Get_global_entry_size (),
00531      file_header->Get_global_size(),
00532      file_header->Get_global_entry_size () *
00533      file_header->Get_global_size ());
00534     
00535     if (file_header->Get_common_size ())
00536   fprintf (f, format, "COMMON",
00537      file_header->Get_common_offset (),
00538      file_header->Get_common_entry_size (),
00539      file_header->Get_common_size(),
00540      file_header->Get_common_entry_size () *
00541      file_header->Get_common_size ());
00542     
00543     if (file_header->Get_common_shape_size ())
00544   fprintf (f, format, "COMMON_SHAPE",
00545      file_header->Get_common_shape_offset (),
00546      file_header->Get_common_shape_entry_size (),
00547      file_header->Get_common_shape_size(),
00548      file_header->Get_common_shape_entry_size () *
00549      file_header->Get_common_shape_size ());
00550 
00551     if (file_header->Get_global_stid_size ())
00552   fprintf (f, format, "GLOBAL_STID",
00553      file_header->Get_global_stid_offset (),
00554      file_header->Get_global_stid_entry_size (),
00555      file_header->Get_global_stid_size(),
00556      file_header->Get_global_stid_entry_size () *
00557      file_header->Get_global_stid_size ());
00558     
00559     if (file_header->Get_scalar_node_size ())
00560   fprintf (f, format, "SCALAR_NODE",
00561      file_header->Get_scalar_offset (),
00562      file_header->Get_scalar_node_entry_size (),
00563      file_header->Get_scalar_node_size(),
00564      file_header->Get_scalar_node_entry_size () *
00565      file_header->Get_scalar_node_size ());
00566     
00567     if (file_header->Get_cfg_node_size ())
00568   fprintf (f, format, "CFG_NODE",
00569      file_header->Get_cfg_node_offset (),
00570      file_header->Get_cfg_node_entry_size (),
00571      file_header->Get_cfg_node_size(),
00572      file_header->Get_cfg_node_entry_size () *
00573      file_header->Get_cfg_node_size ());
00574     
00575     if (file_header->Get_regions_array_size ())
00576   fprintf (f, format, "REGIONS_ARRAY",
00577      file_header->Get_regions_array_offset (),
00578      file_header->Get_regions_array_entry_size (),
00579      file_header->Get_regions_array_size(),
00580      file_header->Get_regions_array_entry_size () *
00581      file_header->Get_regions_array_size ());
00582     
00583     if (file_header->Get_projected_region_size ())
00584   fprintf (f, format, "PROJECTED_REGION",
00585      file_header->Get_projected_region_offset (),
00586      file_header->Get_projected_region_entry_size (),
00587      file_header->Get_projected_region_size(),
00588      file_header->Get_projected_region_entry_size () *
00589      file_header->Get_projected_region_size ());
00590     
00591     if (file_header->Get_projected_array_size ())
00592   fprintf (f, format, "PROJECTED_ARRAY",
00593      file_header->Get_projected_array_offset (),
00594      file_header->Get_projected_array_entry_size (),
00595      file_header->Get_projected_array_size(),
00596      file_header->Get_projected_array_entry_size () *
00597      file_header->Get_projected_array_size ());
00598     
00599     if (file_header->Get_term_array_size ())
00600   fprintf (f, format, "TERM_ARRAY",
00601      file_header->Get_term_array_offset (),
00602      file_header->Get_term_array_entry_size (),
00603      file_header->Get_term_array_size(),
00604      file_header->Get_term_array_entry_size () *
00605      file_header->Get_term_array_size ());
00606     
00607     if (file_header->Get_ivar_size ())
00608   fprintf (f, format, "IVAR",
00609      file_header->Get_ivar_offset (),
00610      file_header->Get_ivar_entry_size (),
00611      file_header->Get_ivar_size(),
00612      file_header->Get_ivar_entry_size () *
00613      file_header->Get_ivar_size ());
00614     
00615     if (file_header->Get_loopinfo_size ())
00616   fprintf (f, format, "LOOPINFO",
00617      file_header->Get_loopinfo_offset (),
00618      file_header->Get_loopinfo_entry_size (),
00619      file_header->Get_loopinfo_size(),
00620      file_header->Get_loopinfo_entry_size () *
00621      file_header->Get_loopinfo_size ());
00622     if (file_header->Get_struct_access_size () != 0)
00623   fprintf (f, format, "FLD_ACCESS",
00624      file_header->Get_struct_access_offset (),
00625      file_header->Get_struct_access_entry_size (),
00626      file_header->Get_struct_access_size(),
00627      file_header->Get_struct_access_entry_size () *
00628      file_header->Get_struct_access_size ());
00629 #ifdef KEY
00630     if (file_header->Get_ty_info_size () != 0)
00631   fprintf (f, format, "TY_INFO",
00632      file_header->Get_ty_info_offset (),
00633      file_header->Get_ty_info_entry_size (),
00634      file_header->Get_ty_info_size(),
00635      file_header->Get_ty_info_entry_size () *
00636      file_header->Get_ty_info_size ());
00637 #endif
00638     
00639     if (file_header->Get_symbol_size() != 0) {
00640   sym_array = (SUMMARY_SYMBOL *)
00641       (section_base + file_header->Get_symbol_offset());
00642   Ipl_Summary_Symbol = sym_array;
00643   sym_array->Print_array ( f, file_header->Get_symbol_size(),
00644           symbol_names, function_names );
00645 
00646     }
00647 
00648     if (file_header->Get_proc_size() != 0) {
00649   proc_array =  (SUMMARY_PROCEDURE *)
00650       (section_base + file_header->Get_proc_offset());
00651   proc_array->Print_array ( f, file_header->Get_proc_size() );
00652     }
00653 
00654     if (file_header->Get_feedback_size() != 0) {
00655   feedback_array =  (SUMMARY_FEEDBACK *)
00656       (section_base + file_header->Get_feedback_offset());
00657   feedback_array->Print_array ( f, file_header->Get_feedback_size() );
00658     }
00659 
00660     if (file_header->Get_callsite_size() != 0) {
00661   callsite_array = (SUMMARY_CALLSITE*)
00662       (section_base + file_header->Get_callsite_offset()); 
00663   callsite_array->Print_array (f, file_header->Get_callsite_size());
00664     }
00665 
00666     if (file_header->Get_actual_size() != 0) {
00667   actual_array = (SUMMARY_ACTUAL *)
00668       (section_base + file_header->Get_actual_offset());  
00669   actual_array->Print_array ( f, file_header->Get_actual_size() );
00670     }
00671 
00672     if (file_header->Get_value_size() != 0) {
00673   value_array = (SUMMARY_VALUE *) (section_base +
00674            file_header->Get_value_offset());  
00675   value_array->Print_array ( f, file_header->Get_value_size() );
00676     }
00677 
00678     if (file_header->Get_expr_size() != 0) {
00679   expr_array = (SUMMARY_EXPR *) (section_base +
00680                file_header->Get_expr_offset());  
00681   expr_array->Print_array ( f, file_header->Get_expr_size() );
00682     }
00683 
00684     if (file_header->Get_phi_size() != 0) {
00685   phi_array = (SUMMARY_PHI *) (section_base +
00686              file_header->Get_phi_offset());  
00687   phi_array->Print_array ( f, file_header->Get_phi_size() );
00688     }
00689 
00690     if (file_header->Get_chi_size() != 0) {
00691   chi_array = (SUMMARY_CHI *) (section_base +
00692              file_header->Get_chi_offset());  
00693   chi_array->Print_array ( f, file_header->Get_chi_size() );
00694     }
00695 
00696     if (file_header->Get_stmt_size() != 0) {
00697   stmt_array = (SUMMARY_STMT *) (section_base +
00698                file_header->Get_stmt_offset());  
00699   stmt_array->Print_array ( f, file_header->Get_stmt_size() );
00700     }
00701 
00702     if (file_header->Get_ctrl_dep_size() != 0) {
00703   ctrl_dep_array = (SUMMARY_CONTROL_DEPENDENCE *)
00704       (section_base + file_header->Get_ctrl_dep_offset());  
00705   ctrl_dep_array->Print_array ( f, file_header->Get_ctrl_dep_size() );
00706     }
00707 
00708     if (file_header->Get_formal_size() != 0) {
00709   formal_array = (SUMMARY_FORMAL *) (section_base +
00710              file_header->Get_formal_offset()); 
00711   formal_array->Print_array ( f, file_header->Get_formal_size() );
00712     }
00713 
00714     if (file_header->Get_global_size() != 0) {
00715   global_array = (SUMMARY_GLOBAL *)
00716       (section_base + file_header->Get_global_offset());
00717   global_array->Print_array ( f, file_header->Get_global_size() );
00718     }
00719 
00720     if (file_header->Get_global_stid_size() != 0) {
00721       global_stid_array = (SUMMARY_STID *)
00722   (section_base + file_header->Get_global_stid_offset());
00723       global_stid_array->Print_array ( f, file_header->Get_global_stid_size() );
00724     }
00725 
00726     if (file_header->Get_common_size() != 0) {
00727   common_array = (SUMMARY_COMMON *)
00728       (section_base + file_header->Get_common_offset());
00729   common_array->Print_array ( f, file_header->Get_common_size() );
00730     }
00731 
00732     if (file_header->Get_common_shape_size() != 0) {
00733   common_shape_array = (SUMMARY_COMMON_SHAPE *)
00734       (section_base + file_header->Get_common_shape_offset());
00735   common_shape_array->Print_array(f,
00736           file_header->Get_common_shape_size() );
00737 
00738     }
00739     if (file_header->Get_struct_access_size() != 0) {
00740   struct_access_array =  (SUMMARY_STRUCT_ACCESS *)
00741       (section_base + file_header->Get_struct_access_offset());
00742   struct_access_array->Print_array ( f, file_header->Get_struct_access_size() );
00743     }    
00744 #ifdef KEY
00745     if (file_header->Get_ty_info_size() != 0) {
00746   ty_info_array =  (SUMMARY_TY_INFO *)
00747       (section_base + file_header->Get_ty_info_offset());
00748   ty_info_array->Print_array ( f, file_header->Get_ty_info_size() );
00749     }
00750 #endif
00751     
00752     array_summary.Trace(f, sbase);
00753 }
00754 
00755 
00756 
00757 //---------------------------------------------------------------
00758 // Higher-level interface for ipl to trace summary info.
00759 //---------------------------------------------------------------
00760 
00761 void
00762 IPA_Trace_Summary_File (FILE *f, 
00763             Output_File *fl, 
00764       BOOL verbose,
00765       DYN_ARRAY<char*>* symbol_names,
00766       DYN_ARRAY<char*>* function_names)
00767 {
00768   Section *section = NULL;
00769   INT i;
00770 
00771   // Find the IPA summary section
00772   for (i = 0; i < fl->num_of_section; i++) {
00773     if ((fl->section_list[i].shdr.sh_info == WT_IPA_SUMMARY) &&
00774         (strcmp (fl->section_list[i].name, MIPS_WHIRL_SUMMARY) == 0)) {
00775       section = fl->section_list + i;
00776       break;
00777     }
00778   }
00779 
00780   if ( verbose ) {
00781     fprintf ( (FILE *)f, "TRACING SUMMARY INFORMATION \n" );
00782   }
00783 
00784   if (section == NULL) {
00785     fprintf ( (FILE *)f, "--- Empty summary section ---\n" );
00786   }
00787   else {
00788     char *summary_base = (char *)(fl->map_addr + section->shdr.sh_offset);
00789     IPA_Trace_Summary_Section ( f, summary_base, symbol_names, function_names );
00790   }
00791 }
00792 
00793 
00794 // ----------------------------------------------------------------
00795 // Print summary info arrays: similar to IPA_Trace_Summary_Section, 
00796 // but has simpler interface and doesn't print header info.
00797 // ----------------------------------------------------------------
00798 template<>
00799 void 
00800 SUMMARIZE<IPL>::Trace(FILE* fp)
00801 {
00802   if (Has_symbol_entry()) {
00803     Ipl_Summary_Symbol = Get_symbol(0);
00804     Ipl_Summary_Symbol->Print_array(fp, Get_symbol_idx()+1);
00805   }
00806 
00807   if (Has_procedure_entry())
00808     Get_procedure(0)->Print_array(fp, Get_procedure_idx()+1);
00809   
00810   if (Has_callsite_entry())
00811     Get_callsite(0)->Print_array(fp, Get_callsite_idx()+1);
00812 
00813   if (Has_feedback_entry())
00814     Get_feedback(0)->Print_array(fp, Get_feedback_idx()+1);
00815 
00816   if (Has_actual_entry())
00817     Get_actual(0)->Print_array(fp, Get_actual_idx()+1);
00818   
00819   if (Has_value_entry())
00820     Get_value(0)->Print_array(fp, Get_value_idx()+1);
00821 
00822   if (Has_expr_entry())
00823     Get_expr(0)->Print_array(fp, Get_expr_idx()+1);
00824   
00825   if (Has_phi_entry())
00826     Get_phi(0)->Print_array(fp, Get_phi_idx()+1);
00827 
00828   if (Has_chi_entry())
00829     Get_chi(0)->Print_array(fp, Get_chi_idx()+1);
00830   
00831   if (Has_stmt_entry())
00832     Get_stmt(0)->Print_array(fp, Get_stmt_idx()+1);
00833 
00834   if (Has_ctrl_dep_entry())
00835     Get_ctrl_dep(0)->Print_array(fp, Get_ctrl_dep_idx()+1);
00836 
00837   if (Has_formal_entry())
00838     Get_formal(0)->Print_array(fp, Get_formal_idx()+1);
00839   
00840   if (Has_global_entry())
00841     Get_global(0)->Print_array(fp, Get_global_idx()+1);
00842 
00843   if (Has_global_stid_entry())
00844     Get_global_stid(0)->Print_array(fp, Get_global_stid_idx()+1);
00845 
00846   if (Has_common_entry())
00847     Get_common(0)->Print_array(fp, Get_common_idx()+1);
00848 
00849   if (Has_common_shape_entry())
00850     Get_common_shape(0)->Print_array(fp, Get_common_shape_idx()+1);
00851   if (Has_struct_access_entry())
00852     Get_struct_access(0)->Print_array(fp, Get_struct_access_idx()+1);
00853 #ifdef KEY
00854   if (Has_ty_info_entry())
00855     Get_ty_info(0)->Print_array(fp, Get_ty_info_idx()+1);
00856 #endif
00857   
00858 }
00859 
00860
osprey/ipa/local/ipl_bread_write.cxx
