/* Copyright (C) 2000, 2001 Silicon Graphics, Inc. All Rights Reserved. This program is free software; you can redistribute it and/or modify it under the terms of version 2 of the GNU General Public License as published by the Free Software Foundation. This program is distributed in the hope that it would be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Further, this software is distributed without any warranty that it is free of the rightful claim of any third person regarding infringement or the like. Any license provided herein, whether implied or otherwise, applies only to this software file. Patent licenses, if any, provided herein do not apply to combinations of this program with other software, or any other product whatsoever. You should have received a copy of the GNU General Public License along with this program; if not, write the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA. Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky, Mountain View, CA 94043, or: http://www.sgi.com For further information regarding this notice, see: http://oss.sgi.com/projects/GenInfo/NoticeExplan */ /* -*-Mode: c++;-*- (Tell emacs to use c++ mode) */ /* ==================================================================== * ==================================================================== * * Module: ipl_summarize.h * * Description: * Generation of summary information. * * ==================================================================== * ==================================================================== */ #ifndef ipl_summarize_INCLUDED #define ipl_summarize_INCLUDED #ifndef cxx_template_INCLUDED #include "cxx_template.h" #endif // cxx_template_INCLUDED #ifndef cxx_hash_INCLUDED #include "cxx_hash.h" #endif // cxx_hash_INCLUDED #ifndef wn_util_INCLUDED #include "wn_util.h" // for WN, iterators, #endif // wn_util_INCLUDED #ifndef wn_map_INCLUDED #include "wn_map.h" // for WN mappings #endif // wn_map_INCLUDED #ifndef lwn_util_INCLUDED #include "lwn_util.h" // for LWN_Parentize #endif // lwn_util_INCLUDED #ifndef config_ipa_INCLUDED #include "config_ipa.h" // for INLINE_Enable_Copy_Prop #endif // config_ipa_INCLUDED #ifndef opt_du_INCLUDED #include "opt_du.h" // for DU-manager #endif // opt_du__INCLUDED #ifndef opt_alias_interface_INCLUDED #include "opt_alias_interface.h" // for alias manager #endif // opt_alias_interface_INCLUDED #ifndef opt_ssa_INCLUDED #include "opt_ssa.h" // for PHI_NODE #endif // opt_ssa_INCLUDED #ifndef ipl_summary_INCLUDED #include "ipl_summary.h" // summary info data structures #endif // ipl_summary_INCLUDED extern void Init_Aux_Symbol_Info (SYMTAB_IDX level); //from ipl_summarize_util.h //--------------------------------------------------------------- // alternate entry point array // contain all the alternate entry points encountered in the // subroutine //--------------------------------------------------------------- class ALT_ENTRY { private: WN* _w; INT _position; INT _formal_count; public: WN* Get_wn() const { return _w;}; void Set_wn(WN* w) { _w = w;}; INT Get_position() const { return _position;}; void Set_position(INT p) { _position = p;}; INT Get_formal_count() const { return _formal_count;}; void Set_formal_count(INT f) { _formal_count = f;}; void Init() { bzero (this, sizeof(ALT_ENTRY)); } }; // ALT_ENTRY /* buffer up all inline-related pragmas -- use later to update the callsite node inline attributes */ class INLINE_ATTR { #define IPL_FILE_INLINE 0x1 #define IPL_NO_FILE_INLINE 0x2 #define IPL_PU_INLINE 0x4 #define IPL_NO_PU_INLINE 0x8 private: char *name; // function named by the pragma INT inline_attr; // inline attributes public: /* access functions */ void Set_name (char *str) { name = str; } char *Get_name () const { return name; } void Set_file_inline() { inline_attr |= IPL_FILE_INLINE;}; BOOL Is_file_inline() const { return inline_attr & IPL_FILE_INLINE;}; void Set_no_file_inline() { inline_attr |= IPL_NO_FILE_INLINE;}; BOOL Is_no_file_inline() const { return inline_attr & IPL_NO_FILE_INLINE;}; void Set_pu_inline() { inline_attr |= IPL_PU_INLINE;}; BOOL Is_pu_inline() const { return inline_attr & IPL_PU_INLINE;}; void Set_no_pu_inline() { inline_attr |= IPL_NO_PU_INLINE;}; BOOL Is_no_pu_inline() const { return inline_attr & IPL_NO_PU_INLINE;}; }; // INLINE_ATTR typedef HASH_TABLE GLOBAL_HASH_TABLE; typedef HASH_TABLE COMMON_HASH_TABLE; class EMITTER; class SUMMARY_CHECK_POINT; /* describe what kind of summary structure is needed for a given WHIRL node */ class SUMMARY_DESC { private: WN *_w; union { PHI_NODE *_phi; CODEREP *_chi_cr; } u; IPA_CONST_TYPE _type; BOOL _addr_of; // see description in SUMMARY_VALUE BOOL _convertible_to_global; // see description in SUMMARY_VALUE TYPE_ID _target_mtype; // see description in SUMMARY_VALUE public: SUMMARY_DESC () { bzero (this, sizeof(SUMMARY_DESC)); } void Set_wn (WN *w) { _w = w; } WN *Get_wn () const { return _w; } void Set_type (IPA_CONST_TYPE t) { _type = t;} IPA_CONST_TYPE Get_type () const { return _type; } void Set_phi (PHI_NODE *p) { u._phi = p; } PHI_NODE *Get_phi () const { return u._phi; }; void Set_chi_cr (CODEREP *cr) { u._chi_cr = cr; } CODEREP *Get_chi_cr () const { return u._chi_cr; }; void Set_is_addr_of () { _addr_of = TRUE; } void Reset_is_addr_of () { _addr_of = FALSE; } BOOL Is_addr_of () const { return _addr_of; } void Set_convertible_to_global () { _convertible_to_global = TRUE; } void Reset_convertible_to_global () { _convertible_to_global = FALSE; } BOOL Is_convertible_to_global () const { return _convertible_to_global; } void Set_target_mtype (TYPE_ID m) { _target_mtype = m; } TYPE_ID Target_mtype () const { return _target_mtype; } }; // SUMMARY_DESC enum PROGRAM { IPL, INLINER }; // ====================================================================== // The next two classes are ONLY for inlining purpose // ====================================================================== // class SUMMARY_CREF_SYMBOL used ONLY by inliner to keep cref count // ====================================================================== class SUMMARY_CREF_SYMBOL { private: INT32 _symbol_index;// mirrors the SUMMARY_SYMBOL's index INT _cur_cref_count; public: void Set_symbol_index(INT32 idx) { _symbol_index = idx;}; INT32 Get_symbol_index() const { return _symbol_index;}; void Reset_cur_cref_count() { _cur_cref_count = 0;}; void Incr_cur_cref_count() { _cur_cref_count++;}; void Decr_cur_cref_count() { _cur_cref_count--;}; INT Get_cur_cref_count() const { return _cur_cref_count;} }; // SUMMARY_CREF_SYMBOL // ====================================================================== // class SUMMARY_PROC_INFO used ONLY by the inliner to keep // remaining-call-count, and ISTORE/MSTORE/STID/ info // to enable substitution of actuals for formals when actual is LDID // ====================================================================== class SUMMARY_PROC_INFO { private: mINT32 _symbol_index;// mirrors the SUMMARY_PROCEDURE's index INT32 _call_count; // current # of calls in the procedure mUINT32 _state; // bit fields for _state #define PROC_HAS_ISTORE 0x001 // There is an ISTORE in the body public: void Set_symbol_index (INT32 s) { _symbol_index = s; } INT32 Get_symbol_index () const { return _symbol_index; } UINT32 Get_state () const { return _state; } void Set_has_istore() { _state |= PROC_HAS_ISTORE;} BOOL Has_istore() const { return (_state & PROC_HAS_ISTORE);} void Incr_call_count () { ++_call_count; } void Decr_call_count () { --_call_count; } BOOL Is_Leaf_now () const { return (_call_count == 0);} void Init (void) { bzero (this, sizeof(SUMMARY_PROC_INFO)); _call_count = 0; } }; // SUMMARY_PROC_INFO // ====================================================================== // Template for class SUMMARIZE: // // Shared by ipl.so and standalone inliner, instantiated by the enumeration // type PROGRAM. // // This class contains all the functions for creating summary information. template class SUMMARIZE { private: MEM_POOL *mem; WN *entry_point; // original entry point, for alt // entry point processing. // used by inliner to keep proc struct DU_MANAGER *du_mgr; struct ALIAS_MANAGER *alias_mgr; EMITTER *emitter; DYN_ARRAY _procedure; DYN_ARRAY _callsite; DYN_ARRAY _stmt; DYN_ARRAY _ctrl_dep; DYN_ARRAY _formal; DYN_ARRAY _actual; DYN_ARRAY _value; DYN_ARRAY _expr; DYN_ARRAY _phi; DYN_ARRAY _chi; DYN_ARRAY _symbol; // _proc_info and _crefcount used ONLY by inliner DYN_ARRAY _symbol_crefcount; DYN_ARRAY _proc_info; DYN_ARRAY _global; DYN_ARRAY _feedback; DYN_ARRAY _common; DYN_ARRAY _common_shape; DYN_ARRAY _global_stid; DYN_ARRAY _tcon; DYN_ARRAY _alt_entry; DYN_ARRAY _inline_attr; BOOL Trace_Modref; // trace mod/ref analysis /* used as cache to keep track of which global symbols have been entered into the SUMMARY_SYMBOL array */ DYN_ARRAY *Global_index; /* For each procedure, record if a SUMMARY_GLOBAL entry is created, and if so, the index corresponds to that entry into the SUMMARY_GLOBAL array */ GLOBAL_HASH_TABLE *Global_hash_table; BOOL File_Pragmas; // has file based pragmas /* private access functions */ void Set_entry_point (WN *w) { entry_point = w; } /* private operations */ SUMMARY_PROCEDURE *New_procedure () { INT new_idx = _procedure.Newidx (); _procedure[new_idx].Init (); return &(_procedure[new_idx]); } SUMMARY_PROC_INFO *New_proc_info () { INT new_idx = _proc_info.Newidx (); _proc_info[new_idx].Init (); return &(_proc_info[new_idx]); } SUMMARY_CALLSITE *New_callsite () { INT new_idx = _callsite.Newidx (); _callsite[new_idx].Init (); return &(_callsite[new_idx]); } SUMMARY_STMT *New_stmt () { INT new_idx = _stmt.Newidx (); _stmt[new_idx].Init (); return &(_stmt[new_idx]); } SUMMARY_CONTROL_DEPENDENCE *New_ctrl_dep () { INT new_idx = _ctrl_dep.Newidx (); _ctrl_dep[new_idx].Init (); return &(_ctrl_dep[new_idx]); } SUMMARY_ACTUAL *New_actual () { INT new_idx = _actual.Newidx (); _actual[new_idx].Init (); return &(_actual[new_idx]); } SUMMARY_FORMAL *New_formal () { INT new_idx = _formal.Newidx (); return &(_formal[new_idx]); } SUMMARY_VALUE *New_value () { INT new_idx = _value.Newidx (); _value[new_idx].Init (); return &(_value[new_idx]); } SUMMARY_EXPR *New_expr () { INT new_idx = _expr.Newidx (); _expr[new_idx].Init (); return &(_expr[new_idx]); } SUMMARY_PHI *New_phi () { INT new_idx = _phi.Newidx (); _phi[new_idx].Init (); return &(_phi[new_idx]); } SUMMARY_CHI *New_chi () { INT new_idx = _chi.Newidx (); _chi[new_idx].Init (); return &(_chi[new_idx]); } SUMMARY_SYMBOL *New_symbol () { INT new_idx = _symbol.Newidx (); _symbol[new_idx].Init (); return &(_symbol[new_idx]); } SUMMARY_CREF_SYMBOL *New_symbol_crefcount () { INT new_idx = _symbol_crefcount.Newidx (); _symbol_crefcount[new_idx].Reset_cur_cref_count(); // initialize ref count to 0 return &(_symbol_crefcount[new_idx]); } SUMMARY_GLOBAL *New_global () { INT new_idx = _global.Newidx (); _global[new_idx].Init (); return &(_global[new_idx]); } SUMMARY_FEEDBACK *New_feedback () { INT new_idx = _feedback.Newidx (); _feedback[new_idx].Init (); return &(_feedback[new_idx]); } SUMMARY_COMMON *New_common () { INT new_idx = _common.Newidx (); _common[new_idx].Init (); return &(_common[new_idx]); } SUMMARY_COMMON_SHAPE *New_common_shape () { INT new_idx = _common_shape.Newidx (); _common_shape[new_idx].Init (); return &(_common_shape[new_idx]); } SUMMARY_STID *New_global_stid () { INT new_idx = _global_stid.Newidx (); _global_stid[new_idx].Init (); return &(_global_stid[new_idx]); } TCON **New_tcon () { INT new_idx = _tcon.Newidx (); return &(_tcon[new_idx]); } ALT_ENTRY *New_alt_entry () { INT new_idx = _alt_entry.Newidx (); _alt_entry[new_idx].Init (); return &(_alt_entry[new_idx]); } INLINE_ATTR *New_inline_attr () { INT new_idx = _inline_attr.Newidx (); return &(_inline_attr[new_idx]); } void Process_alt_procedure (WN *w, INT formal_index, INT formal_count); void Process_callsite (WN *w, INT id, INT loopnest); void Process_formal (WN *w, INT num_formals, SUMMARY_PROCEDURE *proc); void Process_formal_alt (WN *w, INT kid_count); void Process_actual (WN *actual); void Process_alt_entry (WN *w); void Process_IO(WN* w); void Set_IO(WN *w, BOOL is_read); void Process_inline_attr (WN *pragma_node); void Process_commons_in_whirl(WN* w, SUMMARY_PROCEDURE *proc); inline void Restore_from_check_point (const SUMMARY_CHECK_POINT *cp); void Process_constant_jump_function (WN *w, SUMMARY_VALUE *value); void Process_phi_operand (INT phi_index, WN *orig_wn, CODEREP *cr, INT kid); INT Process_phi_jump_function (WN *orig_wn, PHI_NODE *phi); INT Process_chi_jump_function (WN *wn, const SUMMARY_DESC &desc); void Process_operand (WN *w, INT kid, INT expr_idx); INT Process_polynomial_jump_function (WN *w); BOOL Mismatched_load_store (CODEREP *cr, BOOL is_ptr_var, ST *st, INT load_offset, TYPE_ID load_type); void Classify_indirect (SUMMARY_DESC &result, WN *w); void Classify_const_value (SUMMARY_DESC &result, WN *w); void Classify_const_value (SUMMARY_DESC &result, WN *w, CODEREP *cr); INT Process_jump_function (SUMMARY_DESC *desc); void Process_jump_function (WN *w, INT value_idx); void Record_global_ref (WN *w, ST *s, OPERATOR op, BOOL refcount_only); void Record_ref_formal (WN *); void Record_ref_all_formal (WN *w, BOOL parm_store = FALSE); void Check_kid_ref (WN* w); void Record_ref (WN *w); void Record_global_dmod (const WN *w, const WN *rhs, const ST *st); void Record_mod_formal (WN *w); void Record_mod_common (WN *w, const ST *st); void Record_mod (WN *w); INT Process_cd_for_phi_node (IDTYPE cd_bb_idx); BOOL Process_control_dependence (WN *w, INT node_index); void Copy_summary_ctrl_dep (SUMMARY_CONTROL_DEPENDENCE *cd); inline void Generate_summary_control_dependence (void); void Update_Addr_Passed_Count (WN* opr_parm); void Set_local_addr_taken_attrib (); void Process_pragma_node (WN* w); void Process_pragmas (WN *w); void Update_call_pragmas (SUMMARY_CALLSITE *callsite); // Functions needed for execution cost analysis INT IPL_GEN_Value(WN* wn_value, DYN_ARRAY* sv, DYN_ARRAY* sx); INT IPL_GEN_Expr(OPERATOR opr, INT exp_one, INT exp_two, DYN_ARRAY* sx); INT IPL_GEN_Const(INT value, DYN_ARRAY* sv, DYN_ARRAY* sx); BOOL Easy_Trip_Count(WN* wn_loop, WN** wn_addr_ub, WN** wn_addr_lb, INT* addr_intconst); INT IPL_EX_Expr(WN* wn_expr, DYN_ARRAY* sv, DYN_ARRAY* sx); INT IPL_EX_Trip_Count(WN* wn_loop, DYN_ARRAY* sv, DYN_ARRAY* sx, BOOL constant_estimate); INT IPL_EX_Call(WN* wn_call, DYN_ARRAY* sv, DYN_ARRAY* sx); INT IPL_EX_Statement(WN* wn_statement, DYN_ARRAY* sv, DYN_ARRAY* sx, BOOL constant_estimate); INT IPL_EX_Block(WN* wn_block, DYN_ARRAY* sv, DYN_ARRAY* sx, BOOL constant_estimate); void IPL_Execution_Cost(WN* wn_func, SUMMARY_PROCEDURE* sp, MEM_POOL* mem_pool, BOOL constant_estimate); public: /* public access functions */ WN *Get_entry_point () const { return entry_point; } BOOL Has_global_symbol_index(const ST* st); void Set_mem_pool (MEM_POOL *m) { mem = m; } MEM_POOL *Get_mem_pool () const { return mem; } void Set_du_mgr (struct DU_MANAGER *du) { du_mgr = du; } struct DU_MANAGER *Get_du_mgr () const { return du_mgr; } void Set_alias_mgr (struct ALIAS_MANAGER *alias) { alias_mgr = alias; } struct ALIAS_MANAGER *Get_alias_mgr () const { return alias_mgr; } void Set_emitter (EMITTER *e) { emitter = e; } EMITTER *Get_emitter () const { return emitter; } SUMMARY_PROCEDURE *Get_procedure (INT id) const { return &(_procedure[id]); } SUMMARY_PROC_INFO *Get_proc_info (INT id) const { return &(_proc_info[id]); } SUMMARY_CALLSITE *Get_callsite (INT id) const { return &(_callsite[id]); } SUMMARY_STMT *Get_stmt (INT id) const { return &(_stmt[id]); } SUMMARY_CONTROL_DEPENDENCE *Get_ctrl_dep (INT id) const { return &(_ctrl_dep[id]); } SUMMARY_FORMAL *Get_formal (INT idx) const { return &(_formal[idx]); } SUMMARY_ACTUAL *Get_actual (INT idx) const { return &(_actual[idx]); } SUMMARY_VALUE *Get_value (INT idx) const { return &(_value[idx]); } SUMMARY_EXPR *Get_expr (INT idx) const { return &(_expr[idx]); } SUMMARY_PHI *Get_phi (INT idx) const { return &(_phi[idx]); } SUMMARY_CHI *Get_chi (INT idx) const { return &(_chi[idx]); } SUMMARY_SYMBOL *Get_symbol (INT idx) const { return &(_symbol[idx]); } SUMMARY_CREF_SYMBOL *Get_symbol_crefcount (INT idx) const { return &(_symbol_crefcount[idx]);} SUMMARY_GLOBAL *Get_global (INT idx) const { return &(_global[idx]); } SUMMARY_FEEDBACK *Get_feedback (INT idx) const { return &(_feedback[idx]);} SUMMARY_COMMON *Get_common (INT idx) const { return &(_common[idx]); } SUMMARY_COMMON_SHAPE *Get_common_shape (INT idx) const { return &(_common_shape[idx]); } SUMMARY_STID *Get_global_stid (INT idx) const { return &(_global_stid[idx]); } TCON **Get_tcon (INT idx) const { return &(_tcon[idx]); } ALT_ENTRY *Get_alt_entry (INT idx) const { return &(_alt_entry[idx]); } INLINE_ATTR *Get_inline_attr (INT idx) const { return &(_inline_attr[idx]); } BOOL Has_procedure_entry () const { return _procedure.Lastidx () != -1; } BOOL Has_proc_info_entry () const { return _proc_info.Lastidx () != -1; } BOOL Has_callsite_entry () const { return _callsite.Lastidx () != -1; } BOOL Has_stmt_entry () const { return _stmt.Lastidx () != -1; } BOOL Has_ctrl_dep_entry () const { return _ctrl_dep.Lastidx () != -1; } BOOL Has_formal_entry () const { return _formal.Lastidx () != -1; } BOOL Has_actual_entry () const { return _actual.Lastidx () != -1; } BOOL Has_value_entry () const { return _value.Lastidx () != -1; } BOOL Has_expr_entry () const { return _expr.Lastidx () != -1; } BOOL Has_phi_entry () const { return _phi.Lastidx () != -1; } BOOL Has_chi_entry () const { return _chi.Lastidx () != -1; } BOOL Has_symbol_entry () const { return _symbol.Lastidx () != -1; } BOOL Has_symbol_crefcount_entry () const { return _symbol_crefcount.Lastidx () != -1; } BOOL Has_global_entry () const { return _global.Lastidx () != -1; } BOOL Has_feedback_entry () const { return _feedback.Lastidx () != -1; } BOOL Has_common_entry () const { return _common.Lastidx () != -1; } BOOL Has_common_shape_entry () const{ return _common_shape.Lastidx () != -1; } BOOL Has_alt_entry () const { return _alt_entry.Lastidx () != -1; } BOOL Has_inline_attr () const { return _inline_attr.Lastidx () != -1; } BOOL Has_global_stid_entry () const { return _global_stid.Lastidx () != -1; } INT Get_procedure_idx () const { return _procedure.Lastidx (); } INT Get_proc_info_idx () const { return _proc_info.Lastidx (); } INT Get_callsite_idx () const { return _callsite.Lastidx (); } INT Get_stmt_idx () const { return _stmt.Lastidx (); } INT Get_ctrl_dep_idx () const { return _ctrl_dep.Lastidx (); } INT Get_formal_idx () const { return _formal.Lastidx (); } INT Get_actual_idx () const { return _actual.Lastidx (); } INT Get_value_idx () const { return _value.Lastidx (); } INT Get_expr_idx () const { return _expr.Lastidx (); } INT Get_phi_idx () const { return _phi.Lastidx (); } INT Get_chi_idx () const { return _chi.Lastidx (); } INT Get_symbol_idx () const { return _symbol.Lastidx (); } INT Get_symbol_crefcount_idx () const { return _symbol_crefcount.Lastidx (); } INT Get_global_idx () const { return _global.Lastidx (); } INT Get_feedback_idx () const { return _feedback.Lastidx (); } INT Get_common_idx () const { return _common.Lastidx (); } INT Get_common_shape_idx () const { return _common_shape.Lastidx (); } INT Get_alt_entry_idx () const { return _alt_entry.Lastidx (); } INT Get_inline_attr_idx () const { return _inline_attr.Lastidx (); } INT Get_global_stid_idx () const { return _global_stid.Lastidx (); } // constructor SUMMARIZE (MEM_POOL *m) { SUMMARY_VALUE* value = NULL; Set_mem_pool (m); _procedure.Set_Mem_Pool (m); _proc_info.Set_Mem_Pool (m); _callsite.Set_Mem_Pool (m); _stmt.Set_Mem_Pool (m); _ctrl_dep.Set_Mem_Pool (m); _formal.Set_Mem_Pool (m); _actual.Set_Mem_Pool (m); _value.Set_Mem_Pool (m); _expr.Set_Mem_Pool (m); _phi.Set_Mem_Pool (m); _chi.Set_Mem_Pool (m); _symbol.Set_Mem_Pool (m); _symbol_crefcount.Set_Mem_Pool (m); _global.Set_Mem_Pool (m); _feedback.Set_Mem_Pool (m); _common.Set_Mem_Pool (m); _common_shape.Set_Mem_Pool (m); _tcon.Set_Mem_Pool (m); _alt_entry.Set_Mem_Pool (m); _inline_attr.Set_Mem_Pool (m); _global_stid.Set_Mem_Pool(m); Trace_Modref = FALSE; entry_point = NULL; File_Pragmas = FALSE; Global_index = CXX_NEW (DYN_ARRAY(m), m); INT Global_index_size = ST_Table_Size (GLOBAL_SYMTAB); Global_index->Setidx (Global_index_size); Global_index->Bzero_array (); Global_hash_table = 0; Init_Aux_Symbol_Info (GLOBAL_SYMTAB); if (program == INLINER) return; /* set up the two most common constants */ value = New_value (); value->Set_mtype (MTYPE_I4); value->Set_int_const (); value->Set_int_const_value (0); value = New_value (); value->Set_mtype (MTYPE_I4); value->Set_int_const (); value->Set_int_const_value (1); }; // public operations void Summarize (WN *w); void Process_procedure (WN *w); INT Get_symbol_index (const ST *st); void Set_global_addr_taken_attrib (void); INT Get_symbol_crefcount_index (INT32 i); // only for inliner INT Find_symbol_crefcount_index (INT32 i); // only for inliner INT Find_proc_info_index(INT32 i); // only for inliner void Trace(FILE* fp); }; // SUMMARIZE #ifdef IPA_SUMMARY #define PROGRAM_NAME IPL #define Trace_CopyProp (0) #else // IPA_SUMMARY #define PROGRAM_NAME INLINER extern BOOL Trace_CopyProp; #endif // IPA_SUMMARY typedef SUMMARIZE SUMMARY; extern SUMMARY *Summary; #endif /* ipl_summarize_INCLUDED */