lestes::backend_v2::workers::spillgen Class Reference

Performs spillgen generation. More...

#include <spillgen.g.hh>

Inheritance diagram for lestes::backend_v2::workers::spillgen:


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 spillgen::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 spillgen::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 spillgen::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 spillgen::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 spillgen::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 spillgen::waiting_intervals to the given value.
ptr< ::lestes::std::set< ulint > >	free_registers_get () const
	The method free_registers_get returns the value of the field spillgen::free_registers.
void	free_registers_set (const ptr< ::lestes::std::set< ulint > > &)
	The method free_registers_set sets the field spillgen::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 spillgen::used_registers.
void	used_registers_set (const ptr< ::lestes::std::set< ulint > > &)
	The method used_registers_set sets the field spillgen::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 spillgen::all_registers.
void	all_registers_set (const ptr< ::lestes::std::set< ulint > > &)
	The method all_registers_set sets the field spillgen::all_registers 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 spillgen::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 spillgen::register_owners to the given value.
ptr< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::pi_mem_factory > > >	free_spill_spaces_get () const
	The method free_spill_spaces_get returns the value of the field spillgen::free_spill_spaces.
void	free_spill_spaces_set (const ptr< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::pi_mem_factory > > > &)
	The method free_spill_spaces_set sets the field spillgen::free_spill_spaces to the given value.
ptr< ::lestes::md::registers::move_generator >	move_gen_get () const
	The method move_gen_get returns the value of the field spillgen::move_gen.
void	move_gen_set (const ptr< ::lestes::md::registers::move_generator > &)
	The method move_gen_set sets the field spillgen::move_gen to the given value.
bool	registers_freed_get () const
	The method registers_freed_get returns the value of the field spillgen::registers_freed.
void	registers_freed_set (bool)
	The method registers_freed_set sets the field spillgen::registers_freed to the given value.
ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::pi_mem_factory >, srp< ::lestes::backend_v2::intercode::ge_pi > > >	spill_space_last_use_get () const
	The method spill_space_last_use_get returns the value of the field spillgen::spill_space_last_use.
void	spill_space_last_use_set (const ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::pi_mem_factory >, srp< ::lestes::backend_v2::intercode::ge_pi > > > &)
	The method spill_space_last_use_set sets the field spillgen::spill_space_last_use to the given value.
ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::intercode::ge_pi > > >	register_last_use_get () const
	The method register_last_use_get returns the value of the field spillgen::register_last_use.
void	register_last_use_set (const ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::intercode::ge_pi > > > &)
	The method register_last_use_set sets the field spillgen::register_last_use to the given value.
ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::backend_v2::workers::alloc_interval > > >	op2interval_get () const
	The method op2interval_get returns the value of the field spillgen::op2interval.
void	op2interval_set (const ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::backend_v2::workers::alloc_interval > > > &)
	The method op2interval_set sets the field spillgen::op2interval to the given value.
ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< spillgen_group > > >	op2group_get () const
	The method op2group_get returns the value of the field spillgen::op2group.
void	op2group_set (const ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< spillgen_group > > > &)
	The method op2group_set sets the field spillgen::op2group to the given value.
ptr< ::lestes::std::list< srp< spillgen_group > > >	groups_get () const
	The method groups_get returns the value of the field spillgen::groups.
void	groups_set (const ptr< ::lestes::std::list< srp< spillgen_group > > > &)
	The method groups_set sets the field spillgen::groups to the given value.
ptr< ::lestes::std::set< ulint > >	regs_used_by_groups_get () const
	The method regs_used_by_groups_get returns the value of the field spillgen::regs_used_by_groups.
void	regs_used_by_groups_set (const ptr< ::lestes::std::set< ulint > > &)
	The method regs_used_by_groups_set sets the field spillgen::regs_used_by_groups to the given value.
ptr< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::ge_pi > > >	curr_generated_instructions_get () const
	The method curr_generated_instructions_get returns the value of the field spillgen::curr_generated_instructions.
void	curr_generated_instructions_set (const ptr< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::ge_pi > > > &)
	The method curr_generated_instructions_set sets the field spillgen::curr_generated_instructions to the given value.
void	process ()
	Performs spill-code generation on a function body.
ptr< ::lestes::backend_v2::structs::func_data >	get_result ()
	Returns data of the processed function with spill-code included.
ptr< ::lestes::backend_v2::intercode::ge_pi >	find_last_use_of_register (ulint regid)
	Returns a pseudoinstruction that is the last user of a register.
void	set_last_use_of_register (ulint regid, ptr< ::lestes::backend_v2::intercode::ge_pi > ge)
void	process_instruction (ptr< ::lestes::backend_v2::intercode::ge_pi > ge, ptr< list< srp< ::lestes::backend_v2::intercode::ge_pi > > > output, list< srp< ::lestes::backend_v2::intercode::ge_pi > >::iterator insert_pos)
void	generate_spill_code (ptr< ::lestes::backend_v2::intercode::ge_pi > ge, ptr< list< srp< ::lestes::backend_v2::intercode::ge_pi > > > output, list< srp< ::lestes::backend_v2::intercode::ge_pi > >::iterator insert_pos)
ptr< vector< srp< ::lestes::backend_v2::intercode::ge_pi > > >	generate_backup_code (ptr< ::lestes::backend_v2::intercode::ge_pi > ge, ptr< spillgen_group > group, ptr< set< srp< ::lestes::backend_v2::workers::alloc_interval > > > reg_orig_owners)
ptr< vector< srp< ::lestes::backend_v2::intercode::ge_pi > > >	generate_restore_code (ptr< ::lestes::backend_v2::intercode::ge_pi > ge, ptr< spillgen_group > group, ptr< set< srp< ::lestes::backend_v2::workers::alloc_interval > > > reg_orig_owners)
ptr< vector< srp< ::lestes::backend_v2::intercode::ge_pi > > >	generate_load_code (ptr< ::lestes::backend_v2::intercode::ge_pi > ge, ptr< spillgen_group > group, ptr< ::lestes::backend_v2::workers::alloc_interval > interval, ptr< ::lestes::backend_v2::intercode::ge_operand_reg > operand, ptr< ::lestes::md::registers::tm_register > reg)
ptr< vector< srp< ::lestes::backend_v2::intercode::ge_pi > > >	generate_store_code (ptr< ::lestes::backend_v2::intercode::ge_pi > ge, ptr< spillgen_group > group, ptr< ::lestes::backend_v2::workers::alloc_interval > interval, ptr< ::lestes::backend_v2::intercode::ge_operand_reg > operand, ptr< ::lestes::md::registers::tm_register > reg)
void	insert_code_to_bb (ptr< ::lestes::backend_v2::workers::basic_block > bb, ptr< vector< srp< ::lestes::backend_v2::intercode::ge_pi > > > code, bool back)
void	free_group_resources ()
	Frees resources (registers,spill-places) used by spill-code generation for the currently processed instruction.
ptr< ::lestes::backend_v2::intercode::ge_pi >	interval_find_previous_instruction (ptr< ::lestes::backend_v2::workers::alloc_interval > interval, ulint pos)
ptr< ::lestes::backend_v2::intercode::ge_pi >	interval_find_next_instruction (ptr< ::lestes::backend_v2::workers::alloc_interval > interval, ulint pos)
ptr< set< srp< ::lestes::backend_v2::workers::alloc_interval > > >	find_register_owners (ptr< ::lestes::md::registers::tm_register > reg)
ptr< set< srp< ::lestes::backend_v2::workers::spillgen_group > > >	find_groups_by_reg (ptr< ::lestes::md::registers::tm_register > reg)
void	allocate_regs_for_groups ()
	Allocates registers to operand groups of a currently processed instruction.
void	allocate_reg_for_group (ptr< spillgen_group > group)
	Allocates register to a operand group of a currently processed instruction.
void	steal_register_from_siblings (ptr< spillgen_group > thief, ptr< set< ulint > > allowed_regs)
bool	identify_groups (ptr< ::lestes::backend_v2::intercode::ge_pi > ge)
ptr< set< ulint > >	filter_regs_by_data_type (ptr< set< ulint > > reg_set, ulint type)
void	setup_registers ()
	Fills the all_registers set with all the available registers.
void	find_free_registers ()
	Recomputes the free_registers set.
ptr< ::lestes::backend_v2::intercode::pi_mem_factory >	get_free_spill_space (ptr< ::lestes::md::types::tm_data_type_base > type)
bool	expire_old_intervals (ulint curr_point)
	Removes intervals whoose endpoints precede a currently processed point from the active_intervals set.
bool	activate_waiting_intervals (ulint curr_point)
	Adds intervals whoose startpoints follows a currently processed point to the active_intervals set.
void	set_instruction_property (ptr< vector< srp< ::lestes::backend_v2::intercode::ge_pi > > > instrs, ulint property_id, lstring property_value)
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< spillgen >	create (ptr< ::lestes::backend_v2::structs::func_data > a__worker_base__data, ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > a__spillgen__active_intervals, ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > a__spillgen__expired_intervals, ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > a__spillgen__waiting_intervals, ptr< ::lestes::std::set< ulint > > a__spillgen__free_registers, ptr< ::lestes::std::set< ulint > > a__spillgen__used_registers, ptr< ::lestes::std::set< ulint > > a__spillgen__all_registers, ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::workers::alloc_interval > > > a__spillgen__register_owners, ptr< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::pi_mem_factory > > > a__spillgen__free_spill_spaces, ptr< ::lestes::md::registers::move_generator > a__spillgen__move_gen, bool a__spillgen__registers_freed, ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::pi_mem_factory >, srp< ::lestes::backend_v2::intercode::ge_pi > > > a__spillgen__spill_space_last_use, ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::intercode::ge_pi > > > a__spillgen__register_last_use, ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::backend_v2::workers::alloc_interval > > > a__spillgen__op2interval, ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< spillgen_group > > > a__spillgen__op2group, ptr< ::lestes::std::list< srp< spillgen_group > > > a__spillgen__groups, ptr< ::lestes::std::set< ulint > > a__spillgen__regs_used_by_groups, ptr< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::ge_pi > > > a__spillgen__curr_generated_instructions)
	First generated factory method for class spillgen.
static ptr< spillgen >	create (ptr< ::lestes::backend_v2::structs::func_data > a__worker_base__data)
	Second generated factory method for class spillgen.
Protected Member Functions
	spillgen (ptr< ::lestes::backend_v2::structs::func_data > a__worker_base__data, ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > a__spillgen__active_intervals, ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > a__spillgen__expired_intervals, ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > > a__spillgen__waiting_intervals, ptr< ::lestes::std::set< ulint > > a__spillgen__free_registers, ptr< ::lestes::std::set< ulint > > a__spillgen__used_registers, ptr< ::lestes::std::set< ulint > > a__spillgen__all_registers, ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::workers::alloc_interval > > > a__spillgen__register_owners, ptr< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::pi_mem_factory > > > a__spillgen__free_spill_spaces, ptr< ::lestes::md::registers::move_generator > a__spillgen__move_gen, bool a__spillgen__registers_freed, ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::pi_mem_factory >, srp< ::lestes::backend_v2::intercode::ge_pi > > > a__spillgen__spill_space_last_use, ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::intercode::ge_pi > > > a__spillgen__register_last_use, ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::backend_v2::workers::alloc_interval > > > a__spillgen__op2interval, ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< spillgen_group > > > a__spillgen__op2group, ptr< ::lestes::std::list< srp< spillgen_group > > > a__spillgen__groups, ptr< ::lestes::std::set< ulint > > a__spillgen__regs_used_by_groups, ptr< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::ge_pi > > > a__spillgen__curr_generated_instructions)
	Generated constructor for class spillgen.
virtual void	gc_mark ()
	Marking routine for class spillgen.
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::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< 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< srp< ::lestes::backend_v2::intercode::pi_mem_factory > > >	free_spill_spaces
	A set of free spill-places.
srp< ::lestes::md::registers::move_generator >	move_gen
	Provides generation of copy-code between register and memory.
bool	registers_freed
srp< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::pi_mem_factory >, srp< ::lestes::backend_v2::intercode::ge_pi > > >	spill_space_last_use
	A map between a spill-space and its last use.
srp< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::intercode::ge_pi > > >	register_last_use
	A map between a register and its last use.
srp< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::backend_v2::workers::alloc_interval > > >	op2interval
	A map between an operand and its active interval.
srp< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< spillgen_group > > >	op2group
	A map between an operand and its active group.
srp< ::lestes::std::list< srp< spillgen_group > > >	groups
	Active groups.
srp< ::lestes::std::set< ulint > >	regs_used_by_groups
	A set of registers used by active groups.
srp< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::ge_pi > > >	curr_generated_instructions
	A spill-code that has been generated for a current intruction.
Static Private Attributes
static ptr< reflection_list >	reflection = reflection

Detailed Description

Performs spillgen generation.

Definition at line 115 of file spillgen.g.hh.

Constructor & Destructor Documentation

lestes::backend_v2::workers::spillgen::spillgen	(	ptr< ::lestes::backend_v2::structs::func_data >	a__worker_base__data,
		ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__spillgen__active_intervals,
		ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__spillgen__expired_intervals,
		ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__spillgen__waiting_intervals,
		ptr< ::lestes::std::set< ulint > >	a__spillgen__free_registers,
		ptr< ::lestes::std::set< ulint > >	a__spillgen__used_registers,
		ptr< ::lestes::std::set< ulint > >	a__spillgen__all_registers,
		ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__spillgen__register_owners,
		ptr< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::pi_mem_factory > > >	a__spillgen__free_spill_spaces,
		ptr< ::lestes::md::registers::move_generator >	a__spillgen__move_gen,
		bool	a__spillgen__registers_freed,
		ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::pi_mem_factory >, srp< ::lestes::backend_v2::intercode::ge_pi > > >	a__spillgen__spill_space_last_use,
		ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::intercode::ge_pi > > >	a__spillgen__register_last_use,
		ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__spillgen__op2interval,
		ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< spillgen_group > > >	a__spillgen__op2group,
		ptr< ::lestes::std::list< srp< spillgen_group > > >	a__spillgen__groups,
		ptr< ::lestes::std::set< ulint > >	a__spillgen__regs_used_by_groups,
		ptr< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::ge_pi > > >	a__spillgen__curr_generated_instructions
	)			`[protected]`

Generated constructor for class spillgen.

Author:: lsg

Definition at line 392 of file spillgen.g.cc.

Referenced by create().

00410         : worker_base(a__worker_base__data), active_intervals(checked(a__spillgen__active_intervals)), expired_intervals(checked(a__spillgen__expired_intervals)), waiting_intervals(a__spillgen__waiting_intervals), free_registers(checked(a__spillgen__free_registers)), used_registers(checked(a__spillgen__used_registers)), all_registers(checked(a__spillgen__all_registers)), register_owners(checked(a__spillgen__register_owners)), free_spill_spaces(checked(a__spillgen__free_spill_spaces)), move_gen(a__spillgen__move_gen), registers_freed(a__spillgen__registers_freed), spill_space_last_use(checked(a__spillgen__spill_space_last_use)), register_last_use(checked(a__spillgen__register_last_use)), op2interval(checked(a__spillgen__op2interval)), op2group(checked(a__spillgen__op2group)), groups(checked(a__spillgen__groups)), regs_used_by_groups(checked(a__spillgen__regs_used_by_groups)), curr_generated_instructions(checked(a__spillgen__curr_generated_instructions))
00411 {}

Member Function Documentation

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

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

Returns:: The value of spillgen::active_intervals.

Author:: lsg

Definition at line 34 of file spillgen.g.cc.

References active_intervals.

00035 {
00036         return active_intervals;
00037 }

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

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

Parameters:

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

Author:: lsg

Definition at line 43 of file spillgen.g.cc.

References active_intervals.

00044 {
00045         spillgen::active_intervals = x;
00046 }

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

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

Returns:: The value of spillgen::expired_intervals.

Author:: lsg

Definition at line 52 of file spillgen.g.cc.

References expired_intervals.

00053 {
00054         return expired_intervals;
00055 }

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

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

Parameters:

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

Author:: lsg

Definition at line 61 of file spillgen.g.cc.

References expired_intervals.

00062 {
00063         spillgen::expired_intervals = x;
00064 }

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

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

Returns:: The value of spillgen::waiting_intervals.

Author:: lsg

Definition at line 70 of file spillgen.g.cc.

References waiting_intervals.

00071 {
00072         return waiting_intervals;
00073 }

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

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

Parameters:

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

Author:: lsg

Definition at line 79 of file spillgen.g.cc.

References waiting_intervals.

00080 {
00081         spillgen::waiting_intervals = x;
00082 }

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

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

Returns:: The value of spillgen::free_registers.

Author:: lsg

Definition at line 88 of file spillgen.g.cc.

References free_registers.

00089 {
00090         return free_registers;
00091 }

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

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

Parameters:

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

Author:: lsg

Definition at line 97 of file spillgen.g.cc.

References free_registers.

00098 {
00099         spillgen::free_registers = x;
00100 }

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

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

Returns:: The value of spillgen::used_registers.

Author:: lsg

Definition at line 106 of file spillgen.g.cc.

References used_registers.

00107 {
00108         return used_registers;
00109 }

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

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

Parameters:

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

Author:: lsg

Definition at line 115 of file spillgen.g.cc.

References used_registers.

00116 {
00117         spillgen::used_registers = x;
00118 }

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

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

Returns:: The value of spillgen::all_registers.

Author:: lsg

Definition at line 124 of file spillgen.g.cc.

References all_registers.

00125 {
00126         return all_registers;
00127 }

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

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

Parameters:

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

Author:: lsg

Definition at line 133 of file spillgen.g.cc.

References all_registers.

00134 {
00135         spillgen::all_registers = x;
00136 }

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

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

Returns:: The value of spillgen::register_owners.

Author:: lsg

Definition at line 142 of file spillgen.g.cc.

References register_owners.

00143 {
00144         return register_owners;
00145 }

void lestes::backend_v2::workers::spillgen::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 spillgen::register_owners to the given value.

Parameters:

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

Author:: lsg

Definition at line 151 of file spillgen.g.cc.

References register_owners.

00152 {
00153         spillgen::register_owners = x;
00154 }

ptr<::lestes::std::set< srp<::lestes::backend_v2::intercode::pi_mem_factory > > > lestes::backend_v2::workers::spillgen::free_spill_spaces_get ( ) const

The method free_spill_spaces_get returns the value of the field spillgen::free_spill_spaces.

Returns:: The value of spillgen::free_spill_spaces.

Author:: lsg

Definition at line 160 of file spillgen.g.cc.

References free_spill_spaces.

00161 {
00162         return free_spill_spaces;
00163 }

void lestes::backend_v2::workers::spillgen::free_spill_spaces_set ( const ptr< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::pi_mem_factory > > > & x )

The method free_spill_spaces_set sets the field spillgen::free_spill_spaces to the given value.

Parameters:

[in] x The new value to set spillgen::free_spill_spaces to.

Author:: lsg

Definition at line 169 of file spillgen.g.cc.

References free_spill_spaces.

00170 {
00171         spillgen::free_spill_spaces = x;
00172 }

ptr<::lestes::md::registers::move_generator > lestes::backend_v2::workers::spillgen::move_gen_get ( ) const

The method move_gen_get returns the value of the field spillgen::move_gen.

Returns:: The value of spillgen::move_gen.

Author:: lsg

Definition at line 178 of file spillgen.g.cc.

References move_gen.

00179 {
00180         return move_gen;
00181 }

void lestes::backend_v2::workers::spillgen::move_gen_set ( const ptr< ::lestes::md::registers::move_generator > & x )

The method move_gen_set sets the field spillgen::move_gen to the given value.

Parameters:

[in] x The new value to set spillgen::move_gen to.

Author:: lsg

Definition at line 187 of file spillgen.g.cc.

References move_gen.

00188 {
00189         spillgen::move_gen = x;
00190 }

bool lestes::backend_v2::workers::spillgen::registers_freed_get ( ) const

The method registers_freed_get returns the value of the field spillgen::registers_freed.

Returns:: The value of spillgen::registers_freed.

Author:: lsg

Definition at line 196 of file spillgen.g.cc.

References registers_freed.

00197 {
00198         return registers_freed;
00199 }

void lestes::backend_v2::workers::spillgen::registers_freed_set ( bool x )

The method registers_freed_set sets the field spillgen::registers_freed to the given value.

Parameters:

[in] x The new value to set spillgen::registers_freed to.

Author:: lsg

Definition at line 205 of file spillgen.g.cc.

References registers_freed.

00206 {
00207         spillgen::registers_freed = x;
00208 }

ptr<::lestes::std::map< srp<::lestes::backend_v2::intercode::pi_mem_factory >, srp<::lestes::backend_v2::intercode::ge_pi > > > lestes::backend_v2::workers::spillgen::spill_space_last_use_get ( ) const

The method spill_space_last_use_get returns the value of the field spillgen::spill_space_last_use.

Returns:: The value of spillgen::spill_space_last_use.

Author:: lsg

Definition at line 214 of file spillgen.g.cc.

References spill_space_last_use.

00215 {
00216         return spill_space_last_use;
00217 }

void lestes::backend_v2::workers::spillgen::spill_space_last_use_set ( const ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::pi_mem_factory >, srp< ::lestes::backend_v2::intercode::ge_pi > > > & x )

The method spill_space_last_use_set sets the field spillgen::spill_space_last_use to the given value.

Parameters:

[in] x The new value to set spillgen::spill_space_last_use to.

Author:: lsg

Definition at line 223 of file spillgen.g.cc.

References spill_space_last_use.

00224 {
00225         spillgen::spill_space_last_use = x;
00226 }

ptr<::lestes::std::map< ulint, srp<::lestes::backend_v2::intercode::ge_pi > > > lestes::backend_v2::workers::spillgen::register_last_use_get ( ) const

The method register_last_use_get returns the value of the field spillgen::register_last_use.

Returns:: The value of spillgen::register_last_use.

Author:: lsg

Definition at line 232 of file spillgen.g.cc.

References register_last_use.

00233 {
00234         return register_last_use;
00235 }

void lestes::backend_v2::workers::spillgen::register_last_use_set ( const ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::intercode::ge_pi > > > & x )

The method register_last_use_set sets the field spillgen::register_last_use to the given value.

Parameters:

[in] x The new value to set spillgen::register_last_use to.

Author:: lsg

Definition at line 241 of file spillgen.g.cc.

References register_last_use.

00242 {
00243         spillgen::register_last_use = x;
00244 }

ptr<::lestes::std::map< srp<::lestes::backend_v2::intercode::ge_operand_reg >, srp<::lestes::backend_v2::workers::alloc_interval > > > lestes::backend_v2::workers::spillgen::op2interval_get ( ) const

The method op2interval_get returns the value of the field spillgen::op2interval.

Returns:: The value of spillgen::op2interval.

Author:: lsg

Definition at line 250 of file spillgen.g.cc.

References op2interval.

00251 {
00252         return op2interval;
00253 }

void lestes::backend_v2::workers::spillgen::op2interval_set ( const ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::backend_v2::workers::alloc_interval > > > & x )

The method op2interval_set sets the field spillgen::op2interval to the given value.

Parameters:

[in] x The new value to set spillgen::op2interval to.

Author:: lsg

Definition at line 259 of file spillgen.g.cc.

References op2interval.

00260 {
00261         spillgen::op2interval = x;
00262 }

ptr<::lestes::std::map< srp<::lestes::backend_v2::intercode::ge_operand_reg >, srp< spillgen_group > > > lestes::backend_v2::workers::spillgen::op2group_get ( ) const

The method op2group_get returns the value of the field spillgen::op2group.

Returns:: The value of spillgen::op2group.

Author:: lsg

Definition at line 268 of file spillgen.g.cc.

References op2group.

00269 {
00270         return op2group;
00271 }

void lestes::backend_v2::workers::spillgen::op2group_set ( const ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< spillgen_group > > > & x )

The method op2group_set sets the field spillgen::op2group to the given value.

Parameters:

[in] x The new value to set spillgen::op2group to.

Author:: lsg

Definition at line 277 of file spillgen.g.cc.

References op2group.

00278 {
00279         spillgen::op2group = x;
00280 }

ptr<::lestes::std::list< srp< spillgen_group > > > lestes::backend_v2::workers::spillgen::groups_get ( ) const

The method groups_get returns the value of the field spillgen::groups.

Returns:: The value of spillgen::groups.

Author:: lsg

Definition at line 286 of file spillgen.g.cc.

References groups.

00287 {
00288         return groups;
00289 }

void lestes::backend_v2::workers::spillgen::groups_set ( const ptr< ::lestes::std::list< srp< spillgen_group > > > & x )

The method groups_set sets the field spillgen::groups to the given value.

Parameters:

[in] x The new value to set spillgen::groups to.

Author:: lsg

Definition at line 295 of file spillgen.g.cc.

References groups.

00296 {
00297         spillgen::groups = x;
00298 }

ptr<::lestes::std::set< ulint > > lestes::backend_v2::workers::spillgen::regs_used_by_groups_get ( ) const

The method regs_used_by_groups_get returns the value of the field spillgen::regs_used_by_groups.

Returns:: The value of spillgen::regs_used_by_groups.

Author:: lsg

Definition at line 304 of file spillgen.g.cc.

References regs_used_by_groups.

00305 {
00306         return regs_used_by_groups;
00307 }

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

The method regs_used_by_groups_set sets the field spillgen::regs_used_by_groups to the given value.

Parameters:

[in] x The new value to set spillgen::regs_used_by_groups to.

Author:: lsg

Definition at line 313 of file spillgen.g.cc.

References regs_used_by_groups.

00314 {
00315         spillgen::regs_used_by_groups = x;
00316 }

ptr<::lestes::std::set< srp<::lestes::backend_v2::intercode::ge_pi > > > lestes::backend_v2::workers::spillgen::curr_generated_instructions_get ( ) const

The method curr_generated_instructions_get returns the value of the field spillgen::curr_generated_instructions.

Returns:: The value of spillgen::curr_generated_instructions.

Author:: lsg

Definition at line 322 of file spillgen.g.cc.

References curr_generated_instructions.

00323 {
00324         return curr_generated_instructions;
00325 }

void lestes::backend_v2::workers::spillgen::curr_generated_instructions_set ( const ptr< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::ge_pi > > > & x )

The method curr_generated_instructions_set sets the field spillgen::curr_generated_instructions to the given value.

Parameters:

[in] x The new value to set spillgen::curr_generated_instructions to.

Author:: lsg

Definition at line 331 of file spillgen.g.cc.

References curr_generated_instructions.

00332 {
00333         spillgen::curr_generated_instructions = x;
00334 }

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

Performs spill-code generation on a function body.

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

Definition at line 55 of file spillgen.cc.

References activate_waiting_intervals(), lestes::backend_v2::workers::alloc_int_cmp1(), lestes::backend_v2::workers::worker_base::data_get(), lestes::msg::eolog, expire_old_intervals(), find_free_registers(), lassert, move_gen, process_instruction(), setup_registers(), and waiting_intervals.

00055                        {
00056         slog << "process start\n" << eolog;
00057 
00058         move_gen = move_generator::create();
00059         
00060         //Set all available registers free.
00061         setup_registers();      
00062         
00063         //Get intervals for spillcode generation.
00064         waiting_intervals = alloc_int_vector__type::create(data_get()->alloc_ints_get());
00065         
00066         //Sort intervals by increasing start point
00067         ::std::sort(waiting_intervals->begin(),waiting_intervals->end(),alloc_int_cmp1);
00068         
00069         /*
00070                 Go through function's body and generate spill code.
00071         */
00072         ptr<ge_pi_list__type> body = data_get()->ge_body_get();
00073         
00074         /*
00075                 Code is to be inserted between current and next instruction. 
00076                 Backup pointer to the next instruction in order to not process inserted code.
00077         */
00078         ge_pi_list__type::iterator it_next;
00079         
00080         for(ge_pi_list__type::iterator it = body->begin(); it!=body->end();) {
00081                 ptr<ge_pi> ge = *it;
00082                 
00083                 it_next = it;
00084                 ++it_next;
00085                 
00086                 //Remove overaged (interval->end < ge->schedule_pos) intervals from the active set.
00087                 expire_old_intervals(ge->schedule_pos_get());
00088                 
00089                 //Activate waiting intervals (interval->start <= ge->schedule_pos)
00090                 activate_waiting_intervals(ge->schedule_pos_get());
00091                 
00092                 //Recompute free register set according to used register set.
00093                 find_free_registers();
00094                 
00095                 //Generate spill code for instruction.
00096                 process_instruction(ge,body,it); 
00097                 
00098                 it = it_next;
00099         }
00100 
00101         lassert(waiting_intervals->size()==0);
00102         
00103         slog << "process end\n" << eolog;
00104 }

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

Returns data of the processed function with spill-code included.

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

Definition at line 1492 of file spillgen.cc.

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

01492                                                              {
01493         slog << "get_result start\n" << eolog;
01494 
01495         slog << "get_result end\n" << eolog;
01496         return data_get();
01497 }

ptr< ge_pi > lestes::backend_v2::workers::spillgen::find_last_use_of_register ( ulint regid )

Returns a pseudoinstruction that is the last user of a register.

Parameters:

regid

The register.

Returns:: The last user.

Definition at line 1424 of file spillgen.cc.

References register_last_use.

Referenced by expire_old_intervals().

01424                                                           {
01425         slog << "find_last_use_of_register start\n" << eolog;
01426         
01427         reg2ge_pi__type::iterator it = register_last_use->find(regid);
01428         
01429         slog << "find_last_use_of_register end\n" << eolog;
01430         return it==register_last_use->end() ? NULL : it->second;
01431 }

void lestes::backend_v2::workers::spillgen::set_last_use_of_register	(	ulint	regid,
		ptr< ::lestes::backend_v2::intercode::ge_pi >	ge
	)

Referenced by expire_old_intervals().

void lestes::backend_v2::workers::spillgen::process_instruction	(	ptr< ::lestes::backend_v2::intercode::ge_pi >	ge,
		ptr< list< srp< ::lestes::backend_v2::intercode::ge_pi > > >	output,
		list< srp< ::lestes::backend_v2::intercode::ge_pi > >::iterator	insert_pos
	)

Referenced by process().

void lestes::backend_v2::workers::spillgen::generate_spill_code	(	ptr< ::lestes::backend_v2::intercode::ge_pi >	ge,
		ptr< list< srp< ::lestes::backend_v2::intercode::ge_pi > > >	output,
		list< srp< ::lestes::backend_v2::intercode::ge_pi > >::iterator	insert_pos
	)

ptr<vector<srp< ::lestes::backend_v2::intercode::ge_pi > > > lestes::backend_v2::workers::spillgen::generate_backup_code	(	ptr< ::lestes::backend_v2::intercode::ge_pi >	ge,
		ptr< spillgen_group >	group,
		ptr< set< srp< ::lestes::backend_v2::workers::alloc_interval > > >	reg_orig_owners
	)

ptr<vector<srp< ::lestes::backend_v2::intercode::ge_pi > > > lestes::backend_v2::workers::spillgen::generate_restore_code	(	ptr< ::lestes::backend_v2::intercode::ge_pi >	ge,
		ptr< spillgen_group >	group,
		ptr< set< srp< ::lestes::backend_v2::workers::alloc_interval > > >	reg_orig_owners
	)

ptr<vector<srp< ::lestes::backend_v2::intercode::ge_pi > > > lestes::backend_v2::workers::spillgen::generate_load_code	(	ptr< ::lestes::backend_v2::intercode::ge_pi >	ge,
		ptr< spillgen_group >	group,
		ptr< ::lestes::backend_v2::workers::alloc_interval >	interval,
		ptr< ::lestes::backend_v2::intercode::ge_operand_reg >	operand,
		ptr< ::lestes::md::registers::tm_register >	reg
	)

ptr<vector<srp< ::lestes::backend_v2::intercode::ge_pi > > > lestes::backend_v2::workers::spillgen::generate_store_code	(	ptr< ::lestes::backend_v2::intercode::ge_pi >	ge,
		ptr< spillgen_group >	group,
		ptr< ::lestes::backend_v2::workers::alloc_interval >	interval,
		ptr< ::lestes::backend_v2::intercode::ge_operand_reg >	operand,
		ptr< ::lestes::md::registers::tm_register >	reg
	)

void lestes::backend_v2::workers::spillgen::insert_code_to_bb	(	ptr< ::lestes::backend_v2::workers::basic_block >	bb,
		ptr< vector< srp< ::lestes::backend_v2::intercode::ge_pi > > >	code,
		bool	back
	)

void lestes::backend_v2::workers::spillgen::free_group_resources ( )

Frees resources (registers,spill-places) used by spill-code generation for the currently processed instruction.

Definition at line 166 of file spillgen.cc.

References free_spill_spaces, and groups.

00166                                     {
00167         slog << "free_group_resources start\n" << eolog;
00168         
00169         //Setup dependencies of the previously generated spill code.
00170         for(spillgen_group_list__type::iterator it = groups->begin(); it!=groups->end(); ++it) {
00171                 ptr<spillgen_group> group = *it;
00172 
00173                 if ( group->backup_space_get() ) {                      
00174                         ptr<pi_mem_factory> mf = group->backup_space_get()->factory_get();
00175         
00176                         //Free the spill place.
00177                         free_spill_spaces->insert(mf);  
00178                 }
00179         }
00180         
00181         slog << "free_group_resources end\n" << eolog;
00182 }

ptr< ::lestes::backend_v2::intercode::ge_pi > lestes::backend_v2::workers::spillgen::interval_find_previous_instruction	(	ptr< ::lestes::backend_v2::workers::alloc_interval >	interval,
		ulint	pos
	)

ptr< ::lestes::backend_v2::intercode::ge_pi > lestes::backend_v2::workers::spillgen::interval_find_next_instruction	(	ptr< ::lestes::backend_v2::workers::alloc_interval >	interval,
		ulint	pos
	)

ptr<set<srp< ::lestes::backend_v2::workers::alloc_interval > > > lestes::backend_v2::workers::spillgen::find_register_owners ( ptr< ::lestes::md::registers::tm_register > reg )

ptr<set<srp< ::lestes::backend_v2::workers::spillgen_group > > > lestes::backend_v2::workers::spillgen::find_groups_by_reg ( ptr< ::lestes::md::registers::tm_register > reg )

void lestes::backend_v2::workers::spillgen::allocate_regs_for_groups ( )

Allocates registers to operand groups of a currently processed instruction.

Definition at line 815 of file spillgen.cc.

References allocate_reg_for_group(), and groups.

00815                                         {
00816         slog << "allocate_regs_for_groups start\n" << eolog;    
00817         
00818         spillgen_group_list__type::iterator it_stop = groups->end();
00819         spillgen_group_list__type::iterator it = groups->begin();
00820         
00821         while (true) {
00822                 if ( it_stop==it ) {
00823                         break;
00824                 }
00825                 
00826                 if ( it == groups->end() ) {
00827                         it = groups->begin();
00828                         continue;
00829                 }
00830                 
00831                 ptr<spillgen_group> group = *it;
00832                 
00833                 if ( !group->reg_get() ) {
00834                         allocate_reg_for_group(group);
00835                         it_stop = it;
00836                 }
00837                 
00838                 ++it;
00839         }
00840         
00841         slog << "allocate_regs_for_groups end\n" << eolog;      
00842 }

void lestes::backend_v2::workers::spillgen::allocate_reg_for_group ( ptr< spillgen_group > group )

Allocates register to a operand group of a currently processed instruction.

Parameters:

group

The group.

Definition at line 849 of file spillgen.cc.

References all_registers, free_registers, lassert, regs_used_by_groups, and steal_register_from_siblings().

Referenced by allocate_regs_for_groups().

00849                                                                {
00850         slog << "allocate_reg_for_group start\n" << eolog;      
00851         
00852         ptr<id_set__type> allowed_regs =  group->allowed_registers_get();
00853         ptr<id_set__type> avail_regs = id_set__type::create();
00854         
00855         ptr<tm_register> reg;
00856         
00857         while (true) {
00858                 ptr<id_set__type> avail_regs = id_set__type::create();
00859                 
00860                 //Try find available allowed registers first.
00861                 ::std::set_intersection(
00862                         free_registers->begin(),
00863                         free_registers->end(),
00864                         allowed_regs->begin(),
00865                         allowed_regs->end(),
00866                         ::std::inserter(*avail_regs, avail_regs->begin()));
00867                         
00868 
00869                 if ( avail_regs->size()==0 ) {
00870                         /*
00871                                 No free allowed register found.
00872                                 Try steal a register from operand not used within this ge_pi.
00873                         */
00874                         ptr<id_set__type> tmp = id_set__type::create();
00875                 
00876                         ::std::set_difference(
00877                                 all_registers->begin(),
00878                                 all_registers->end(),
00879                                 regs_used_by_groups->begin(),
00880                                 regs_used_by_groups->end(),
00881                                 ::std::inserter(*tmp, tmp->begin()));
00882                         
00883                         ::std::set_intersection(
00884                                 tmp->begin(),
00885                                 tmp->end(),
00886                                 allowed_regs->begin(),
00887                                 allowed_regs->end(),
00888                                 ::std::inserter(*avail_regs, avail_regs->begin()));
00889                         
00890                 }
00891                         
00892                 if ( avail_regs->size()!=0 ) {
00893                         reg = tm_register::instance(*avail_regs->begin());      
00894                         break;
00895                 }        
00896         
00897                 //No free or stolen one available. Steal one from an operand within the same ge_pi.
00898                 steal_register_from_siblings(group, allowed_regs);
00899         }
00900                 
00901         lassert(reg);
00902         lassert(allowed_regs->find(reg->id_get())!=allowed_regs->end());
00903         
00904         group->reg_set(reg);
00905         
00906         regs_used_by_groups->insert(reg->aliases_get()->begin(),reg->aliases_get()->end());
00907         
00908         ptr<id_set__type> updated_free_registers = id_set__type::create();
00909         
00910         ::std::set_difference(
00911                         all_registers->begin(),
00912                         all_registers->end(),
00913                         reg->aliases_get()->begin(),
00914                         reg->aliases_get()->end(),
00915                         ::std::inserter(*updated_free_registers,updated_free_registers->begin()));
00916                         
00917         free_registers = updated_free_registers;
00918         
00919         slog << "allocate_reg_for_group end\n" << eolog;        
00920 }

void lestes::backend_v2::workers::spillgen::steal_register_from_siblings	(	ptr< spillgen_group >	thief,
		ptr< set< ulint > >	allowed_regs
	)

Referenced by allocate_reg_for_group().

bool lestes::backend_v2::workers::spillgen::identify_groups ( ptr< ::lestes::backend_v2::intercode::ge_pi > ge )

ptr<set<ulint> > lestes::backend_v2::workers::spillgen::filter_regs_by_data_type	(	ptr< set< ulint > >	reg_set,
		ulint	type
	)

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

Fills the all_registers set with all the available registers.

Definition at line 1150 of file spillgen.cc.

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

Referenced by process().

01150                                {
01151         for(ulint i = R_UNDEFINED+1; i<RIT_TERMINATOR; ++i) {
01152                 all_registers->insert(i);
01153         }
01154 }

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

Recomputes the free_registers set.

free_registers <- all_registers - used_registers

Definition at line 1161 of file spillgen.cc.

References all_registers, free_registers, registers_freed, and used_registers.

Referenced by process().

01161                                    {
01162         slog << "find_free_registers start\n" << eolog;
01163         
01164         registers_freed = false;
01165         
01166         ptr<id_set__type> deep_used_registers = id_set__type::create();
01167         
01168         for(id_set__type::iterator it=used_registers->begin(); it!=used_registers->end(); ++it) {
01169                 ptr<tm_register> reg = tm_register::instance(*it);
01170                 
01171                 ptr<id_set__type> new_deep_used_registers = id_set__type::create();
01172                 
01173                 ::std::set_union(
01174                         reg->aliases_get()->begin(),
01175                         reg->aliases_get()->end(),
01176                         deep_used_registers->begin(),
01177                         deep_used_registers->end(),
01178                         ::std::inserter(*new_deep_used_registers,new_deep_used_registers->begin()));
01179                         
01180                 deep_used_registers = new_deep_used_registers;
01181         }
01182         
01183         ptr<id_set__type> updated_free_registers = id_set__type::create();
01184         
01185         ::std::set_difference(
01186                         all_registers->begin(),
01187                         all_registers->end(),
01188                         deep_used_registers->begin(),
01189                         deep_used_registers->end(),
01190                         ::std::inserter(*updated_free_registers,updated_free_registers->begin()));
01191                         
01192         free_registers = updated_free_registers;
01193         
01194         slog << "find_free_registers end\n" << eolog;
01195 }

ptr< ::lestes::backend_v2::intercode::pi_mem_factory > lestes::backend_v2::workers::spillgen::get_free_spill_space ( ptr< ::lestes::md::types::tm_data_type_base > type )

Referenced by expire_old_intervals().

bool lestes::backend_v2::workers::spillgen::expire_old_intervals ( ulint curr_point )

Removes intervals whoose endpoints precede a currently processed point from the active_intervals set.

Parameters:

curr_point

The current point.

Returns:: True if an interval has expired. False otherwise.

Definition at line 1282 of file spillgen.cc.

References active_intervals, expired_intervals, find_last_use_of_register(), free_spill_spaces, get_free_spill_space(), move_gen, register_owners, set_instruction_property(), set_last_use_of_register(), spill_space_last_use, and used_registers.

Referenced by process().

01282                                                     {
01283         slog << "expire_old_intervals start\n" << eolog;
01284         
01285         bool b_free_regs_need_recalculate = false;
01286         
01287         for(alloc_int_vector__type::iterator it = active_intervals->begin(); it!=active_intervals->end();) {
01288                 ptr<alloc_interval> interval = *it;
01289                 
01290                 if ( interval->end_get() < curr_point ) {
01291                         slog << "interval(id:" << interval->uid_get() << ") expired\n" << eolog;
01292                         
01293                         it = active_intervals->erase(it);                       
01294                         expired_intervals->push_back(interval);
01295                         
01296                         if ( interval->next_get() ) {
01297                                 //Copy operand's value between intervals.
01298                                 ptr<alloc_interval> next = interval->next_get();
01299                                 
01300                                 ptr<tm_register> source_reg = interval->allocated_reg_get();
01301                                 ptr<tm_register> target_reg = next->allocated_reg_get();
01302                                 
01303                                 if ( interval->allocated_spill_place_get() && !target_reg ) {
01304                                         //Reuse spill space in next interval. No copy needed.
01305                                         next->allocated_spill_place_set(interval->allocated_spill_place_get());
01306                                 } else {
01307                                         //Free spill space.
01308                                         free_spill_spaces->insert(interval->allocated_spill_place_get());
01309                                 }
01310                                 
01311                                 ptr<ge_pi_vector__type> copy_code;
01312                                 
01313                                 if ( source_reg && target_reg ) {
01314                                         //Copy value reg -> reg.
01315                                         ptr<ge_operand_reg> target_operand = ge_operand_reg::create(next->operand_get()->type_get(),NULL,NULL);
01316                                         copy_code = move_gen->generate_copy_to_register(interval->operand_get(),source_reg,target_operand,target_reg);
01317                                         target_operand->origin_set(copy_code->back());
01318                                         
01319                                         ptr<ge_pi> prev_use = find_last_use_of_register(source_reg->id_get());
01320                                         if ( prev_use ) {
01321                                                 deplog << "Q. " << copy_code->front()->uid_get() << " -> " <<  prev_use->uid_get() << "\n" << eolog;
01322                                                 copy_code->front()->dependencies_get()->insert(prev_use);
01323                                         }
01324                                         
01325                                         prev_use = find_last_use_of_register(target_reg->id_get());
01326                                         if ( prev_use ) {
01327                                                 deplog << "R. " << copy_code->front()->uid_get() << " -> " <<  prev_use->uid_get() << "\n" << eolog;
01328                                                 copy_code->front()->dependencies_get()->insert(prev_use);
01329                                         }
01330                                         
01331                                         set_last_use_of_register(source_reg->id_get(),copy_code->back());
01332                                         set_last_use_of_register(target_reg->id_get(),copy_code->back());
01333                                         
01334                                 } else if ( !source_reg && target_reg ) {
01335                                         //Copy value mem -> reg.
01336                                         ptr<pi_mem_factory> mf = interval->allocated_spill_place_get();
01337                                         ptr<ge_operand_reg> target_operand = ge_operand_reg::create(next->operand_get()->type_get(),NULL,NULL);
01338                                         ptr<ge_operand_mem> spill_place = mf->get_ge_mem(interval->instructions_get()->front());
01339                                         copy_code = move_gen->generate_load_from_memory(spill_place,target_operand,target_reg);
01340                                         target_operand->origin_set(copy_code->back());
01341                                         
01342                                         mf2ge_pi__type::iterator mf_it = spill_space_last_use->find(mf);
01343                                         if ( mf_it!=spill_space_last_use->end() ) {
01344                                                 deplog << "S. " << copy_code->front()->uid_get() << " -> " <<  mf_it->second->uid_get() << "\n" << eolog;
01345                                                 copy_code->front()->dependencies_get()->insert(mf_it->second);
01346                                         }
01347                                         
01348                                         ptr<ge_pi> prev_use = find_last_use_of_register(target_reg->id_get());
01349                                         if ( prev_use ) {
01350                                                 deplog << "T. " << copy_code->front()->uid_get() << " -> " <<  prev_use->uid_get() << "\n" << eolog;
01351                                                 copy_code->front()->dependencies_get()->insert(prev_use);
01352                                         }
01353                 
01354                                         set_last_use_of_register(target_reg->id_get(),copy_code->back());
01355                                         (*spill_space_last_use)[mf] = copy_code->back();
01356                                 } else if ( source_reg && !target_reg ) {
01357                                         //Copy value reg -> mem.
01358                                         ptr<pi_mem_factory> mf = next->allocated_spill_place_get();
01359                                         
01360                                         if ( !mf ) {
01361                                                 mf = get_free_spill_space(next->operand_get()->type_get());
01362                                                 next->allocated_spill_place_set(mf);
01363                                         }
01364                                         
01365                                         ptr<ge_operand_mem> spill_place = mf->get_ge_mem(NULL);
01366                                         copy_code = move_gen->generate_store_to_memory(interval->operand_get(),source_reg,spill_place);
01367                                         spill_place->origin_set(copy_code->back());
01368                                         
01369                                         mf2ge_pi__type::iterator mf_it = spill_space_last_use->find(mf);
01370                                         if ( mf_it!=spill_space_last_use->end() ) {
01371                                                 deplog << "U. " << copy_code->front()->uid_get() << " -> " <<  mf_it->second->uid_get() << "\n" << eolog;
01372                                                 copy_code->front()->dependencies_get()->insert(mf_it->second);
01373                                         }
01374                                         
01375                                         ptr<ge_pi> prev_use = find_last_use_of_register(source_reg->id_get());
01376                                         if ( prev_use ) {
01377                                                 deplog << "V. " << copy_code->front()->uid_get() << " -> " <<  prev_use->uid_get() << "\n" << eolog;
01378                                                 copy_code->front()->dependencies_get()->insert(prev_use);
01379                                         }
01380                 
01381                                         set_last_use_of_register(source_reg->id_get(),copy_code->back());
01382                                         (*spill_space_last_use)[mf] = copy_code->back();
01383                                 }
01384                                 
01385                                 if ( copy_code ) {
01386                                         //Insert the copy code to a basic block.
01387                                         ptr<basic_block> bb = interval->instructions_get()->back()->bb_get();
01388                                         bb->instructions_get()->insert(bb->instructions_get()->end(),copy_code->begin(),copy_code->end());
01389                                         
01390 #ifdef BACKEND_V2_DEBUG         
01391                                 ::std::ostringstream oss1;
01392                                 oss1 << "copy code between intervals (i1=" << interval->uid_get() << ", i2=" << next->uid_get() << ")";
01393                                 set_instruction_property(copy_code,ge_pi::PROPERTY_SPILLGEN_INFO,oss1.str());
01394 #endif
01395                                 }
01396                                 
01397                         } else {
01398                                 if ( interval->allocated_spill_place_get() ) {
01399                                         free_spill_spaces->insert(interval->allocated_spill_place_get());
01400                                 }
01401                         }       
01402                         
01403                         if ( interval->allocated_reg_get() && (*register_owners)[interval->allocated_reg_get()->id_get()]==interval ) {
01404                                 b_free_regs_need_recalculate = true;
01405                                 used_registers->erase(interval->allocated_reg_get()->id_get());
01406                                 register_owners->erase(interval->allocated_reg_get()->id_get());
01407                         }
01408                 } else {
01409                         ++it;
01410                 }
01411         }
01412         
01413         slog << "expire_old_intervals end\n" << eolog;
01414         
01415         return b_free_regs_need_recalculate;
01416         
01417 }

bool lestes::backend_v2::workers::spillgen::activate_waiting_intervals ( ulint curr_point )

Adds intervals whoose startpoints follows a currently processed point to the active_intervals set.

Parameters:

curr_point

The current point.

Returns:: True if an interval has been added. False otherwise.

Definition at line 1242 of file spillgen.cc.

References active_intervals, used_registers, and waiting_intervals.

Referenced by process().

01242                                                           {
01243         slog << "activate_waiting_intervals start\n" << eolog;
01244         
01245         bool b_free_regs_need_recalculate = false;
01246         
01247         for(alloc_int_vector__type::iterator it = waiting_intervals->begin(); it!=waiting_intervals->end();) {
01248                 ptr<alloc_interval> interval = *it;
01249                 
01250                 if ( interval->start_get() <= curr_point ) {
01251                         slog << "interval(id:" << interval->uid_get() << ") activated\n" << eolog;
01252                         
01253                         active_intervals->push_back(interval);
01254                         it = waiting_intervals->erase(it);
01255                         
01256                         ptr<tm_register> allocated_reg = interval->allocated_reg_get();
01257                         
01258                         if ( allocated_reg ) {
01259                                 (*register_owners)[allocated_reg->id_get()] = interval;
01260                                 used_registers->insert(allocated_reg->id_get());
01261                                 b_free_regs_need_recalculate = true;
01262                         }
01263                         
01264                         (*op2interval)[interval->operand_get()] = interval;
01265                 } else {
01266                         break;
01267                 }
01268         }
01269         
01270         slog << "activate_waiting_intervals end\n" << eolog;
01271         
01272         return b_free_regs_need_recalculate;
01273         
01274 }

void lestes::backend_v2::workers::spillgen::set_instruction_property	(	ptr< vector< srp< ::lestes::backend_v2::intercode::ge_pi > > >	instrs,
		ulint	property_id,
		lstring	property_value
	)

Referenced by expire_old_intervals().

ptr< spillgen > lestes::backend_v2::workers::spillgen::create	(	ptr< ::lestes::backend_v2::structs::func_data >	a__worker_base__data,
		ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__spillgen__active_intervals,
		ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__spillgen__expired_intervals,
		ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__spillgen__waiting_intervals,
		ptr< ::lestes::std::set< ulint > >	a__spillgen__free_registers,
		ptr< ::lestes::std::set< ulint > >	a__spillgen__used_registers,
		ptr< ::lestes::std::set< ulint > >	a__spillgen__all_registers,
		ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__spillgen__register_owners,
		ptr< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::pi_mem_factory > > >	a__spillgen__free_spill_spaces,
		ptr< ::lestes::md::registers::move_generator >	a__spillgen__move_gen,
		bool	a__spillgen__registers_freed,
		ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::pi_mem_factory >, srp< ::lestes::backend_v2::intercode::ge_pi > > >	a__spillgen__spill_space_last_use,
		ptr< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::intercode::ge_pi > > >	a__spillgen__register_last_use,
		ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::backend_v2::workers::alloc_interval > > >	a__spillgen__op2interval,
		ptr< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< spillgen_group > > >	a__spillgen__op2group,
		ptr< ::lestes::std::list< srp< spillgen_group > > >	a__spillgen__groups,
		ptr< ::lestes::std::set< ulint > >	a__spillgen__regs_used_by_groups,
		ptr< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::ge_pi > > >	a__spillgen__curr_generated_instructions
	)			`[static]`

First generated factory method for class spillgen.

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

Author:: lsg

Definition at line 340 of file spillgen.g.cc.

References spillgen().

Referenced by create().

00358 {
00359         return ptr< spillgen > ( new spillgen(a__worker_base__data,
00360                 a__spillgen__active_intervals,
00361                 a__spillgen__expired_intervals,
00362                 a__spillgen__waiting_intervals,
00363                 a__spillgen__free_registers,
00364                 a__spillgen__used_registers,
00365                 a__spillgen__all_registers,
00366                 a__spillgen__register_owners,
00367                 a__spillgen__free_spill_spaces,
00368                 a__spillgen__move_gen,
00369                 a__spillgen__registers_freed,
00370                 a__spillgen__spill_space_last_use,
00371                 a__spillgen__register_last_use,
00372                 a__spillgen__op2interval,
00373                 a__spillgen__op2group,
00374                 a__spillgen__groups,
00375                 a__spillgen__regs_used_by_groups,
00376                 a__spillgen__curr_generated_instructions) );
00377 }

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

Second generated factory method for class spillgen.

This factory method for class spillgen uses initializers.

Author:: lsg

Definition at line 383 of file spillgen.g.cc.

References create(), and spillgen().

00384 {
00385         return ptr< spillgen > ( new spillgen(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::set< ulint > ::create(), ::lestes::std::set< ulint > ::create(), ::lestes::std::set< ulint > ::create(), ::lestes::std::map< ulint, srp< ::lestes::backend_v2::workers::alloc_interval > > ::create(), ::lestes::std::set< srp< ::lestes::backend_v2::intercode::pi_mem_factory > > ::create(), NULL, false, ::lestes::std::map< srp< ::lestes::backend_v2::intercode::pi_mem_factory >, srp< ::lestes::backend_v2::intercode::ge_pi > > ::create(), ::lestes::std::map< ulint, srp< ::lestes::backend_v2::intercode::ge_pi > > ::create(), ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::backend_v2::workers::alloc_interval > > ::create(), ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< spillgen_group > > ::create(), ::lestes::std::list< srp< spillgen_group > > ::create(), ::lestes::std::set< ulint > ::create(), ::lestes::std::set< srp< ::lestes::backend_v2::intercode::ge_pi > > ::create()) );
00386 }

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

for purposes of dumping

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

Definition at line 413 of file spillgen.g.cc.

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

00414 {
00415         if (!reflection) {
00416                 typedef class_reflection::field_metadata md;
00417                 typedef class_reflection::field_metadata_list mdlist;
00418                 ptr<mdlist> mdl = mdlist::create();
00419                 mdl->push_back( md::create( "active_intervals", "vector&lt; srp&lt; ::lestes::backend_v2::workers::alloc_interval &gt; &gt;" ) );
00420                 mdl->push_back( md::create( "expired_intervals", "vector&lt; srp&lt; ::lestes::backend_v2::workers::alloc_interval &gt; &gt;" ) );
00421                 mdl->push_back( md::create( "waiting_intervals", "vector&lt; srp&lt; ::lestes::backend_v2::workers::alloc_interval &gt; &gt;" ) );
00422                 mdl->push_back( md::create( "free_registers", "set&lt; ulint &gt;" ) );
00423                 mdl->push_back( md::create( "used_registers", "set&lt; ulint &gt;" ) );
00424                 mdl->push_back( md::create( "all_registers", "set&lt; ulint &gt;" ) );
00425                 mdl->push_back( md::create( "register_owners", "map&lt; ulint, srp&lt; ::lestes::backend_v2::workers::alloc_interval &gt; &gt;" ) );
00426                 mdl->push_back( md::create( "free_spill_spaces", "set&lt; srp&lt; ::lestes::backend_v2::intercode::pi_mem_factory &gt; &gt;" ) );
00427                 mdl->push_back( md::create( "move_gen", "move_generator" ) );
00428                 mdl->push_back( md::create( "registers_freed", "bool" ) );
00429                 mdl->push_back( md::create( "spill_space_last_use", "map&lt; srp&lt; ::lestes::backend_v2::intercode::pi_mem_factory &gt;, srp&lt; ::lestes::backend_v2::intercode::ge_pi &gt; &gt;" ) );
00430                 mdl->push_back( md::create( "register_last_use", "map&lt; ulint, srp&lt; ::lestes::backend_v2::intercode::ge_pi &gt; &gt;" ) );
00431                 mdl->push_back( md::create( "op2interval", "map&lt; srp&lt; ::lestes::backend_v2::intercode::ge_operand_reg &gt;, srp&lt; ::lestes::backend_v2::workers::alloc_interval &gt; &gt;" ) );
00432                 mdl->push_back( md::create( "op2group", "map&lt; srp&lt; ::lestes::backend_v2::intercode::ge_operand_reg &gt;, srp&lt; spillgen_group &gt; &gt;" ) );
00433                 mdl->push_back( md::create( "groups", "list&lt; srp&lt; spillgen_group &gt; &gt;" ) );
00434                 mdl->push_back( md::create( "regs_used_by_groups", "set&lt; ulint &gt;" ) );
00435                 mdl->push_back( md::create( "curr_generated_instructions", "set&lt; srp&lt; ::lestes::backend_v2::intercode::ge_pi &gt; &gt;" ) );
00436                 reflection = reflection_list::create( worker_base::reflection_get() );
00437                 reflection->push_back( class_reflection::create( "spillgen", mdl ) );
00438         }
00439         return reflection;
00440 }

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

for purposes of dumping

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

Definition at line 442 of file spillgen.g.cc.

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

00443 {
00444         ptr < field_list_list > result = worker_base::field_values_get();
00445         result->push_back( value_list::create() );
00446         result->back()->push_back( this->active_intervals );
00447         result->push_back( value_list::create() );
00448         result->back()->push_back( this->expired_intervals );
00449         result->push_back( value_list::create() );
00450         result->back()->push_back( this->waiting_intervals );
00451         result->push_back( value_list::create() );
00452         result->back()->push_back( this->free_registers );
00453         result->push_back( value_list::create() );
00454         result->back()->push_back( this->used_registers );
00455         result->push_back( value_list::create() );
00456         result->back()->push_back( this->all_registers );
00457         result->push_back( value_list::create() );
00458         result->back()->push_back( this->register_owners );
00459         result->push_back( value_list::create() );
00460         result->back()->push_back( this->free_spill_spaces );
00461         result->push_back( value_list::create() );
00462         result->back()->push_back( this->move_gen );
00463         result->push_back( value_list::create() );
00464         result->back()->push_back( objectize< bool > ::create( this->registers_freed ) );
00465         result->push_back( value_list::create() );
00466         result->back()->push_back( this->spill_space_last_use );
00467         result->push_back( value_list::create() );
00468         result->back()->push_back( this->register_last_use );
00469         result->push_back( value_list::create() );
00470         result->back()->push_back( this->op2interval );
00471         result->push_back( value_list::create() );
00472         result->back()->push_back( this->op2group );
00473         result->push_back( value_list::create() );
00474         result->back()->push_back( this->groups );
00475         result->push_back( value_list::create() );
00476         result->back()->push_back( this->regs_used_by_groups );
00477         result->push_back( value_list::create() );
00478         result->back()->push_back( this->curr_generated_instructions );
00479         return result;
00480 }

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

Marking routine for class spillgen.

Marking routine is used for garbage collection.

Author:: lsg

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

Definition at line 487 of file spillgen.g.cc.

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

00488 {
00489         worker_base::gc_mark();
00490 }

Member Data Documentation

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

A list of active intervals.

Definition at line 333 of file spillgen.g.hh.

Referenced by activate_waiting_intervals(), active_intervals_get(), active_intervals_set(), and expire_old_intervals().

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

A list of already processed intervals.

Definition at line 335 of file spillgen.g.hh.

Referenced by expire_old_intervals(), expired_intervals_get(), and expired_intervals_set().

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

A list of intervals witing for processing.

Definition at line 337 of file spillgen.g.hh.

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

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

A set of free registers.

Definition at line 339 of file spillgen.g.hh.

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

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

A set of used registers.

Definition at line 341 of file spillgen.g.hh.

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

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

A set of all the registers that machine description contains.

Definition at line 343 of file spillgen.g.hh.

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

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

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

Definition at line 345 of file spillgen.g.hh.

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

srp< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::pi_mem_factory > > > lestes::backend_v2::workers::spillgen::free_spill_spaces [private]

A set of free spill-places.

Definition at line 347 of file spillgen.g.hh.

Referenced by expire_old_intervals(), free_group_resources(), free_spill_spaces_get(), and free_spill_spaces_set().

srp< ::lestes::md::registers::move_generator > lestes::backend_v2::workers::spillgen::move_gen [private]

Provides generation of copy-code between register and memory.

Definition at line 349 of file spillgen.g.hh.

Referenced by expire_old_intervals(), move_gen_get(), move_gen_set(), and process().

bool lestes::backend_v2::workers::spillgen::registers_freed [private]

Definition at line 350 of file spillgen.g.hh.

Referenced by find_free_registers(), registers_freed_get(), and registers_freed_set().

srp< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::pi_mem_factory >, srp< ::lestes::backend_v2::intercode::ge_pi > > > lestes::backend_v2::workers::spillgen::spill_space_last_use [private]

A map between a spill-space and its last use.

Definition at line 352 of file spillgen.g.hh.

Referenced by expire_old_intervals(), spill_space_last_use_get(), and spill_space_last_use_set().

srp< ::lestes::std::map< ulint, srp< ::lestes::backend_v2::intercode::ge_pi > > > lestes::backend_v2::workers::spillgen::register_last_use [private]

A map between a register and its last use.

Definition at line 354 of file spillgen.g.hh.

Referenced by find_last_use_of_register(), register_last_use_get(), and register_last_use_set().

srp< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< ::lestes::backend_v2::workers::alloc_interval > > > lestes::backend_v2::workers::spillgen::op2interval [private]

A map between an operand and its active interval.

Definition at line 356 of file spillgen.g.hh.

Referenced by op2interval_get(), and op2interval_set().

srp< ::lestes::std::map< srp< ::lestes::backend_v2::intercode::ge_operand_reg >, srp< spillgen_group > > > lestes::backend_v2::workers::spillgen::op2group [private]

A map between an operand and its active group.

Definition at line 358 of file spillgen.g.hh.

Referenced by op2group_get(), and op2group_set().

srp< ::lestes::std::list< srp< spillgen_group > > > lestes::backend_v2::workers::spillgen::groups [private]

Active groups.

Definition at line 360 of file spillgen.g.hh.

Referenced by allocate_regs_for_groups(), free_group_resources(), groups_get(), and groups_set().

srp< ::lestes::std::set< ulint > > lestes::backend_v2::workers::spillgen::regs_used_by_groups [private]

A set of registers used by active groups.

Definition at line 362 of file spillgen.g.hh.

Referenced by allocate_reg_for_group(), regs_used_by_groups_get(), and regs_used_by_groups_set().

srp< ::lestes::std::set< srp< ::lestes::backend_v2::intercode::ge_pi > > > lestes::backend_v2::workers::spillgen::curr_generated_instructions [private]

A spill-code that has been generated for a current intruction.

Definition at line 364 of file spillgen.g.hh.

Referenced by curr_generated_instructions_get(), and curr_generated_instructions_set().

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

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

Definition at line 365 of file spillgen.g.hh.

Referenced by reflection_get().

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

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

1.5.1-20070107

lestes::backend_v2::workers::spillgen 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