Polaris: SymbolAccess.cc Source File

00001 ///
00002 /// \file SymbolAccess.cc
00003 ///
00004 #ifdef POLARIS_GNU_PRAGMAS
00005 #pragma implementation
00006 #endif
00007 ///
00008 #include "Statement/Statement.h"
00009 #include "SymbolAccess.h"
00010 #include "utilities/access_util.h"
00011 #include "utilities/switches_util.h"
00012 
00013 SymbolAccess::SymbolAccess( ) {
00014     #ifdef CLASS_INSTANCE_REGISTRY
00015     register_instance(SYMBOL_ACCESS, sizeof(SymbolAccess), this);
00016     #endif
00017 }
00018 
00019 SymbolAccess::SymbolAccess( const List<AbstractAccess> read, 
00020                const List<AbstractAccess> write, 
00021                const List<AbstractAccess> readwrite ) {
00022 
00023     #ifdef CLASS_INSTANCE_REGISTRY
00024     register_instance(SYMBOL_ACCESS, sizeof(SymbolAccess), this);
00025     #endif
00026 
00027     /// ...  Copy the lists
00028 
00029     _copy_access_lists( read, write, readwrite );
00030 }
00031 
00032 SymbolAccess::SymbolAccess( const SymbolAccess & other ) {
00033 
00034     #ifdef CLASS_INSTANCE_REGISTRY
00035     register_instance(SYMBOL_ACCESS, sizeof(SymbolAccess), this);
00036     #endif
00037 
00038     _copy_access_lists( other._read, other._write, other._readwrite );
00039 }
00040 
00041 void
00042 SymbolAccess::ins( const SymbolAccess & rhs ) {
00043     _copy_access_lists( (List<AbstractAccess> &) rhs._read, 
00044                 (List<AbstractAccess> &) rhs._write, 
00045                 (List<AbstractAccess> &) rhs._readwrite );
00046 }
00047 
00048 void
00049 SymbolAccess::_copy_access_lists( const List<AbstractAccess> read, 
00050                  const List<AbstractAccess> write, 
00051                  const List<AbstractAccess> readwrite ) {
00052 
00053     for (Iterator<AbstractAccess> iter = read;
00054      iter.valid();
00055      ++iter) {
00056     _read.ins_last( iter.current().clone() );
00057     }
00058 
00059     for (Iterator<AbstractAccess> iter = write;
00060      iter.valid();
00061      ++iter) {
00062     _write.ins_last( iter.current().clone() );
00063     }
00064 
00065     for (Iterator<AbstractAccess> iter = readwrite;
00066      iter.valid();
00067      ++iter) {
00068     _readwrite.ins_last( iter.current().clone() );
00069     }
00070 
00071 }
00072 
00073 SymbolAccess::~SymbolAccess( ) {
00074     #ifdef CLASS_INSTANCE_REGISTRY
00075     unregister_instance(SYMBOL_ACCESS, this);
00076     #endif
00077 }
00078 
00079 SymbolAccess *
00080 SymbolAccess::clone() const
00081 {
00082     return new SymbolAccess( *this );
00083 }
00084 
00085 Listable *
00086 SymbolAccess::listable_clone() const
00087 {
00088     return (Listable *) clone();
00089 }
00090 
00091 void 
00092 SymbolAccess::relink_eptrs( ProgramUnit & p ) {
00093 
00094     for (Iterator<AbstractAccess> iter = _read;
00095      iter.valid();
00096      ++iter) {
00097     iter.current().relink_eptrs( p );
00098     }
00099 
00100     for (Iterator<AbstractAccess> iter = _write;
00101      iter.valid();
00102      ++iter) {
00103     iter.current().relink_eptrs( p );
00104     }
00105 
00106     for (Iterator<AbstractAccess> iter = _readwrite;
00107      iter.valid();
00108      ++iter) {
00109     iter.current().relink_eptrs( p );
00110     }
00111 }
00112 
00113 void 
00114 SymbolAccess::add_read( const AbstractAccess * aa ) {
00115     _read.ins_first(aa);
00116 }
00117 
00118 void 
00119 SymbolAccess::add_write( const AbstractAccess * aa ) {
00120     _write.ins_first(aa);
00121 }
00122 
00123 void 
00124 SymbolAccess::add_readwrite( const AbstractAccess * aa ) {
00125     _readwrite.ins_first(aa);
00126 }
00127 
00128 void 
00129 SymbolAccess::add_read( const RefList<AbstractAccess> & list ) {
00130     for(Iterator<AbstractAccess> iter = list; iter.valid(); ++iter) {
00131     _read.ins_first(iter.current().clone());
00132     }
00133 }
00134 
00135 void 
00136 SymbolAccess::add_write( const RefList<AbstractAccess> & list ) {
00137     for(Iterator<AbstractAccess> iter = list; iter.valid(); ++iter) {
00138     _write.ins_first(iter.current().clone());
00139     }
00140 }
00141 
00142 void 
00143 SymbolAccess::add_readwrite( const RefList<AbstractAccess> & list ) {
00144     for(Iterator<AbstractAccess> iter = list; iter.valid(); ++iter) {
00145     _readwrite.ins_first(iter.current().clone());
00146     }
00147 }
00148 
00149 Iterator<AbstractAccess>
00150 SymbolAccess::iter_read( ) {
00151     Iterator<AbstractAccess> iter = _read;
00152     return iter;
00153 }
00154 
00155 Iterator<AbstractAccess>
00156 SymbolAccess::iter_write( ) {
00157     Iterator<AbstractAccess> iter = _write;
00158     return iter;
00159 }
00160 
00161 Iterator<AbstractAccess>
00162 SymbolAccess::iter_readwrite( ) {
00163     Iterator<AbstractAccess> iter = _readwrite;
00164     return iter;
00165 }
00166 
00167 Mutator<AbstractAccess>
00168 SymbolAccess::muter_read( ) {
00169     Mutator<AbstractAccess> muter = _read;
00170     return muter;
00171 }
00172 
00173 Mutator<AbstractAccess>
00174 SymbolAccess::muter_write( ) {
00175     Mutator<AbstractAccess> muter = _write;
00176     return muter;
00177 }
00178 
00179 Mutator<AbstractAccess>
00180 SymbolAccess::muter_readwrite( ) {
00181     Mutator<AbstractAccess> muter = _readwrite;
00182     return muter;
00183 }
00184 
00185 SymbolAccess *
00186 SymbolAccess::remap_interface_vars( InlineObject * inl_obj, const Symbol & sym,
00187                    ProgramUnit & pgm,
00188                    Statement & stmt, int exec_pred) const
00189 {
00190     List<AbstractAccess> * read_list = new List<AbstractAccess>;
00191     Iterator<AbstractAccess> iter = _read;
00192     for (;
00193      iter.valid();
00194      ++iter) {
00195     AbstractAccess & aa = iter.current();
00196     AbstractAccess * new_aa = 
00197         aa.remap_interface_vars(inl_obj, stmt, sym, IN_REF_EXPR, exec_pred );
00198     read_list->ins_last( new_aa );
00199 //  aa.outer().ins_last(*new_aa);   /// ...  Link inner to outer
00200     new_aa->pgm_summarized_to( &pgm ); /// ...  Summarized to the pgm containing CALL
00201     new_aa->summarized_to( &stmt );  /// ...  Summarized to the CALL stmt
00202 //  new_aa->inner().ins_last(aa);    /// ...  Link outer to inner
00203     new_aa->nesting_level( aa.nesting_level() );  /// ...  Nesting level does not change
00204     }
00205     
00206     List<AbstractAccess> * write_list = new List<AbstractAccess>;
00207     iter = _write;
00208     for (;
00209     iter.valid();
00210      ++iter) {
00211     AbstractAccess & aa = iter.current();
00212     AbstractAccess * new_aa = 
00213         aa.remap_interface_vars(inl_obj, stmt, sym, OUT_REF_EXPR, exec_pred);
00214     write_list->ins_last( new_aa );
00215 //  aa.outer().ins_last(*new_aa);   /// ...  Link inner to outer
00216     new_aa->pgm_summarized_to( &pgm ); /// ...  Summarized to the pgm containing CALL
00217     new_aa->summarized_to( &stmt );  /// ...  Summarized to the CALL stmt
00218 //  new_aa->inner().ins_last(aa);    /// ...  Link outer to inner
00219     new_aa->nesting_level( aa.nesting_level() );  /// ...  Nesting level does not change
00220     }
00221     
00222     List<AbstractAccess> * rw_list = new List<AbstractAccess>;
00223     iter = _readwrite;
00224     for (;
00225     iter.valid();
00226      ++iter) {
00227     AbstractAccess & aa = iter.current();
00228     AbstractAccess * new_aa = 
00229         aa.remap_interface_vars(inl_obj, stmt, sym, IN_OUT_REF_EXPR, exec_pred);
00230     rw_list->ins_last( new_aa );
00231 //  aa.outer().ins_last(*new_aa);   /// ...  Link inner to outer
00232     new_aa->pgm_summarized_to( &pgm ); /// ...  Summarized to the pgm containing CALL
00233     new_aa->summarized_to( &stmt );  /// ...  Summarized to the CALL stmt
00234 //  new_aa->inner().ins_last(aa);    /// ...  Link outer to inner
00235     new_aa->nesting_level( aa.nesting_level() );  /// ...  Nesting level does not change
00236     }
00237 
00238     SymbolAccess * new_sa = new SymbolAccess(*read_list, *write_list, *rw_list);
00239     return new_sa;
00240 }
00241 
00242 void
00243 SymbolAccess::print( ostream & o ) const {
00244 
00245     Iterator<AbstractAccess> iter = _read;
00246     if (iter.valid()) {
00247     o << "RO:{";
00248     for (;
00249         iter.valid();
00250          ++iter,o << ";") {
00251         o << iter.current();
00252     }
00253     o << "}";
00254     }
00255     
00256     iter = _write;
00257     if (iter.valid()) {
00258     o << " WF:{";
00259     for (;
00260         iter.valid();
00261          ++iter,o << ";") {
00262         o << iter.current();
00263     }
00264     o << "}";
00265     }
00266     
00267     iter = _readwrite;
00268     if (iter.valid()) {
00269     o << " RW:{";
00270     for (;
00271         iter.valid();
00272          ++iter,o << ";") {
00273         o << iter.current();
00274     }
00275     o << "}";
00276     }
00277 }
00278 
00279 void
00280 SymbolAccess::write( ostream & o, Symbol & sym, Statement & stmt ) const {
00281 
00282     int accreg_counts = switch_value("accreg_counts");
00283 
00284     Iterator<AbstractAccess> iter = _read;
00285     if (iter.valid()) {
00286     o << "RO:{";
00287     for (;
00288         iter.valid();
00289          ++iter,o << ";") {
00290         o << iter.current();
00291     }
00292     o << "}" << endl;
00293     }
00294     
00295     if (accreg_counts && (_read.entries() > 0) && 
00296     ((stmt.stmt_class()==DO_STMT) || 
00297      (stmt.stmt_class() == CALL_STMT) ||
00298      ((stmt.stmt_class() == ASSIGNMENT_STMT) &&
00299       (stmt.rhs().op()==FUNCTION_CALL_OP)) || 
00300      (stmt.stmt_class() == ENTRY_STMT) ))
00301 
00302     print_access_region_statistics( o, _read, stmt, sym );
00303     
00304     iter = _write;
00305     if (iter.valid()) {
00306     o << " WF:{";
00307     for (;
00308         iter.valid();
00309          ++iter,o << ";") {
00310         o << iter.current();
00311     }
00312     o << "}" << endl;
00313     }
00314     
00315     if (accreg_counts && (_write.entries() > 0) &&
00316     ((stmt.stmt_class()==DO_STMT) || 
00317      (stmt.stmt_class() == CALL_STMT) ||
00318      ((stmt.stmt_class() == ASSIGNMENT_STMT) &&
00319       (stmt.rhs().op()==FUNCTION_CALL_OP)) || 
00320      (stmt.stmt_class() == ENTRY_STMT) ))
00321 
00322     print_access_region_statistics( o, _write, stmt, sym );
00323     
00324     iter = _readwrite;
00325     if (iter.valid()) {
00326     o << " RW:{";
00327     for (;
00328         iter.valid();
00329          ++iter,o << ";") {
00330         o << iter.current();
00331     }
00332     o << "}" << endl;
00333     }
00334 
00335     if (accreg_counts && (_readwrite.entries() > 0) &&
00336     ((stmt.stmt_class()==DO_STMT) || 
00337      (stmt.stmt_class() == CALL_STMT) ||
00338      ((stmt.stmt_class() == ASSIGNMENT_STMT) &&
00339       (stmt.rhs().op()==FUNCTION_CALL_OP)) || 
00340      (stmt.stmt_class() == ENTRY_STMT) ))
00341 
00342     print_access_region_statistics( o, _readwrite, stmt, sym );
00343     
00344 }
00345 
00346 ostream & 
00347 operator << (ostream & o, const SymbolAccess & sa) 
00348 {
00349     sa.print(o);
00350     return o;
00351 }
00352 
00353