Open64: osprey/ipa/common/ipc

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 #ifndef ipc_file_INCLUDED
00042 #define ipc_file_INCLUDED
00043 
00044 #ifndef symtab_INCLUDED
00045 #include "symtab.h"     // for FILE_INFO
00046 #endif
00047 
00048 #ifndef dwarf_DST_mem_INCLUDED
00049 #define USE_DST_INTERNALS
00050 #include "dwarf_DST_mem.h"
00051 #endif
00052 
00053 // forward declaration
00054 
00055 class SUMMARY_FILE_HEADER;    // see ipl_summary.h
00056 class IPC_GLOBAL_IDX_MAP;   // see ipc_symtab_merge.h
00057 
00058 /* 
00059    ipa state information is related to whirl tree nodes and local symbol
00060    tables. If a whirl tree is read in and modified as a side effect of
00061    the read process, then the flag is set to IPA_MODIFIED. Originally,
00062    everything is set to IPA_ORIG. When a whirl tree node or local
00063    symbol table is written out to the temporary file then the flag
00064    is set to IPA_WRITTEN
00065 */
00066 
00067 enum IPA_STATE_TYPE {
00068     IPA_ORIG = 1,
00069     IPA_MODIFIED = 2,
00070     IPA_WRITTEN = 3,
00071     IPA_UNUSED = 4,       /* to be deleted */
00072     IPA_DELETED = 5       /* already deleted */
00073 };
00074 
00075 struct IP_PROC_INFO {
00076 
00077     IPA_STATE_TYPE state;
00078     struct pu_info *info;
00079     
00080 };
00081 
00082 inline IPA_STATE_TYPE
00083 IP_PROC_INFO_state (const IP_PROC_INFO& proc)
00084 {
00085     return proc.state;
00086 }
00087 inline void
00088 Set_IP_PROC_INFO_state (IP_PROC_INFO& proc, IPA_STATE_TYPE st)
00089 {
00090     proc.state = st;
00091 }
00092 
00093 inline struct pu_info *
00094 IP_PROC_INFO_pu_info (const IP_PROC_INFO& proc) {
00095     return proc.info;
00096 }
00097 
00098 inline void
00099 Set_IP_PROC_INFO_pu_info (IP_PROC_INFO& proc, struct pu_info *pu)
00100 {
00101     proc.info = pu;
00102 }
00103 
00104 class SECTION_FILE_ANNOT;
00105 
00106 // Flags for IP_FILE_HDR
00107 #define FILE_HAS_NESTED_PU  0x00000001  // File contains nested PU
00108 
00109 struct IP_FILE_HDR
00110 {
00111     void *input_map_addr;
00112     const char *file_name;    // input file name.
00113                                         // There is no unique output name.
00114 
00115     IP_PROC_INFO *proc_info;    // array of procedure info
00116     UINT32 max_size;      // max size of the proc_info array
00117     struct pu_info *pu_list;    // pu list from the whirl file header
00118     struct pu_info *new_pu_list;  // new PUs added during IPA
00119     UINT32 num_procs;     // number of procedures in file
00120     UINT32 num_procs_processed;   // number of procedures processed
00121     UINT32 num_written;                 // number of Pus written back to disk
00122 
00123     MEM_POOL mem_pool;      // file mem pool (kept till written)
00124 
00125     // symbol table related
00126     FILE_INFO file_info;    // file scope symtab attributes
00127     DST_TYPE dst;                       // The debug symbol table.
00128     char *summary;      // section base of summary info
00129     SUMMARY_FILE_HEADER *file_header; // header for the summary info
00130     const IPC_GLOBAL_IDX_MAP *idx_maps; // maps for merged global symtab
00131 
00132     SECTION_FILE_ANNOT* section_annot;  // per file section info
00133     UINT32 flags;     // Special flags for this file
00134     off_t mapped_size;                  // Size of mmap memory size.
00135 
00136     // constructor
00137 
00138     IP_FILE_HDR (const char *name, void *mmap_addr, off_t mmap_size) {
00139   BZERO (this, sizeof(IP_FILE_HDR));
00140   file_name = name;
00141   input_map_addr = mmap_addr;
00142   MEM_POOL_Initialize (&mem_pool, const_cast<char *> (file_name),
00143            FALSE /* non-zero mempool */);
00144   MEM_POOL_Push (&mem_pool);
00145     }
00146 
00147 
00148 }; // IP_FILE_HDR
00149 
00150 // access functions for IP_FILE_HDR
00151 
00152 // Returns number of PUs with a given state.  This is O(num_procs),
00153 // and is used only for debugging.
00154 UINT32 IP_FILE_HDR_PUs_in_state(const IP_FILE_HDR& hdr, IPA_STATE_TYPE state);
00155 
00156 inline void *
00157 IP_FILE_HDR_input_map_addr (const IP_FILE_HDR& hdr) {
00158     return hdr.input_map_addr;
00159 }
00160 inline void
00161 Set_IP_FILE_HDR_input_map_addr (IP_FILE_HDR& hdr, void* base) {
00162     hdr.input_map_addr = base;
00163 }
00164 
00165 inline const char *
00166 IP_FILE_HDR_file_name (const IP_FILE_HDR& hdr) {
00167     return hdr.file_name;
00168 }
00169 inline void
00170 Set_IP_FILE_HDR_file_name (IP_FILE_HDR& hdr, const char* name) {
00171     hdr.file_name = name;
00172 }
00173 
00174 inline IP_PROC_INFO *
00175 IP_FILE_HDR_proc_info (const IP_FILE_HDR& hdr) {
00176     return hdr.proc_info;
00177 }
00178 inline void
00179 Set_IP_FILE_HDR_proc_info (IP_FILE_HDR& hdr, IP_PROC_INFO *p) {
00180     hdr.proc_info = p;
00181 }
00182 
00183 inline UINT32
00184 IP_FILE_HDR_max_size (const IP_FILE_HDR& hdr) {
00185     return hdr.max_size;
00186 }
00187 inline void
00188 Set_IP_FILE_HDR_max_size (IP_FILE_HDR& hdr, UINT32 size) {
00189     hdr.max_size = size;
00190 }
00191 
00192 inline struct pu_info *
00193 IP_FILE_HDR_pu_list (const IP_FILE_HDR& hdr) {
00194     return hdr.pu_list;
00195 }
00196 
00197 inline void
00198 Set_IP_FILE_HDR_pu_list (IP_FILE_HDR& hdr, struct pu_info* pu)
00199 {
00200     hdr.pu_list = pu;
00201 }
00202 
00203 inline struct pu_info *
00204 IP_FILE_HDR_new_pu_list (const IP_FILE_HDR& hdr) {
00205     return hdr.new_pu_list;
00206 }
00207 inline void
00208 Set_IP_FILE_HDR_new_pu_list (IP_FILE_HDR& hdr, struct pu_info* pu)
00209 {
00210     hdr.new_pu_list = pu;
00211 }
00212 
00213 inline UINT32
00214 IP_FILE_HDR_num_procs (const IP_FILE_HDR& hdr) {
00215 #if 0
00216     Is_True(hdr.num_procs ==
00217             IP_FILE_HDR_PUs_in_state(hdr, IPA_ORIG) +
00218             IP_FILE_HDR_PUs_in_state(hdr, IPA_MODIFIED) +
00219             IP_FILE_HDR_PUs_in_state(hdr, IPA_WRITTEN) +
00220             IP_FILE_HDR_PUs_in_state(hdr, IPA_UNUSED) +
00221             IP_FILE_HDR_PUs_in_state(hdr, IPA_DELETED),
00222             ("File header %s has inconsistent proc count %s",
00223              hdr.file_name, hdr.num_procs));
00224 #endif
00225     return hdr.num_procs;
00226 }
00227 inline void
00228 Set_IP_FILE_HDR_num_procs (IP_FILE_HDR& hdr, UINT32 num) {
00229     hdr.num_procs = num;
00230 }
00231 inline void
00232 Inc_IP_FILE_HDR_num_procs (IP_FILE_HDR& hdr) {
00233     ++hdr.num_procs;
00234 }
00235 
00236 inline UINT32
00237 IP_FILE_HDR_num_procs_processed (const IP_FILE_HDR& hdr) {
00238 #if 0
00239     Is_True(hdr.num_procs_processed ==
00240             IP_FILE_HDR_PUs_in_state(hdr, IPA_WRITTEN) +
00241             IP_FILE_HDR_PUs_in_state(hdr, IPA_DELETED),
00242             ("File hdr %s has inconsistent processed count %d, should be %d",
00243              hdr.file_name,
00244              hdr.num_procs_processed,
00245              IP_FILE_HDR_PUs_in_state(hdr, IPA_WRITTEN) +
00246              IP_FILE_HDR_PUs_in_state(hdr, IPA_DELETED)));
00247 #endif
00248     return hdr.num_procs_processed;
00249 }
00250 
00251 // Precondition: the PU that has been processed must be flagged as
00252 // WRITTEN or DELETED before this function is called.  Postcondition:
00253 // number of num_procs_proccessed equals number in state WRITTEN plus
00254 // number in state DELETED, and this is less than or equal to total
00255 // number in the file.
00256 inline void
00257 Inc_IP_FILE_HDR_num_procs_processed (IP_FILE_HDR& hdr) {
00258     ++(hdr.num_procs_processed);
00259     Is_True(hdr.num_procs_processed <= hdr.num_procs,
00260             ("File header %s has %u procs, %u processed",
00261              hdr.file_name,
00262              hdr.num_procs,
00263              hdr.num_procs_processed));
00264     Is_True(hdr.num_procs_processed ==
00265             IP_FILE_HDR_PUs_in_state(hdr, IPA_WRITTEN) +
00266             IP_FILE_HDR_PUs_in_state(hdr, IPA_DELETED),
00267             ("File hdr %s has inconsistent processed count %d, should be %d",
00268              hdr.file_name,
00269              hdr.num_procs_processed,
00270              IP_FILE_HDR_PUs_in_state(hdr, IPA_WRITTEN) +
00271              IP_FILE_HDR_PUs_in_state(hdr, IPA_DELETED)));
00272 }
00273 
00274 // Returns true if all PUs in the file have been written or deleted.
00275 inline bool 
00276 IP_FILE_HDR_all_procs_processed (const IP_FILE_HDR& hdr) {
00277   return IP_FILE_HDR_num_procs(hdr) == IP_FILE_HDR_num_procs_processed(hdr);
00278 }
00279 
00280 inline MEM_POOL *
00281 IP_FILE_HDR_mem_pool (const IP_FILE_HDR& hdr) {
00282     return const_cast<MEM_POOL*>(&hdr.mem_pool);
00283 }
00284 inline void
00285 Set_IP_FILE_HDR_mem_pool (IP_FILE_HDR& hdr, MEM_POOL& m) {
00286     hdr.mem_pool = m;
00287 }
00288 
00289 inline FILE_INFO &
00290 IP_FILE_HDR_file_info (IP_FILE_HDR& hdr) {
00291     return hdr.file_info;
00292 }
00293 
00294 inline void
00295 Set_IP_FILE_HDR_file_info (IP_FILE_HDR& hdr, FILE_INFO& file_info) {
00296     hdr.file_info = file_info;
00297 }
00298 
00299 inline DST_TYPE IP_FILE_HDR_dst(const IP_FILE_HDR& h) {
00300   return h.dst;
00301 }
00302 
00303 inline void Set_IP_FILE_HDR_dst(IP_FILE_HDR& h, DST_TYPE dst) {
00304   h.dst = dst;
00305 }
00306 
00307 inline char *
00308 IP_FILE_HDR_summary (const IP_FILE_HDR& hdr) {
00309     return hdr.summary;
00310 }
00311 inline void
00312 Set_IP_FILE_HDR_summary (IP_FILE_HDR& hdr, char *sum) {
00313     hdr.summary = sum;
00314 }
00315     
00316 inline SUMMARY_FILE_HEADER *
00317 IP_FILE_HDR_file_header (const IP_FILE_HDR& hdr) {
00318     return hdr.file_header;
00319 }
00320 inline void
00321 Set_IP_FILE_HDR_file_header (IP_FILE_HDR& hdr, SUMMARY_FILE_HEADER *f_hdr)
00322 {
00323     hdr.file_header = f_hdr;
00324 }
00325 
00326 inline const IPC_GLOBAL_IDX_MAP*
00327 IP_FILE_HDR_idx_maps (const IP_FILE_HDR& hdr)
00328 {
00329     return hdr.idx_maps;
00330 }
00331 
00332 inline void
00333 Set_IP_FILE_HDR_idx_maps (IP_FILE_HDR& hdr, const IPC_GLOBAL_IDX_MAP* maps)
00334 {
00335     hdr.idx_maps = maps;
00336 }
00337 
00338 inline SECTION_FILE_ANNOT*
00339 IP_FILE_HDR_section_annot (const IP_FILE_HDR& hdr) {
00340     return hdr.section_annot;
00341 }
00342 
00343 inline void
00344 Set_IP_FILE_HDR_section_annot (IP_FILE_HDR& hdr, SECTION_FILE_ANNOT* annot) {
00345     hdr.section_annot = annot;
00346 }
00347 
00348 inline BOOL
00349 IP_FILE_HDR_has_nested_pu (IP_FILE_HDR& hdr) {
00350     return (hdr.flags & FILE_HAS_NESTED_PU);
00351 }
00352 
00353 inline void
00354 Set_IP_FILE_HDR_has_nested_pu (IP_FILE_HDR& hdr) {
00355     hdr.flags |= FILE_HAS_NESTED_PU;
00356 }
00357 
00358 typedef SEGMENTED_ARRAY<IP_FILE_HDR, 32> IP_FILE_HDR_TABLE;
00359 extern IP_FILE_HDR_TABLE IP_File_header; 
00360 
00361 
00362 extern IP_FILE_HDR &
00363 Setup_File_Header (const char *file_name, void *mmap_addr, off_t);
00364 
00365 // Reclaims all of the resources associated with hdr, by destroying
00366 // its mempool.  Precondition: all PUs have been processed.
00367 void Destroy_File_Header(IP_FILE_HDR& hdr);
00368 
00369 // Used for adding PUs to IP_FILE_HDR during cloning
00370 extern struct pu_info* IP_FILE_HDR_Add_New_PU (IP_FILE_HDR& hdr);
00371 
00372 // Delete a PROC_INFO entry for a given function (i.e., don't write it 
00373 // to output file
00374 inline void
00375 Delete_Function_In_File (IP_FILE_HDR& hdr, UINT index)
00376 {
00377     IP_PROC_INFO* proc_info = IP_FILE_HDR_proc_info (hdr);
00378     
00379     Is_True (IP_PROC_INFO_state (proc_info[index]) != IPA_WRITTEN &&
00380        IP_PROC_INFO_state (proc_info[index]) != IPA_DELETED,
00381        ("Delete_Proc:  function already deleted"));
00382     
00383     Set_IP_PROC_INFO_state (proc_info[index], IPA_DELETED);
00384     Inc_IP_FILE_HDR_num_procs_processed (hdr);
00385     hdr.num_written++;
00386 }
00387 
00388 #endif /* ipc_file_INCLUDED */
osprey/ipa/common/ipc_file.h
