lestes::backend_v2::workers::bb_finder Class Reference

Identifies basic block in a function body. More...

#include <bb_finder.g.hh>

Inheritance diagram for lestes::backend_v2::workers::bb_finder:

List of all members.

Public Member Functions
void	process ()
	Groups pseudoinstructions of a function body to basic blocks.
ptr< ::lestes::backend_v2::structs::func_data >	get_result ()
bool	is_instruction_safe (ptr< ::lestes::backend_v2::intercode::ge_pi > ge)
ptr< basic_block >	join_blocks (ptr< basic_block > bb1, ptr< basic_block > bb2)
	Merges two basic blocks into one.
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< bb_finder >	create (ptr< ::lestes::backend_v2::structs::func_data > a__worker_base__data)
	First generated factory method for class bb_finder.
Protected Member Functions
	bb_finder (ptr< ::lestes::backend_v2::structs::func_data > a__worker_base__data)
	Generated constructor for class bb_finder.
virtual void	gc_mark ()
	Marking routine for class bb_finder.
Static Private Attributes
static ptr< reflection_list >	reflection = reflection

---

Detailed Description

Identifies basic block in a function body.

Definition at line 50 of file bb_finder.g.hh.

---

Constructor & Destructor Documentation

lestes::backend_v2::workers::bb_finder::bb_finder

(

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

a__worker_base__data

)

[protected]

Generated constructor for class bb_finder.

Generated constructor for class bb_finder.

Author:

lsg

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

Referenced by create().

        : worker_base(a__worker_base__data)
{}

---

Member Function Documentation

void lestes::backend_v2::workers::bb_finder::process

(

)

[virtual]

Groups pseudoinstructions of a function body to basic blocks.

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

Definition at line 29 of file bb_finder.cc.

References lestes::backend_v2::workers::basic_block::create(), lestes::backend_v2::workers::worker_base::data_get(), is_instruction_safe(), and join_blocks().

                        {
        
        ptr<ge_pi_list__type> body = data_get()->ge_body_get();
        ptr<bb_vector__type> bbs = data_get()->bbs_get();
        
        ptr<basic_block> prev_bb = NULL;
        ptr<basic_block> active_bb = NULL;
        
        bool b_active_is_safe = true;
        
        for(ge_pi_list__type::iterator it = body->begin(); it!=body->end(); ++it) {
                ptr<ge_pi> ge = *it;

                if (ge->kind_get()==ge_pi::SP ) {
                        ptr<ge_sp> sp = ge.dncast<ge_sp>();

                        if ( active_bb ) {
                                active_bb->lsp_set(sp);
                                
                                if ( prev_bb ) {
                                        //Join blocks.
                                        active_bb = join_blocks(prev_bb,active_bb);
                                } else {                                        
                                        bbs->push_back(active_bb);
                                }
                                
                                if ( sp->is_jmp_target_get() || !b_active_is_safe ) {
                                        prev_bb = NULL;
                                } else {
                                        prev_bb = active_bb;
                                }
                                
                                active_bb = NULL;
                        }
                        
                        if ( !active_bb && ge!=body->back() ) {
                                active_bb = basic_block::create();
                                active_bb->fsp_set(sp);
                                b_active_is_safe = true;
                        }
                        
                } else {                
                        /*
                                The following code line turns off block joining.
                                
                                Extended basic blocks bring a lots of problems especially 
                                in context with memory operands and memory alliasing.
                                
                                Extended blocks don't produce better results of code scheduling
                                so it is better to switch off block joining to extended blocks.
                        */
                        prev_bb = NULL; 
                        
                        ge->bb_set(active_bb);
                        active_bb->instructions_get()->push_back(ge);
                        
                        if ( !is_instruction_safe(ge) ) {
                                 //The block contains instruction that doesn't allow the block to be merged with a previous one.
                                 prev_bb = NULL;
                                 b_active_is_safe = false;
                        }
                }
        }
}

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

(

)

[virtual]

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

Definition at line 275 of file bb_finder.cc.

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

                                     {
        return data_get();
}

bool lestes::backend_v2::workers::bb_finder::is_instruction_safe

(

ptr< ::lestes::backend_v2::intercode::ge_pi >

ge

)

Referenced by process().

ptr< basic_block > lestes::backend_v2::workers::bb_finder::join_blocks	(	ptr< basic_block >	bb1,
		ptr< basic_block >	bb2
	)

Merges two basic blocks into one.

Parameters:

	bb1	A first basic block.
	bb2	A second basic block.

Returns:

A merged result.

Definition at line 144 of file bb_finder.cc.

References lestes::msg::eolog.

Referenced by process().

                                                                                  {
        ptr<ge_pi_vector__type> active_instrs = bb2->instructions_get();
        ptr<ge_pi_vector__type> prev_instrs = bb1->instructions_get();
                                        
        ptr<ge_sp> prev_fsp = bb1->fsp_get();
        ptr<ge_sp> active_lsp = bb2->lsp_get();//
        
        bb1->lsp_set(active_lsp);
        
        ptr<ge_sp> active_fsp = bb2->fsp_get();
                                        
        /*  
                Split the bording sp into two sps. The first one will inherit input operands and dependencies
                and the second one will inherits output ones.
        */
        
        ptr<ge_sp> new_sp = ge_sp::create(NULL,NULL);
        new_sp->operands_input_set(active_fsp->operands_input_get());
        new_sp->dependencies_set(active_fsp->dependencies_get());
        new_sp->bb_set(bb1);
        prev_instrs->push_back(new_sp);
                                        
        prev_instrs->push_back(active_fsp);
        active_fsp->dependencies_set(ge_pi_set__type::create());
        active_fsp->operands_input_set(ge_operand_vector__type::create());
        active_fsp->bb_set(bb1);
                                        
        /*
                In the first block, find instructions that stores into memory.
        */
        ptr<m2ge_pi_set__type> mfdeps = m2ge_pi_set__type::create();
        
        for(ge_pi_vector__type::iterator it = prev_instrs->begin(); it!=prev_instrs->end(); ++it) {
                ptr<ge_pi> ge = *it;
                
                active_lsp->dependencies_get()->insert(ge);
                
                ptr<ge_operand_vector__type> operands = ge->operands_input_get();
                
                for(ge_operand_vector__type::iterator it_op = operands->begin(); it_op!=operands->end(); ++it_op) {
                        if ( (*it_op)->kind_get()!=ge_operand::MEMORY ) {
                                continue;
                        }

                        ptr<pi_mem_factory> mf = (*it_op).dncast<ge_operand_mem>()->factory_get();
                                
                        m2ge_pi_set__type::iterator it_search = mfdeps->find(mf);
                                
                        if ( it_search!=mfdeps->end() ) {
                                it_search->second->insert(ge);
                        } else {
                                ptr<ge_pi_set__type> deps = ge_pi_set__type::create();
                                deps->insert(ge);
                                (*mfdeps)[mf] = deps;
                        }       
                }
                
                operands = ge->operands_output_get();
                
                for(ge_operand_vector__type::iterator it_op = operands->begin(); it_op!=operands->end(); ++it_op) {
                        if ( (*it_op)->kind_get()!=ge_operand::MEMORY ) {
                                continue;
                        }

                        ptr<pi_mem_factory> mf = (*it_op).dncast<ge_operand_mem>()->factory_get();
                                
                        m2ge_pi_set__type::iterator it_search = mfdeps->find(mf);
                                
                        if ( it_search!=mfdeps->end() ) {
                                it_search->second->insert(ge);
                        } else {
                                ptr<ge_pi_set__type> deps = ge_pi_set__type::create();
                                deps->insert(ge);
                                (*mfdeps)[mf] = deps;
                        }       
                }
                
        }
        
        /*
                In the second block, find instructions that uses memory operands and set dependecies on instructions from the
                first block that produces these operands.
        */
        for(ge_pi_vector__type::iterator it = active_instrs->begin(); it!=active_instrs->end(); ++it) {
                ptr<ge_pi> ge = *it;
                
                ptr<ge_operand_vector__type> operands = ge->operands_input_get();
                
                for(ge_operand_vector__type::iterator it_op = operands->begin(); it_op!=operands->end(); ++it_op) {
                        if ( (*it_op)->kind_get()!=ge_operand::MEMORY ) {
                                continue;
                        }

                        ptr<pi_mem_factory> mf = (*it_op).dncast<ge_operand_mem>()->factory_get();
                                
                        m2ge_pi_set__type::iterator it_search = mfdeps->find(mf);
                                
                        if ( it_search!=mfdeps->end() ) {
                                ge->dependencies_get()->insert(it_search->second->begin(),it_search->second->end());
                        }       
                }
                
                operands = ge->operands_output_get();
                
                for(ge_operand_vector__type::iterator it_op = operands->begin(); it_op!=operands->end(); ++it_op) {
                        if ( (*it_op)->kind_get()!=ge_operand::MEMORY ) {
                                continue;
                        }

                        ptr<pi_mem_factory> mf = (*it_op).dncast<ge_operand_mem>()->factory_get();
                                
                        m2ge_pi_set__type::iterator it_search = mfdeps->find(mf);
                                
                        if ( it_search!=mfdeps->end() ) {
                                ge->dependencies_get()->insert(it_search->second->begin(),it_search->second->end());
                        }       
                }
                
                //Finaly, insert instruction from the second block to the first one.
                prev_instrs->push_back(ge);
                ge->bb_set(bb1);
                ge->dependencies_get()->insert(prev_fsp);
                active_lsp->dependencies_get()->insert(ge);
                
        }
        
        bblog << "Blocks joined (" << bb1->uid_get() << "<-" << bb2->uid_get() << ").\n" << eolog;
        
        return bb1;
}

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

(

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

a__worker_base__data

)

[static]

First generated factory method for class bb_finder.

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

Author:

lsg

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

References bb_finder().

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

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

(

)

const [virtual]

for purposes of dumping

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

Definition at line 41 of file bb_finder.g.cc.

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

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

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

(

)

const [virtual]

for purposes of dumping

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

Definition at line 53 of file bb_finder.g.cc.

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

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

void lestes::backend_v2::workers::bb_finder::gc_mark

(

void

)

[protected, virtual]

Marking routine for class bb_finder.

Marking routine is used for garbage collection.

Author:

lsg

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

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

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

{
        worker_base::gc_mark();
}

---

Member Data Documentation

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

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

Definition at line 81 of file bb_finder.g.hh.

Referenced by reflection_get().

---

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

• bb_finder.g.hh
• bb_finder.cc
• bb_finder.g.cc

---