lestes::backend_v2::workers::linscan_regalloc

lestes::backend_v2::workers::linscan_regalloc Class Reference

Provides a linearscan register allocation. More...

#include <linscan_regalloc.g.hh>

Inheritance diagram for lestes::backend_v2::workers::linscan_regalloc:


Public Member Functions
ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	active_intervals_get () const
	The method active_intervals_get returns the value of the field linscan_regalloc::active_intervals.
void	active_intervals_set (const ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > &)
	The method active_intervals_set sets the field linscan_regalloc::active_intervals to the given value.
ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	expired_intervals_get () const
	The method expired_intervals_get returns the value of the field linscan_regalloc::expired_intervals.
void	expired_intervals_set (const ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > &)
	The method expired_intervals_set sets the field linscan_regalloc::expired_intervals to the given value.
ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	waiting_intervals_get () const
	The method waiting_intervals_get returns the value of the field linscan_regalloc::waiting_intervals.
void	waiting_intervals_set (const ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > &)
	The method waiting_intervals_set sets the field linscan_regalloc::waiting_intervals to the given value.
ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::workers::alloc_interval > > >	register_owners_get () const
	The method register_owners_get returns the value of the field linscan_regalloc::register_owners.
void	register_owners_set (const ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::workers::alloc_interval > > > &)
	The method register_owners_set sets the field linscan_regalloc::register_owners to the given value.
ptr< ::lestes::std::set< ulint > >	free_registers_get () const
	The method free_registers_get returns the value of the field linscan_regalloc::free_registers.
void	free_registers_set (const ptr< ::lestes::std::set< ulint > > &)
	The method free_registers_set sets the field linscan_regalloc::free_registers to the given value.
ptr< ::lestes::std::set< ulint > >	used_registers_get () const
	The method used_registers_get returns the value of the field linscan_regalloc::used_registers.
void	used_registers_set (const ptr< ::lestes::std::set< ulint > > &)
	The method used_registers_set sets the field linscan_regalloc::used_registers to the given value.
ptr< ::lestes::std::set< ulint > >	all_registers_get () const
	The method all_registers_get returns the value of the field linscan_regalloc::all_registers.
void	all_registers_set (const ptr< ::lestes::std::set< ulint > > &)
	The method all_registers_set sets the field linscan_regalloc::all_registers to the given value.
ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::md::registers::tm_register > > >	destroyers_get () const
	The method destroyers_get returns the value of the field linscan_regalloc::destroyers.
void	destroyers_set (const ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::md::registers::tm_register > > > &)
	The method destroyers_set sets the field linscan_regalloc::destroyers to the given value.
void	process ()
	Allocates registers to register operands.
ptr< ::lestes::backend_v2::structs::func_data >	get_result ()
	Returns data of the currently processed function with result of the register allocation.
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)
ptr< ::lestes::md::registers::tm_register >	get_free_register (ptr< ::lestes::backend_v2::workers::alloc_interval > interval)
void	set_register_owner (ptr< ::lestes::md::registers::tm_register > reg, ptr< ::lestes::backend_v2::workers::alloc_interval > interval)
void	expire_old_intervals (ptr< ::lestes::backend_v2::workers::alloc_interval > curr_interval)
void	setup_registers ()
	Fills the all_registers set with all the available registers.
void	find_free_registers ()
	Recomputes the free_registers set.
void	set_registers_to_operands ()
	Sets allocated registers of intervals to operands.
void	set_interval_dependencies ()
	Sets up dependencies amoung dependent intervals.
ptr< ::lestes::md::registers::tm_register >	get_destroyed_register (ptr< ::lestes::backend_v2::intercode::ge_operand_reg > op)
void	set_destroyed_register (ptr< ::lestes::backend_v2::intercode::ge_pi > ge, ptr< ::lestes::backend_v2::intercode::ge_operand_reg > op, ptr< ::lestes::md::registers::tm_register > reg)
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< linscan_regalloc >	create (ptr< ::lestes::backend_v2::structs::func_data > a__worker_base__data, ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > a__linscan_regalloc__active_intervals, ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > a__linscan_regalloc__expired_intervals, ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > a__linscan_regalloc__waiting_intervals, ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::workers::alloc_interval > > > a__linscan_regalloc__register_owners, ptr< ::lestes::std::set< ulint > > a__linscan_regalloc__free_registers, ptr< ::lestes::std::set< ulint > > a__linscan_regalloc__used_registers, ptr< ::lestes::std::set< ulint > > a__linscan_regalloc__all_registers, ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::md::registers::tm_register > > > a__linscan_regalloc__destroyers)
	First generated factory method for class linscan_regalloc.
static ptr< linscan_regalloc >	create (ptr< ::lestes::backend_v2::structs::func_data > a__worker_base__data)
	Second generated factory method for class linscan_regalloc.
Protected Member Functions
	linscan_regalloc (ptr< ::lestes::backend_v2::structs::func_data > a__worker_base__data, ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > a__linscan_regalloc__active_intervals, ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > a__linscan_regalloc__expired_intervals, ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > a__linscan_regalloc__waiting_intervals, ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::workers::alloc_interval > > > a__linscan_regalloc__register_owners, ptr< ::lestes::std::set< ulint > > a__linscan_regalloc__free_registers, ptr< ::lestes::std::set< ulint > > a__linscan_regalloc__used_registers, ptr< ::lestes::std::set< ulint > > a__linscan_regalloc__all_registers, ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::md::registers::tm_register > > > a__linscan_regalloc__destroyers)
	Generated constructor for class linscan_regalloc.
virtual void	gc_mark ()
	Marking routine for class linscan_regalloc.
Private Attributes
srp< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	active_intervals
	A list of active intervals.
srp< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	expired_intervals
	A list of already processed intervals.
srp< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	waiting_intervals
	A list of intervals witing for processing.
srp< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::workers::alloc_interval > > >	register_owners
	A map that holds information about which interval has which register allocated.
srp< ::lestes::std::set< ulint > >	free_registers
	A set of free registers.
srp< ::lestes::std::set< ulint > >	used_registers
	A set of used registers.
srp< ::lestes::std::set< ulint > >	all_registers
	A set of all the registers that machine description contains.
srp< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::md::registers::tm_register > > >	destroyers
	A map that holds information about whitch register is destroyed by which operand.
Static Private Attributes
static ptr< reflection_list >	reflection = reflection

Detailed Description

Provides a linearscan register allocation.

Definition at line 82 of file linscan_regalloc.g.hh.

Constructor & Destructor Documentation

lestes::backend_v2::workers::linscan_regalloc::linscan_regalloc	(	ptr< ::lestes::backend_v2::structs::func_data >	a__worker_base__data,
		ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__linscan_regalloc__active_intervals,
		ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__linscan_regalloc__expired_intervals,
		ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__linscan_regalloc__waiting_intervals,
		ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__linscan_regalloc__register_owners,
		ptr< ::lestes::std::set< ulint > >	a__linscan_regalloc__free_registers,
		ptr< ::lestes::std::set< ulint > >	a__linscan_regalloc__used_registers,
		ptr< ::lestes::std::set< ulint > >	a__linscan_regalloc__all_registers,
		ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::md::registers::tm_register > > >	a__linscan_regalloc__destroyers
	)			`[protected]`

Generated constructor for class linscan_regalloc.

Author:: lsg

Definition at line 208 of file linscan_regalloc.g.cc.

Referenced by create().

00217         : worker_base(a__worker_base__data), active_intervals(checked(a__linscan_regalloc__active_intervals)), expired_intervals(checked(a__linscan_regalloc__expired_intervals)), waiting_intervals(a__linscan_regalloc__waiting_intervals), register_owners(checked(a__linscan_regalloc__register_owners)), free_registers(checked(a__linscan_regalloc__free_registers)), used_registers(checked(a__linscan_regalloc__used_registers)), all_registers(checked(a__linscan_regalloc__all_registers)), destroyers(checked(a__linscan_regalloc__destroyers))
00218 {}

Member Function Documentation

ptr<::lestes::std::vector< srp<::lestes::backend_v2::workers::alloc_interval > > > lestes::backend_v2::workers::linscan_regalloc::active_intervals_get ( ) const

The method active_intervals_get returns the value of the field linscan_regalloc::active_intervals.

Returns:: The value of linscan_regalloc::active_intervals.

Author:: lsg

Definition at line 30 of file linscan_regalloc.g.cc.

References active_intervals.

00031 {
00032         return active_intervals;
00033 }

void lestes::backend_v2::workers::linscan_regalloc::active_intervals_set ( const ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > & x )

The method active_intervals_set sets the field linscan_regalloc::active_intervals to the given value.

Parameters:

[in] x The new value to set linscan_regalloc::active_intervals to.

Author:: lsg

Definition at line 39 of file linscan_regalloc.g.cc.

References active_intervals.

00040 {
00041         linscan_regalloc::active_intervals = x;
00042 }

ptr<::lestes::std::vector< srp<::lestes::backend_v2::workers::alloc_interval > > > lestes::backend_v2::workers::linscan_regalloc::expired_intervals_get ( ) const

The method expired_intervals_get returns the value of the field linscan_regalloc::expired_intervals.

Returns:: The value of linscan_regalloc::expired_intervals.

Author:: lsg

Definition at line 48 of file linscan_regalloc.g.cc.

References expired_intervals.

00049 {
00050         return expired_intervals;
00051 }

void lestes::backend_v2::workers::linscan_regalloc::expired_intervals_set ( const ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > & x )

The method expired_intervals_set sets the field linscan_regalloc::expired_intervals to the given value.

Parameters:

[in] x The new value to set linscan_regalloc::expired_intervals to.

Author:: lsg

Definition at line 57 of file linscan_regalloc.g.cc.

References expired_intervals.

00058 {
00059         linscan_regalloc::expired_intervals = x;
00060 }

ptr<::lestes::std::vector< srp<::lestes::backend_v2::workers::alloc_interval > > > lestes::backend_v2::workers::linscan_regalloc::waiting_intervals_get ( ) const

The method waiting_intervals_get returns the value of the field linscan_regalloc::waiting_intervals.

Returns:: The value of linscan_regalloc::waiting_intervals.

Author:: lsg

Definition at line 66 of file linscan_regalloc.g.cc.

References waiting_intervals.

00067 {
00068         return waiting_intervals;
00069 }

void lestes::backend_v2::workers::linscan_regalloc::waiting_intervals_set ( const ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > & x )

The method waiting_intervals_set sets the field linscan_regalloc::waiting_intervals to the given value.

Parameters:

[in] x The new value to set linscan_regalloc::waiting_intervals to.

Author:: lsg

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

References waiting_intervals.

00076 {
00077         linscan_regalloc::waiting_intervals = x;
00078 }

ptr<::lestes::std::map< ulint, srp<::lestes::backend_v2::workers::alloc_interval > > > lestes::backend_v2::workers::linscan_regalloc::register_owners_get ( ) const

The method register_owners_get returns the value of the field linscan_regalloc::register_owners.

Returns:: The value of linscan_regalloc::register_owners.

Author:: lsg

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

References register_owners.

00085 {
00086         return register_owners;
00087 }

void lestes::backend_v2::workers::linscan_regalloc::register_owners_set ( const ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::workers::alloc_interval > > > & x )

The method register_owners_set sets the field linscan_regalloc::register_owners to the given value.

Parameters:

[in] x The new value to set linscan_regalloc::register_owners to.

Author:: lsg

Definition at line 93 of file linscan_regalloc.g.cc.

References register_owners.

00094 {
00095         linscan_regalloc::register_owners = x;
00096 }

ptr<::lestes::std::set< ulint > > lestes::backend_v2::workers::linscan_regalloc::free_registers_get ( ) const

The method free_registers_get returns the value of the field linscan_regalloc::free_registers.

Returns:: The value of linscan_regalloc::free_registers.

Author:: lsg

Definition at line 102 of file linscan_regalloc.g.cc.

References free_registers.

00103 {
00104         return free_registers;
00105 }

void lestes::backend_v2::workers::linscan_regalloc::free_registers_set ( const ptr< ::lestes::std::set< ulint > > & x )

The method free_registers_set sets the field linscan_regalloc::free_registers to the given value.

Parameters:

[in] x The new value to set linscan_regalloc::free_registers to.

Author:: lsg

Definition at line 111 of file linscan_regalloc.g.cc.

References free_registers.

00112 {
00113         linscan_regalloc::free_registers = x;
00114 }

ptr<::lestes::std::set< ulint > > lestes::backend_v2::workers::linscan_regalloc::used_registers_get ( ) const

The method used_registers_get returns the value of the field linscan_regalloc::used_registers.

Returns:: The value of linscan_regalloc::used_registers.

Author:: lsg

Definition at line 120 of file linscan_regalloc.g.cc.

References used_registers.

00121 {
00122         return used_registers;
00123 }

void lestes::backend_v2::workers::linscan_regalloc::used_registers_set ( const ptr< ::lestes::std::set< ulint > > & x )

The method used_registers_set sets the field linscan_regalloc::used_registers to the given value.

Parameters:

[in] x The new value to set linscan_regalloc::used_registers to.

Author:: lsg

Definition at line 129 of file linscan_regalloc.g.cc.

References used_registers.

00130 {
00131         linscan_regalloc::used_registers = x;
00132 }

ptr<::lestes::std::set< ulint > > lestes::backend_v2::workers::linscan_regalloc::all_registers_get ( ) const

The method all_registers_get returns the value of the field linscan_regalloc::all_registers.

Returns:: The value of linscan_regalloc::all_registers.

Author:: lsg

Definition at line 138 of file linscan_regalloc.g.cc.

References all_registers.

00139 {
00140         return all_registers;
00141 }

void lestes::backend_v2::workers::linscan_regalloc::all_registers_set ( const ptr< ::lestes::std::set< ulint > > & x )

The method all_registers_set sets the field linscan_regalloc::all_registers to the given value.

Parameters:

[in] x The new value to set linscan_regalloc::all_registers to.

Author:: lsg

Definition at line 147 of file linscan_regalloc.g.cc.

References all_registers.

00148 {
00149         linscan_regalloc::all_registers = x;
00150 }

ptr<::lestes::std::map< srp<::lestes::backend_v2::intercode::ge_operand_reg >, srp<::lestes::md::registers::tm_register > > > lestes::backend_v2::workers::linscan_regalloc::destroyers_get ( ) const

The method destroyers_get returns the value of the field linscan_regalloc::destroyers.

Returns:: The value of linscan_regalloc::destroyers.

Author:: lsg

Definition at line 156 of file linscan_regalloc.g.cc.

References destroyers.

00157 {
00158         return destroyers;
00159 }

void lestes::backend_v2::workers::linscan_regalloc::destroyers_set ( const ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::md::registers::tm_register > > > & x )

The method destroyers_set sets the field linscan_regalloc::destroyers to the given value.

Parameters:

[in] x The new value to set linscan_regalloc::destroyers to.

Author:: lsg

Definition at line 165 of file linscan_regalloc.g.cc.

References destroyers.

00166 {
00167         linscan_regalloc::destroyers = x;
00168 }

void lestes::backend_v2::workers::linscan_regalloc::process ( ) [virtual]

Allocates registers to register operands.

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

Definition at line 36 of file linscan_regalloc.cc.

References active_intervals, lestes::backend_v2::workers::alloc_int_cmp1(), lestes::backend_v2::workers::worker_base::data_get(), destroyers, lestes::msg::eolog, expire_old_intervals(), expired_intervals, get_free_register(), lassert, register_owners, set_register_owner(), setup_registers(), and waiting_intervals.

00036                                {
00037         rlog << "process start\n" << eolog;
00038         
00039         //Set all available registers free.
00040         setup_registers();
00041         
00042         //Get intervals for register allocation.
00043         waiting_intervals = alloc_int_vector__type::create(data_get()->alloc_ints_get());
00044 
00045         //Sort waiting intervals by increasing start point
00046         ::std::sort(waiting_intervals->begin(),waiting_intervals->end(),alloc_int_cmp1);
00047         
00048         for(alloc_int_vector__type::iterator it = waiting_intervals->begin(); it!=waiting_intervals->end();) {
00049                 ptr<alloc_interval> interval = *it;
00050 
00051                 //Remove old intervals.         
00052                 expire_old_intervals(interval);
00053                 
00054                 //Allocate register for interval.
00055                 ptr<tm_register> allocated_reg = get_free_register(interval);
00056                 
00057                 if ( allocated_reg ) {
00058                         //Free register for interval has been successfuly found.
00059                         interval->allocated_reg_set(allocated_reg);
00060                         
00061                         /*
00062                                 Find interval that was previous owner of the register.
00063                                 This information will help to set dependencies in order to
00064                                 prevent scheduler to schedule these two intervals in a way 
00065                                 where they overlap.
00066                         */
00067                         reg2alloc_int__type::iterator tmp = register_owners->find(allocated_reg->id_get());
00068                         
00069                         if ( tmp!=register_owners->end() ) {
00070                                 interval->allocated_obj_prev_owner_set(tmp->second);
00071                         }
00072                         
00073                         set_register_owner(allocated_reg,interval);
00074                 }
00075                 
00076                 //Set interval active.
00077                 it = waiting_intervals->erase(it);
00078                 active_intervals->push_back(interval);  
00079         }
00080 
00081         //Move rest of the active intervals to the expired intervals    
00082         for(alloc_int_vector__type::iterator it = active_intervals->begin(); it!=active_intervals->end();) {
00083                 expired_intervals->push_back(*it);
00084                 it = active_intervals->erase(it);
00085         }
00086 
00087         lassert(destroyers->size()==0); 
00088         lassert(waiting_intervals->size()==0);
00089         lassert(active_intervals->size()==0);
00090         
00091         rlog << "process end\n" << eolog;
00092 }

ptr<::lestes::backend_v2::structs::func_data > lestes::backend_v2::workers::linscan_regalloc::get_result ( ) [virtual]

Returns data of the currently processed function with result of the register allocation.

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

Definition at line 466 of file linscan_regalloc.cc.

References lestes::backend_v2::workers::worker_base::data_get(), expired_intervals, set_interval_dependencies(), and set_registers_to_operands().

00466                                                                      {
00467         rlog << "get_result start\n" << eolog;
00468         
00469         set_registers_to_operands();
00470         
00471         set_interval_dependencies();
00472         
00473         data_get()->alloc_ints_set(expired_intervals);
00474         
00475         rlog << "get_result end\n" << eolog;
00476         return data_get();
00477 }

ptr<set<ulint> > lestes::backend_v2::workers::linscan_regalloc::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 > lestes::backend_v2::workers::linscan_regalloc::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< ::lestes::md::registers::tm_register > lestes::backend_v2::workers::linscan_regalloc::get_free_register ( ptr< ::lestes::backend_v2::workers::alloc_interval > interval )

Referenced by process().

void lestes::backend_v2::workers::linscan_regalloc::set_register_owner	(	ptr< ::lestes::md::registers::tm_register >	reg,
		ptr< ::lestes::backend_v2::workers::alloc_interval >	interval
	)

Referenced by process().

void lestes::backend_v2::workers::linscan_regalloc::expire_old_intervals ( ptr< ::lestes::backend_v2::workers::alloc_interval > curr_interval )

Referenced by process().

void lestes::backend_v2::workers::linscan_regalloc::setup_registers ( )

Fills the all_registers set with all the available registers.

Definition at line 97 of file linscan_regalloc.cc.

References all_registers, lestes::md::registers::R_UNDEFINED, and lestes::md::registers::RIT_TERMINATOR.

Referenced by process().

00097                                        {
00098         for(ulint i = R_UNDEFINED+1; i<RIT_TERMINATOR; ++i) {
00099                 all_registers->insert(i);
00100         }
00101 }

void lestes::backend_v2::workers::linscan_regalloc::find_free_registers ( )

Recomputes the free_registers set.

free_registers <- all_registers - used_registers

Definition at line 210 of file linscan_regalloc.cc.

References all_registers, free_registers, and used_registers.

00210                                            {
00211         rlog << "find_free_registers start\n" << eolog;
00212         
00213         ptr<id_set__type> deep_used_registers = id_set__type::create();
00214         
00215         for(id_set__type::iterator it=used_registers->begin(); it!=used_registers->end(); ++it) {
00216                 ptr<tm_register> reg = tm_register::instance(*it);
00217                 
00218                 ptr<id_set__type> new_deep_used_registers = id_set__type::create();
00219                 
00220                 ::std::set_union(
00221                         reg->aliases_get()->begin(),
00222                         reg->aliases_get()->end(),
00223                         deep_used_registers->begin(),
00224                         deep_used_registers->end(),
00225                         ::std::inserter(*new_deep_used_registers,new_deep_used_registers->begin()));
00226                         
00227                 deep_used_registers = new_deep_used_registers;
00228         }
00229         
00230         ptr<id_set__type> updated_free_registers = id_set__type::create();
00231         
00232         ::std::set_difference(
00233                         all_registers->begin(),
00234                         all_registers->end(),
00235                         deep_used_registers->begin(),
00236                         deep_used_registers->end(),
00237                         ::std::inserter(*updated_free_registers,updated_free_registers->begin()));
00238                         
00239         free_registers = updated_free_registers;
00240         
00241         rlog << "find_free_registers end\n" << eolog;
00242 }

void lestes::backend_v2::workers::linscan_regalloc::set_registers_to_operands ( )

Sets allocated registers of intervals to operands.

Definition at line 436 of file linscan_regalloc.cc.

References expired_intervals, and lassert.

Referenced by get_result().

00436                                                  {
00437         rlog << "set_registers start\n" << eolog;
00438         /*
00439                 Set assigned_registers and assigned_spill_space properties of ge_operand_regs according to the result of
00440                 the register allocation 
00441         */
00442         for(alloc_int_vector__type::iterator it = expired_intervals->begin(); it!=expired_intervals->end(); ++it) {
00443                 ptr<alloc_interval> interval = *it;
00444                 
00445                 ptr<ge_operand_reg> operand = interval->operand_get();
00446                 
00447                 if ( interval->allocated_reg_get() ) {
00448                         //Operand has register assigned.
00449                         ulint assigned_register = interval->allocated_reg_get()->id_get();
00450                         
00451                         lassert(interval->allowed_registers_get()->find(assigned_register)!=interval->allowed_registers_get()->end());
00452                 
00453                         ptr<ge_pi_vector__type> instructions = interval->instructions_get();
00454                         for(ge_pi_vector__type::iterator it2 = instructions->begin(); it2!=instructions->end(); ++it2) {
00455                                 (*operand->assigned_registers_get())[*it2] = assigned_register;
00456                         }
00457                         
00458                 }       
00459         }
00460         rlog << "set_registers end\n" << eolog;
00461 }

void lestes::backend_v2::workers::linscan_regalloc::set_interval_dependencies ( )

Sets up dependencies amoung dependent intervals.

If two intervals uses the same register, it is needed to not allow them to overlap. It is done by setting dependence of a first pseudoinstruction of the second interval on a last pseudoinstruction of the second interval.

Definition at line 409 of file linscan_regalloc.cc.

References expired_intervals.

Referenced by get_result().

00409                                                  {
00410         rlog << "set_dependencies start\n" << eolog;
00411         /*
00412                 If an interval B pick over register or spillplace of another interval A, it is important that the intervals
00413                 don't overlap and they are executed in the right order (A->B). It is accomplished by setting dependencies
00414                 among instructions of intervals.
00415         */
00416         for(alloc_int_vector__type::iterator it = expired_intervals->begin(); it!=expired_intervals->end(); ++it) {
00417                 ptr<alloc_interval> interval = *it;
00418                 ptr<alloc_interval> alloc_obj_prev_owner = interval->allocated_obj_prev_owner_get();
00419                 
00420                 if ( alloc_obj_prev_owner ) {
00421                         ptr<ge_pi> ge1 = alloc_obj_prev_owner->instructions_get()->back();
00422                         ptr<ge_pi> ge2 = interval->instructions_get()->front();
00423                         
00424                         if ( ge1->bb_get()==ge2->bb_get() ) {
00425                                 ge2->dependencies_get()->insert(ge1);
00426                         }
00427                 }
00428         }
00429         
00430         rlog << "set_dependencies end\n" << eolog;
00431 }

ptr< ::lestes::md::registers::tm_register > lestes::backend_v2::workers::linscan_regalloc::get_destroyed_register ( ptr< ::lestes::backend_v2::intercode::ge_operand_reg > op )

void lestes::backend_v2::workers::linscan_regalloc::set_destroyed_register	(	ptr< ::lestes::backend_v2::intercode::ge_pi >	ge,
		ptr< ::lestes::backend_v2::intercode::ge_operand_reg >	op,
		ptr< ::lestes::md::registers::tm_register >	reg
	)

ptr< linscan_regalloc > lestes::backend_v2::workers::linscan_regalloc::create	(	ptr< ::lestes::backend_v2::structs::func_data >	a__worker_base__data,
		ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__linscan_regalloc__active_intervals,
		ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__linscan_regalloc__expired_intervals,
		ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__linscan_regalloc__waiting_intervals,
		ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__linscan_regalloc__register_owners,
		ptr< ::lestes::std::set< ulint > >	a__linscan_regalloc__free_registers,
		ptr< ::lestes::std::set< ulint > >	a__linscan_regalloc__used_registers,
		ptr< ::lestes::std::set< ulint > >	a__linscan_regalloc__all_registers,
		ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::md::registers::tm_register > > >	a__linscan_regalloc__destroyers
	)			`[static]`

First generated factory method for class linscan_regalloc.

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

Author:: lsg

Definition at line 174 of file linscan_regalloc.g.cc.

References linscan_regalloc().

Referenced by create().

00183 {
00184         return ptr< linscan_regalloc > ( new linscan_regalloc(a__worker_base__data,
00185                 a__linscan_regalloc__active_intervals,
00186                 a__linscan_regalloc__expired_intervals,
00187                 a__linscan_regalloc__waiting_intervals,
00188                 a__linscan_regalloc__register_owners,
00189                 a__linscan_regalloc__free_registers,
00190                 a__linscan_regalloc__used_registers,
00191                 a__linscan_regalloc__all_registers,
00192                 a__linscan_regalloc__destroyers) );
00193 }

ptr< linscan_regalloc > lestes::backend_v2::workers::linscan_regalloc::create ( ptr< ::lestes::backend_v2::structs::func_data > a__worker_base__data ) [static]

Second generated factory method for class linscan_regalloc.

This factory method for class linscan_regalloc uses initializers.

Author:: lsg

Definition at line 199 of file linscan_regalloc.g.cc.

References create(), and linscan_regalloc().

00200 {
00201         return ptr< linscan_regalloc > ( new linscan_regalloc(a__worker_base__data, ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > ::create(), ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > ::create(), NULL, ::lestes::std::map< ulint, srp< ::lestes::backend_v2::workers::alloc_interval > > ::create(), ::lestes::std::set< ulint > ::create(), ::lestes::std::set< ulint > ::create(), ::lestes::std::set< ulint > ::create(), ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::md::registers::tm_register > > ::create()) );
00202 }

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

for purposes of dumping

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

Definition at line 220 of file linscan_regalloc.g.cc.

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

00221 {
00222         if (!reflection) {
00223                 typedef class_reflection::field_metadata md;
00224                 typedef class_reflection::field_metadata_list mdlist;
00225                 ptr<mdlist> mdl = mdlist::create();
00226                 mdl->push_back( md::create( "active_intervals", "vector&lt; srp&lt; ::lestes::backend_v2::workers::alloc_interval &gt; &gt;" ) );
00227                 mdl->push_back( md::create( "expired_intervals", "vector&lt; srp&lt; ::lestes::backend_v2::workers::alloc_interval &gt; &gt;" ) );
00228                 mdl->push_back( md::create( "waiting_intervals", "vector&lt; srp&lt; ::lestes::backend_v2::workers::alloc_interval &gt; &gt;" ) );
00229                 mdl->push_back( md::create( "register_owners", "map&lt; ulint, srp&lt; ::lestes::backend_v2::workers::alloc_interval &gt; &gt;" ) );
00230                 mdl->push_back( md::create( "free_registers", "set&lt; ulint &gt;" ) );
00231                 mdl->push_back( md::create( "used_registers", "set&lt; ulint &gt;" ) );
00232                 mdl->push_back( md::create( "all_registers", "set&lt; ulint &gt;" ) );
00233                 mdl->push_back( md::create( "destroyers", "map&lt; srp&lt; ::lestes::backend_v2::intercode::ge_operand_reg &gt;, srp&lt; ::lestes::md::registers::tm_register &gt; &gt;" ) );
00234                 reflection = reflection_list::create( worker_base::reflection_get() );
00235                 reflection->push_back( class_reflection::create( "linscan_regalloc", mdl ) );
00236         }
00237         return reflection;
00238 }

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

for purposes of dumping

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

Definition at line 240 of file linscan_regalloc.g.cc.

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

00241 {
00242         ptr < field_list_list > result = worker_base::field_values_get();
00243         result->push_back( value_list::create() );
00244         result->back()->push_back( this->active_intervals );
00245         result->push_back( value_list::create() );
00246         result->back()->push_back( this->expired_intervals );
00247         result->push_back( value_list::create() );
00248         result->back()->push_back( this->waiting_intervals );
00249         result->push_back( value_list::create() );
00250         result->back()->push_back( this->register_owners );
00251         result->push_back( value_list::create() );
00252         result->back()->push_back( this->free_registers );
00253         result->push_back( value_list::create() );
00254         result->back()->push_back( this->used_registers );
00255         result->push_back( value_list::create() );
00256         result->back()->push_back( this->all_registers );
00257         result->push_back( value_list::create() );
00258         result->back()->push_back( this->destroyers );
00259         return result;
00260 }

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

Marking routine for class linscan_regalloc.

Marking routine is used for garbage collection.

Author:: lsg

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

Definition at line 267 of file linscan_regalloc.g.cc.

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

00268 {
00269         worker_base::gc_mark();
00270 }

Member Data Documentation

srp< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > lestes::backend_v2::workers::linscan_regalloc::active_intervals [private]

A list of active intervals.

Definition at line 200 of file linscan_regalloc.g.hh.

Referenced by active_intervals_get(), active_intervals_set(), and process().

srp< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > lestes::backend_v2::workers::linscan_regalloc::expired_intervals [private]

A list of already processed intervals.

Definition at line 202 of file linscan_regalloc.g.hh.

Referenced by expired_intervals_get(), expired_intervals_set(), get_result(), process(), set_interval_dependencies(), and set_registers_to_operands().

srp< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > lestes::backend_v2::workers::linscan_regalloc::waiting_intervals [private]

A list of intervals witing for processing.

Definition at line 204 of file linscan_regalloc.g.hh.

Referenced by process(), waiting_intervals_get(), and waiting_intervals_set().

srp< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::workers::alloc_interval > > > lestes::backend_v2::workers::linscan_regalloc::register_owners [private]

A map that holds information about which interval has which register allocated.

Definition at line 206 of file linscan_regalloc.g.hh.

Referenced by process(), register_owners_get(), and register_owners_set().

srp< ::lestes::std::set< ulint > > lestes::backend_v2::workers::linscan_regalloc::free_registers [private]

A set of free registers.

Definition at line 208 of file linscan_regalloc.g.hh.

Referenced by find_free_registers(), free_registers_get(), and free_registers_set().

srp< ::lestes::std::set< ulint > > lestes::backend_v2::workers::linscan_regalloc::used_registers [private]

A set of used registers.

Definition at line 210 of file linscan_regalloc.g.hh.

Referenced by find_free_registers(), used_registers_get(), and used_registers_set().

srp< ::lestes::std::set< ulint > > lestes::backend_v2::workers::linscan_regalloc::all_registers [private]

A set of all the registers that machine description contains.

Definition at line 212 of file linscan_regalloc.g.hh.

Referenced by all_registers_get(), all_registers_set(), find_free_registers(), and setup_registers().

srp< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::md::registers::tm_register > > > lestes::backend_v2::workers::linscan_regalloc::destroyers [private]

A map that holds information about whitch register is destroyed by which operand.

Definition at line 214 of file linscan_regalloc.g.hh.

Referenced by destroyers_get(), destroyers_set(), and process().

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

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

Definition at line 215 of file linscan_regalloc.g.hh.

Referenced by reflection_get().

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

Generated on Mon Feb 12 18:24:10 2007 for lestes by

1.5.1-20070107

lestes::backend_v2::workers::linscan_regalloc Class Reference

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation