Polaris: SymbolAccessRef.cc Source File

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