lestes::backend_v2::workers::liveness_analysis Class Reference

Performs liveness analysis of instruction operands. More...

#include <liveness_analysis.g.hh>

Inheritance diagram for lestes::backend_v2::workers::liveness_analysis:

lestes::std::object lestes::std::mem::keystone List of all members.

Public Member Functions

ptr< ::lestes::backend_v2::structs::func_datadata_get () const
 The method data_get returns the value of the field liveness_analysis::data.
void data_set (const ptr< ::lestes::backend_v2::structs::func_data > &)
 The method data_set sets the field liveness_analysis::data to the given value.
ptr< ::lestes::std::map< srp<
::lestes::backend_v2::intercode::ge_pi >,
srp< ::lestes::std::pair<
srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > >,
srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > > > > > > 
inout_get () const
 The method inout_get returns the value of the field liveness_analysis::inout.
void inout_set (const ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_pi >, srp< ::lestes::std::pair< srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > >, srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > > > > > > &)
 The method inout_set sets the field liveness_analysis::inout to the given value.
void process ()
ptr< vector< srp< liveness_range > > > get_result ()
 Returns a vector of the computed live ranges.
ptr< ::lestes::backend_v2::intercode::ge_operand_regextract_reg_operand (ptr< ::lestes::backend_v2::intercode::ge_operand > op)
virtual ptr< reflection_listreflection_get () const
 for purposes of dumping
virtual ptr< field_list_listfield_values_get () const
 for purposes of dumping

Static Public Member Functions

static ptr< liveness_analysiscreate (ptr< ::lestes::backend_v2::structs::func_data > a__liveness_analysis__data, ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_pi >, srp< ::lestes::std::pair< srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > >, srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > > > > > > a__liveness_analysis__inout)
 First generated factory method for class liveness_analysis.
static ptr< liveness_analysiscreate (ptr< ::lestes::backend_v2::structs::func_data > a__liveness_analysis__data)
 Second generated factory method for class liveness_analysis.

Protected Member Functions

 liveness_analysis (ptr< ::lestes::backend_v2::structs::func_data > a__liveness_analysis__data, ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_pi >, srp< ::lestes::std::pair< srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > >, srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > > > > > > a__liveness_analysis__inout)
 Generated constructor for class liveness_analysis.
virtual void gc_mark ()
 Marking routine for class liveness_analysis.

Private Attributes

srp< ::lestes::backend_v2::structs::func_datadata
srp< ::lestes::std::map< srp<
::lestes::backend_v2::intercode::ge_pi >,
srp< ::lestes::std::pair<
srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > >,
srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > > > > > > 
inout
 Holds a pseudoinstruction to inout set map.

Static Private Attributes

static ptr< reflection_listreflection = reflection

Detailed Description

Performs liveness analysis of instruction operands.

Definition at line 64 of file liveness_analysis.g.hh.


Constructor & Destructor Documentation

lestes::backend_v2::workers::liveness_analysis::liveness_analysis ( ptr< ::lestes::backend_v2::structs::func_data a__liveness_analysis__data,
ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_pi >, srp< ::lestes::std::pair< srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > >, srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > > > > > >  a__liveness_analysis__inout 
) [protected]

Generated constructor for class liveness_analysis.

Generated constructor for class liveness_analysis.

Author:
lsg

Definition at line 84 of file liveness_analysis.g.cc.

Referenced by create().

00086         : ::lestes::std::object(), data(checked(a__liveness_analysis__data)), inout(checked(a__liveness_analysis__inout))
00087 {}


Member Function Documentation

ptr<::lestes::backend_v2::structs::func_data > lestes::backend_v2::workers::liveness_analysis::data_get (  )  const

The method data_get returns the value of the field liveness_analysis::data.

Returns:
The value of liveness_analysis::data.
Author:
lsg

Definition at line 28 of file liveness_analysis.g.cc.

References data.

Referenced by get_result(), and process().

00029 {
00030         return data;
00031 }

void lestes::backend_v2::workers::liveness_analysis::data_set ( const ptr< ::lestes::backend_v2::structs::func_data > &  x  ) 

The method data_set sets the field liveness_analysis::data to the given value.

Parameters:
[in] x The new value to set liveness_analysis::data to.
Author:
lsg

Definition at line 37 of file liveness_analysis.g.cc.

References data.

00038 {
00039         liveness_analysis::data = x;
00040 }

ptr<::lestes::std::map< srp<::lestes::backend_v2::intercode::ge_pi >, srp<::lestes::std::pair< srp< set< srp<::lestes::backend_v2::intercode::ge_operand_reg > > >, srp< set< srp<::lestes::backend_v2::intercode::ge_operand_reg > > > > > > > lestes::backend_v2::workers::liveness_analysis::inout_get (  )  const

The method inout_get returns the value of the field liveness_analysis::inout.

Returns:
The value of liveness_analysis::inout.
Author:
lsg

Definition at line 46 of file liveness_analysis.g.cc.

References inout.

00047 {
00048         return inout;
00049 }

void lestes::backend_v2::workers::liveness_analysis::inout_set ( const ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_pi >, srp< ::lestes::std::pair< srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > >, srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > > > > > > &  x  ) 

The method inout_set sets the field liveness_analysis::inout to the given value.

Parameters:
[in] x The new value to set liveness_analysis::inout to.
Author:
lsg

Definition at line 55 of file liveness_analysis.g.cc.

References inout.

00056 {
00057         liveness_analysis::inout = x;
00058 }

void lestes::backend_v2::workers::liveness_analysis::process (  ) 

Definition at line 43 of file liveness_analysis.cc.

References lestes::std::pair< T1, T2 >::create(), data_get(), extract_reg_operand(), and inout.

00043                                 {
00044 
00045         ptr<visitor_pi_pi2id> pi2id = visitor_pi_pi2id::create();
00046         
00047         ptr<ge_pi_list__type> body = data_get()->ge_body_get(); 
00048 
00049         //initialise In and Out sets for every ge_pi in the body        
00050         for(ge_pi_list__type::iterator it = body->begin(); it!=body->end(); ++it) {
00051                 ptr<ge_pi> ge =  *it;
00052                 (*inout)[ge] = ge_op_set_pair__type::create(ge_op_set__type::create(),ge_op_set__type::create());
00053         }
00054                 
00055         bool changed = true;
00056         
00057         while(changed) {
00058         
00059                 changed = false;
00060                 
00061                 ptr<ge_pi> succ;
00062                 
00063                 for(ge_pi_list__type::reverse_iterator it = body->rbegin(); it!=body->rend(); ++it) {
00064                         ptr<ge_pi> ge =  *it;
00065                         
00066                         if ( ge->kind_get()==ge_pi::SP ) {
00067                                 /*
00068                                         ge_sp usually has no operands.
00069                                         
00070                                         Exception is the case that some instruction A has to be done 
00071                                         and its output operands are not used elsewhere. So the pi_sp 
00072                                         is set to use these output operand in order     to not allow a 
00073                                         dead code elimination to delete the instruction A.
00074                                         These operands aren't real operands, so the ge_sp should
00075                                         not be included in their liveness rangess.
00076                                 */
00077                                 continue;
00078                         }
00079                         
00080                         ptr<ge_op_vector__type> in_ops = ge->operands_input_get();
00081                         ptr<ge_op_vector__type> out_ops = ge->operands_output_get();
00082                         
00083                         //old Inp and Out sets of the current ge_pi
00084                         ptr<ge_op_set_pair__type> ge_io = (*inout)[ge];
00085                         ptr<ge_op_set__type> old_in = ge_io->first;
00086                         ptr<ge_op_set__type> old_out = ge_io->second;
00087                         
00088                         //updated sets
00089                         ptr<ge_op_set__type> in = ge_op_set__type::create();
00090                         ptr<ge_op_set__type> out = ge_op_set__type::create();
00091                         
00092                         ge_io->first = in;
00093                         ge_io->second = out;
00094                         
00095                         /*
00096                                 in[n] <- use[n] UNION ( out[n] DIFFERENCE def[n] )
00097                         */
00098                         for(ulint i=0; i<out_ops->size(); ++i) {
00099                                 ptr<ge_operand> op = (*out_ops)[i];
00100                                 
00101                                 ptr<ge_operand_reg> reg = extract_reg_operand(op);
00102                                 
00103                                 if ( !reg ) {
00104                                         continue;
00105                                 }
00106                                 
00107                                 if ( old_out->find(reg)==old_out->end() ) {
00108                                         in->insert(reg);
00109                                 }
00110                         }
00111                         
00112                         for(ulint i=0; i<in_ops->size(); ++i) {
00113                                 ptr<ge_operand> op = (*in_ops)[i];
00114                                 
00115                                 ptr<ge_operand_reg> reg = extract_reg_operand(op);
00116                                 
00117                                 if ( !reg ) {
00118                                         continue;
00119                                 }
00120                                 
00121                                 in->insert(reg);
00122                         }
00123                         
00124                         
00125                         /*
00126                                 out[n] <- UNION[s from succ(n)](in[s])
00127                         */
00128                         
00129                         visitor_pi_pi2id::kind_type pi_id = visitor_pi_pi2id::PI_ADD;
00130                         
00131                         if ( ge->pi_source_get() ) {
00132                                         pi_id = (visitor_pi_pi2id::kind_type)ge->pi_source_get()->accept_visitor_pi_pi2ulint_gen_base(pi2id);
00133                         }
00134                         
00135                         switch ( pi_id ) {
00136                                 case visitor_pi_pi2id::PI_BA:
00137                                 case visitor_pi_pi2id::PI_LEAVE: {
00138                                         /*
00139                                                 pi_ba and pi_leave always jumps to its target. 
00140                                                 The following instruction in scheduled order is not successor.
00141                                         */              
00142                                         ptr<ge_sp_vector__type> targets = ge->jmp_targets_get();
00143                                         
00144                                         if (  targets && targets->size()!=0 ) {
00145                                         
00146                                                 for(ulint i=0; i<targets->size(); ++i) {
00147                                                         ptr<ge_op_set_pair__type> succ_io = (*inout)[(*targets)[i]];
00148                                                         ptr<ge_op_set__type> succ_in = succ_io->first;
00149                                                         
00150                                                         set_union(
00151                                                                 out->begin(),
00152                                                                 out->end(),
00153                                                                 succ_in->begin(),
00154                                                                 succ_in->end(),
00155                                                                 ::std::insert_iterator<ge_op_set__type>(*out,out->begin()));
00156                                                 }
00157                                         }
00158                                         
00159                                 } break;
00160                                 
00161                                 case visitor_pi_pi2id::PI_BN: {
00162                                         /*
00163                                                 pi_bn never jumps to its target. 
00164                                                 The following instruction in scheduled order is the only successor.
00165                                         */
00166                                         if ( succ ) {
00167                                                 ptr<ge_op_set_pair__type> succ_io = (*inout)[succ];
00168                                                 ptr<ge_op_set__type> succ_in = succ_io->first;
00169                                                 
00170                                                 set_union(
00171                                                         out->begin(),
00172                                                         out->end(),
00173                                                         succ_in->begin(),
00174                                                         succ_in->end(),
00175                                                         ::std::insert_iterator<ge_op_set__type>(*out,out->begin()));
00176                                         }
00177                                         
00178                                 } break;
00179                                 
00180                                 default: {
00181                                         
00182                                         /*
00183                                                 The following instruction in scheduled order is successor.
00184                                         */
00185                                         if ( succ ) {
00186                                                 ptr<ge_op_set_pair__type> succ_io = (*inout)[succ];
00187                                                 ptr<ge_op_set__type> succ_in = succ_io->first;
00188                                                 
00189                                                 set_union(
00190                                                         out->begin(),
00191                                                         out->end(),
00192                                                         succ_in->begin(),
00193                                                         succ_in->end(),
00194                                                         ::std::insert_iterator<ge_op_set__type>(*out,out->begin()));
00195                                         }
00196                                         
00197                                         /*
00198                                                 Successors of a branch instruction are its targets too.
00199                                         */
00200                                         ptr<ge_sp_vector__type> targets = ge->jmp_targets_get();
00201                                         if (  targets && targets->size()!=0 ) {
00202                                                 
00203                                                 for(ulint i=0; i<targets->size(); ++i) {
00204                                                         ptr<ge_op_set_pair__type> succ_io = (*inout)[(*targets)[i]];
00205                                                         ptr<ge_op_set__type> succ_in = succ_io->first;
00206                                                         
00207                                                         set_union(
00208                                                                 out->begin(),
00209                                                                 out->end(),
00210                                                                 succ_in->begin(),
00211                                                                 succ_in->end(),
00212                                                                 ::std::insert_iterator<ge_op_set__type>(*out,out->begin()));
00213                                                 }
00214                                         }
00215                                         
00216                                 } break;
00217                                 
00218                         }
00219                                 
00220                         //Test whether In or Out set has been changed.
00221                         if ( in->size()!=old_in->size() || out->size()!=old_out->size() ) {
00222                                 changed = true;
00223                         }
00224                         
00225                         succ = ge;
00226                         
00227                 }       
00228         }
00229         
00230 }

ptr< vector< srp< liveness_range > > > lestes::backend_v2::workers::liveness_analysis::get_result (  ) 

Returns a vector of the computed live ranges.

Definition at line 251 of file liveness_analysis.cc.

References lestes::backend_v2::workers::liveness_range::create(), create(), and data_get().

00251                                                                  {
00252         ptr<vector<srp<liveness_range> > > output = vector<srp<liveness_range> >::create();
00253         
00254         //Live ranges of operands
00255         ptr<ge_op2liveness__type> op2live = ge_op2liveness__type::create();
00256 
00257         ptr<ge_pi_list__type> body = data_get()->ge_body_get(); 
00258         
00259         for(ge_pi_list__type::iterator it = body->begin(); it!=body->end(); ++it) {
00260                 ptr<ge_pi> ge =  *it;
00261                 
00262                 ptr<ge_op_set__type> ge_io = (*inout)[ge]->first;
00263                 
00264                 for(ge_op_set__type::iterator it_op = ge_io->begin(); it_op!=ge_io->end(); ++it_op) { 
00265                         ptr<ge_operand_reg> reg = *it_op;
00266                         
00267                         ptr<liveness_range> rng;
00268                         
00269                         ge_op2liveness__type::iterator live_it = op2live->find(reg);
00270                         
00271                         if ( live_it==op2live->end() ) {
00272                                 rng = liveness_range::create(reg,ge->schedule_pos_get(),ge->schedule_pos_get());
00273                                 output->push_back(rng);
00274                                 (*op2live)[reg] = rng;
00275                         } else {
00276                                 rng = live_it->second;
00277                                 rng->end_set(ge->schedule_pos_get());
00278                         }
00279                         
00280                         rng->instructions_get()->push_back(ge);
00281                 }
00282         }
00283                 
00284         return output;
00285 }

ptr< ::lestes::backend_v2::intercode::ge_operand_reg > lestes::backend_v2::workers::liveness_analysis::extract_reg_operand ( ptr< ::lestes::backend_v2::intercode::ge_operand op  ) 

Referenced by process().

ptr< liveness_analysis > lestes::backend_v2::workers::liveness_analysis::create ( ptr< ::lestes::backend_v2::structs::func_data a__liveness_analysis__data,
ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_pi >, srp< ::lestes::std::pair< srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > >, srp< set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > > > > > >  a__liveness_analysis__inout 
) [static]

First generated factory method for class liveness_analysis.

This factory method for class liveness_analysis takes values of all fields as arguments.

Author:
lsg

Definition at line 64 of file liveness_analysis.g.cc.

References liveness_analysis().

Referenced by create(), get_result(), and lestes::backend_v2::workers::alloc_int_finder::process().

00066 {
00067         return ptr< liveness_analysis > ( new liveness_analysis(a__liveness_analysis__data,
00068                 a__liveness_analysis__inout) );
00069 }

ptr< liveness_analysis > lestes::backend_v2::workers::liveness_analysis::create ( ptr< ::lestes::backend_v2::structs::func_data a__liveness_analysis__data  )  [static]

Second generated factory method for class liveness_analysis.

This factory method for class liveness_analysis uses initializers.

Author:
lsg

Definition at line 75 of file liveness_analysis.g.cc.

References create(), and liveness_analysis().

00076 {
00077         return ptr< liveness_analysis > ( new liveness_analysis(a__liveness_analysis__data, ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_pi >, srp< ::lestes::std::pair< srp<set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > >, srp<set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > > > > > ::create()) );
00078 }

ptr< object::reflection_list > lestes::backend_v2::workers::liveness_analysis::reflection_get (  )  const [virtual]

for purposes of dumping

Reimplemented from lestes::std::object.

Definition at line 89 of file liveness_analysis.g.cc.

References lestes::std::list< T >::create(), reflection, and lestes::std::object::reflection_get().

00090 {
00091         if (!reflection) {
00092                 typedef class_reflection::field_metadata md;
00093                 typedef class_reflection::field_metadata_list mdlist;
00094                 ptr<mdlist> mdl = mdlist::create();
00095                 mdl->push_back( md::create( "data", "func_data" ) );
00096                 mdl->push_back( md::create( "inout", "map&lt; srp&lt; ::lestes::backend_v2::intercode::ge_pi &gt;, srp&lt; ::lestes::std::pair&lt; srp&lt;set&lt; srp&lt; ::lestes::backend_v2::intercode::ge_operand_reg &gt; &gt; &gt;, srp&lt;set&lt; srp&lt; ::lestes::backend_v2::intercode::ge_operand_reg &gt; &gt; &gt; &gt; &gt; &gt;" ) );
00097                 reflection = reflection_list::create( ::lestes::std::object::reflection_get() );
00098                 reflection->push_back( class_reflection::create( "liveness_analysis", mdl ) );
00099         }
00100         return reflection;
00101 }

ptr< object::field_list_list > lestes::backend_v2::workers::liveness_analysis::field_values_get (  )  const [virtual]

for purposes of dumping

Reimplemented from lestes::std::object.

Definition at line 103 of file liveness_analysis.g.cc.

References lestes::std::list< T >::create(), and lestes::std::object::field_values_get().

00104 {
00105         ptr < field_list_list > result = ::lestes::std::object::field_values_get();
00106         result->push_back( value_list::create() );
00107         result->back()->push_back( this->data );
00108         result->push_back( value_list::create() );
00109         result->back()->push_back( this->inout );
00110         return result;
00111 }

void lestes::backend_v2::workers::liveness_analysis::gc_mark ( void   )  [protected, virtual]

Marking routine for class liveness_analysis.

Marking routine is used for garbage collection.

Author:
lsg

Reimplemented from lestes::std::mem::keystone.

Definition at line 118 of file liveness_analysis.g.cc.

References lestes::std::mem::keystone::gc_mark().

00119 {
00120 	::lestes::std::object::gc_mark();
00121 }


Member Data Documentation

srp< ::lestes::backend_v2::structs::func_data > lestes::backend_v2::workers::liveness_analysis::data [private]

Definition at line 111 of file liveness_analysis.g.hh.

Referenced by data_get(), and data_set().

srp< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_pi >, srp< ::lestes::std::pair< srp<set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > >, srp<set< srp< ::lestes::backend_v2::intercode::ge_operand_reg > > > > > > > lestes::backend_v2::workers::liveness_analysis::inout [private]

Holds a pseudoinstruction to inout set map.

Definition at line 113 of file liveness_analysis.g.hh.

Referenced by inout_get(), inout_set(), and process().

ptr< object::reflection_list > lestes::backend_v2::workers::liveness_analysis::reflection = reflection [static, private]

Reimplemented from lestes::std::object.

Definition at line 114 of file liveness_analysis.g.hh.

Referenced by reflection_get().


The documentation for this class was generated from the following files:
Generated on Mon Feb 12 18:24:11 2007 for lestes by doxygen 1.5.1-20070107