lestes::backend_v2::workers::alloc_int_finder Class Reference

Splits liveranges to a set of intervals with nonempty intersection of sets of allowed register. More...

#include <alloc_int_finder.g.hh>

Inheritance diagram for lestes::backend_v2::workers::alloc_int_finder:

List of all members.

Public Member Functions
void	process ()
	Splits live ranges to regalloc intervals.
ptr< ::lestes::backend_v2::structs::func_data >	get_result ()
	Returns data of a processed function with result of the worker included.
ptr< set< ulint > >	ge_pi__get_allowed_regs_for_op (ptr< ::lestes::backend_v2::intercode::ge_pi > ge, ptr< ::lestes::backend_v2::intercode::ge_operand_reg > op)
ptr< ::lestes::md::instructions::tm_instr_op_reg_base >	ge_pi__find_tm_op_by_ge_op (ptr< ::lestes::backend_v2::intercode::ge_pi > ge, ptr< ::lestes::backend_v2::intercode::ge_operand_reg > op)
virtual ptr< reflection_list >	reflection_get () const
	for purposes of dumping
virtual ptr< field_list_list >	field_values_get () const
	for purposes of dumping
Static Public Member Functions
static ptr< alloc_int_finder >	create (ptr< ::lestes::backend_v2::structs::func_data > a__worker_base__data)
	First generated factory method for class alloc_int_finder.
Protected Member Functions
	alloc_int_finder (ptr< ::lestes::backend_v2::structs::func_data > a__worker_base__data)
	Generated constructor for class alloc_int_finder.
virtual void	gc_mark ()
	Marking routine for class alloc_int_finder.
Static Private Attributes
static ptr< reflection_list >	reflection = reflection

---

Detailed Description

Splits liveranges to a set of intervals with nonempty intersection of sets of allowed register.

Definition at line 99 of file alloc_int_finder.g.hh.

---

Constructor & Destructor Documentation

lestes::backend_v2::workers::alloc_int_finder::alloc_int_finder

(

ptr< ::lestes::backend_v2::structs::func_data >

a__worker_base__data

)

[protected]

Generated constructor for class alloc_int_finder.

Generated constructor for class alloc_int_finder.

Author:

lsg

Definition at line 40 of file alloc_int_finder.g.cc.

Referenced by create().

        : worker_base(a__worker_base__data)
{}

---

Member Function Documentation

void lestes::backend_v2::workers::alloc_int_finder::process

(

)

[virtual]

Splits live ranges to regalloc intervals.

It traverses list of live ranges and splits every range to intervals that have nonempty intersection of allowed register sets.

Implements lestes::backend_v2::workers::worker_base.

Definition at line 30 of file alloc_int_finder.cc.

References lestes::backend_v2::workers::alloc_interval::create(), lestes::backend_v2::workers::liveness_analysis::create(), lestes::backend_v2::workers::worker_base::data_get(), ge_pi__get_allowed_regs_for_op(), and lassert.

                               {

        //Find liveness ranges.
        ptr<liveness_analysis> liveness = liveness_analysis::create(data_get());
        liveness->process();
        ptr<liveness_rng_vector__type> liveness_rngs = liveness->get_result();  
        
        
        ptr<alloc_int_vector__type> ints = data_get()->alloc_ints_get();
        
        /*
                Go through liveness ranges and try split them to intervals with nonempty intersections
                of allowed registers. 
        */
        for(liveness_rng_vector__type::iterator it1 = liveness_rngs->begin(); it1!=liveness_rngs->end(); ++it1) {
                ptr<liveness_range> rng = *it1;
                ptr<ge_operand_reg> operand = rng->operand_get();
                
                ptr<alloc_interval> prev_inter = NULL;
                
                ptr<alloc_interval> inter = NULL;
                ptr<id_set__type> int_allowed_regs = NULL;
                ptr<ge_pi_vector__type> int_instrs = NULL;
                
                ptr<ge_pi_vector__type> rng_instrs = rng->instructions_get();
                
                /*
                        Create intervals of the range's instructions with non-empty intersection
                        of allowed registers.
                */
                for(ge_pi_vector__type::iterator it2 = rng_instrs->begin(); it2!=rng_instrs->end();) {
                        ptr<ge_pi> ge = *it2;

                        if ( !inter ) {
                                inter = alloc_interval::create(operand,rng);
                                ints->push_back(inter);
                
                                int_allowed_regs = NULL;
                                int_instrs = inter->instructions_get();
                                
                                
                                if ( !prev_inter ) {
                                        /*
                                                Insert operand's origin to the first interval.
                                        
                                                NOTE: This is ok, because of the register allocator does old interval expiration
                                                before searching for free registers. So if live range of an operand ends as input 
                                                operand of a ge_pi, register that is allocated for the operand is emediatly free
                                                for any output operand of the ge_pi.
                                        */
                                        if ( operand->origin_get() ) {
                                                if ( operand->origin_get()->kind_get()!=ge_pi::SP ) { //origin can be a ge_sp instruction.
                                                        int_allowed_regs = ge_pi__get_allowed_regs_for_op(operand->origin_get(),operand);
                                                }
                                
                                                int_instrs->push_back(operand->origin_get());
                                        }       
                                } 
                        }
                        
                        if ( ge==operand->origin_get() ) {
                                //The ge_pi is already in interval.
                                ++it2;
                                continue;
                        }
                        
                        if ( ge->kind_get()==ge_pi::SP ) {
                                ++it2;
                                int_instrs->push_back(ge);
                                continue;
                        }
                        
                        ptr<id_set__type> int_allowed_regs_tmp = id_set__type::create();
                                
                        ptr<id_set__type> op_allowed_regs = ge_pi__get_allowed_regs_for_op(ge,operand);
                        
                        if ( !int_allowed_regs ) {
                                //The first instruction in the set
                                int_allowed_regs_tmp->insert(op_allowed_regs->begin(),op_allowed_regs->end());
                                int_allowed_regs = int_allowed_regs_tmp;
                        } else {
                                /*
                                        N'th instruction in the set. Compute allowed intersection of allowed registers for interval and 
                                        instruction.
                                */
                                set_intersection(
                                        int_allowed_regs->begin(),
                                        int_allowed_regs->end(),
                                        op_allowed_regs->begin(),
                                        op_allowed_regs->end(),
                                        ::std::insert_iterator<id_set__type>(*int_allowed_regs_tmp,int_allowed_regs_tmp->begin()));
                        }
                        
                        if ( int_allowed_regs_tmp->size()==0 ) {
                                //Intersection is empty. Split intervals.
                                lassert(int_instrs->size()!=0);
                                
                                inter->allowed_registers_set(int_allowed_regs);
                                
                                if ( prev_inter ) {
                                        inter->start_set(prev_inter->instructions_get()->back()->schedule_pos_get());
                                        prev_inter->end_set(int_instrs->front()->schedule_pos_get());
                                } else {
                                        inter->start_set(int_instrs->front()->schedule_pos_get());
                                }
                                
                                inter->end_set(int_instrs->back()->schedule_pos_get());
                                
                                if ( prev_inter ) {
                                        inter->prev_set(prev_inter);
                                        prev_inter->next_set(inter);
                                }
                                
                                prev_inter = inter;
                                
                                inter = NULL;
                        } else {
                                //Intersection is non-empty.
                                int_allowed_regs = int_allowed_regs_tmp;
                                int_instrs->push_back(ge);
                                ++it2;  
                        }
                        
                        
                }
                
                if ( inter ) {
                        //Finish the last interval.
                        lassert(int_instrs->size()!=0);
                        
                        inter->allowed_registers_set(int_allowed_regs);
                                
                        if ( prev_inter ) {
                                inter->start_set(prev_inter->instructions_get()->back()->schedule_pos_get());
                                prev_inter->end_set(int_instrs->front()->schedule_pos_get());
                        } else {
                                inter->start_set(int_instrs->front()->schedule_pos_get());
                        }
        
                        inter->end_set(int_instrs->back()->schedule_pos_get());
                                
                        if ( prev_inter ) {
                                inter->prev_set(prev_inter);
                                prev_inter->next_set(inter);
                        }
                }
                
        }
        
}

ptr< func_data > lestes::backend_v2::workers::alloc_int_finder::get_result

(

)

[virtual]

Returns data of a processed function with result of the worker included.

Returns:

Data of a processed function.

Implements lestes::backend_v2::workers::worker_base.

Definition at line 251 of file alloc_int_finder.cc.

References lestes::backend_v2::workers::worker_base::data_get().

                                            {
        return data_get();
}

ptr<set<ulint> > lestes::backend_v2::workers::alloc_int_finder::ge_pi__get_allowed_regs_for_op	(	ptr< ::lestes::backend_v2::intercode::ge_pi >	ge,
		ptr< ::lestes::backend_v2::intercode::ge_operand_reg >	op
	)

Referenced by process().

ptr< ::lestes::md::instructions::tm_instr_op_reg_base > lestes::backend_v2::workers::alloc_int_finder::ge_pi__find_tm_op_by_ge_op	(	ptr< ::lestes::backend_v2::intercode::ge_pi >	ge,
		ptr< ::lestes::backend_v2::intercode::ge_operand_reg >	op
	)

ptr< alloc_int_finder > lestes::backend_v2::workers::alloc_int_finder::create

(

ptr< ::lestes::backend_v2::structs::func_data >

a__worker_base__data

)

[static]

First generated factory method for class alloc_int_finder.

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

Author:

lsg

Definition at line 31 of file alloc_int_finder.g.cc.

References alloc_int_finder().

{
        return ptr< alloc_int_finder > ( new alloc_int_finder(a__worker_base__data) );
}

ptr< object::reflection_list > lestes::backend_v2::workers::alloc_int_finder::reflection_get

(

)

const [virtual]

for purposes of dumping

Reimplemented from lestes::backend_v2::workers::worker_base.

Definition at line 44 of file alloc_int_finder.g.cc.

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

{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( worker_base::reflection_get() );
                reflection->push_back( class_reflection::create( "alloc_int_finder", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > lestes::backend_v2::workers::alloc_int_finder::field_values_get

(

)

const [virtual]

for purposes of dumping

Reimplemented from lestes::backend_v2::workers::worker_base.

Definition at line 56 of file alloc_int_finder.g.cc.

References lestes::backend_v2::workers::worker_base::field_values_get().

{
        ptr < field_list_list > result = worker_base::field_values_get();
        return result;
}

void lestes::backend_v2::workers::alloc_int_finder::gc_mark

(

void

)

[protected, virtual]

Marking routine for class alloc_int_finder.

Marking routine is used for garbage collection.

Author:

lsg

Reimplemented from lestes::backend_v2::workers::worker_base.

Definition at line 67 of file alloc_int_finder.g.cc.

References lestes::backend_v2::workers::worker_base::gc_mark().

{
        worker_base::gc_mark();
}

---

Member Data Documentation

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

Reimplemented from lestes::backend_v2::workers::worker_base.

Definition at line 130 of file alloc_int_finder.g.hh.

Referenced by reflection_get().

---

The documentation for this class was generated from the following files:

• alloc_int_finder.g.hh
• alloc_int_finder.cc
• alloc_int_finder.g.cc

---