alloc_int_finder.g.cc

Go to the documentation of this file.

// This file is automatically generated, do not edit.

/*!
        \file
        \author jaz
*/

#include <lestes/backend_v2/structs/func_data.g.hh>
#include <lestes/backend_v2/intercode/ge.g.hh>
#include <lestes/backend_v2/intercode/pi_mem_factory.g.hh>
#include <lestes/backend_v2/workers/liveness_analysis.g.hh>
#include <lestes/md/registers/tm_register.g.hh>

#include <lestes/std/list.hh>
#include <lestes/std/pair.hh>
#include <lestes/std/reflect.hh>

#include <lestes/backend_v2/workers/alloc_int_finder.g.hh>

package(lestes);
package(backend_v2);
package(workers);


// ------------- Class alloc_int_finder follows. -------------

/*!
   This factory method for class alloc_int_finder takes values of all fields as arguments.
   \author lsg
 */
ptr< alloc_int_finder > alloc_int_finder::create(ptr< ::lestes::backend_v2::structs::func_data > a__worker_base__data)
{
        return ptr< alloc_int_finder > ( new alloc_int_finder(a__worker_base__data) );
}

/*!
   Generated constructor for class alloc_int_finder.
   \author lsg
 */
alloc_int_finder::alloc_int_finder (ptr< ::lestes::backend_v2::structs::func_data > a__worker_base__data)
        : worker_base(a__worker_base__data)
{}

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

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


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void alloc_int_finder::gc_mark()
{
        worker_base::gc_mark();
}

// End of class alloc_int_finder.

// ------------- Class alloc_interval follows. -------------

/*!
   \returns The value of alloc_interval::operand.
   \author lsg
 */
ptr< ::lestes::backend_v2::intercode::ge_operand_reg > alloc_interval::operand_get() const
{
        return operand;
}

/*!
   \param[in] x The new value to set alloc_interval::operand to.
   \author lsg
 */
void alloc_interval::operand_set(const ptr< ::lestes::backend_v2::intercode::ge_operand_reg > & x)
{
        alloc_interval::operand = x;
}

/*!
   \returns The value of alloc_interval::rng.
   \author lsg
 */
ptr< ::lestes::backend_v2::workers::liveness_range > alloc_interval::rng_get() const
{
        return rng;
}

/*!
   \param[in] x The new value to set alloc_interval::rng to.
   \author lsg
 */
void alloc_interval::rng_set(const ptr< ::lestes::backend_v2::workers::liveness_range > & x)
{
        alloc_interval::rng = x;
}

/*!
   \returns The value of alloc_interval::prev.
   \author lsg
 */
ptr< alloc_interval > alloc_interval::prev_get() const
{
        return prev;
}

/*!
   \param[in] x The new value to set alloc_interval::prev to.
   \author lsg
 */
void alloc_interval::prev_set(const ptr< alloc_interval > & x)
{
        alloc_interval::prev = x;
}

/*!
   \returns The value of alloc_interval::next.
   \author lsg
 */
ptr< alloc_interval > alloc_interval::next_get() const
{
        return next;
}

/*!
   \param[in] x The new value to set alloc_interval::next to.
   \author lsg
 */
void alloc_interval::next_set(const ptr< alloc_interval > & x)
{
        alloc_interval::next = x;
}

/*!
   \returns The value of alloc_interval::allocated_spill_place.
   \author lsg
 */
ptr< ::lestes::backend_v2::intercode::pi_mem_factory > alloc_interval::allocated_spill_place_get() const
{
        return allocated_spill_place;
}

/*!
   \param[in] x The new value to set alloc_interval::allocated_spill_place to.
   \author lsg
 */
void alloc_interval::allocated_spill_place_set(const ptr< ::lestes::backend_v2::intercode::pi_mem_factory > & x)
{
        alloc_interval::allocated_spill_place = x;
}

/*!
   \returns The value of alloc_interval::allocated_reg.
   \author lsg
 */
ptr< ::lestes::md::registers::tm_register > alloc_interval::allocated_reg_get() const
{
        return allocated_reg;
}

/*!
   \param[in] x The new value to set alloc_interval::allocated_reg to.
   \author lsg
 */
void alloc_interval::allocated_reg_set(const ptr< ::lestes::md::registers::tm_register > & x)
{
        alloc_interval::allocated_reg = x;
}

/*!
   \returns The value of alloc_interval::allocated_obj_prev_owner.
   \author lsg
 */
ptr< alloc_interval > alloc_interval::allocated_obj_prev_owner_get() const
{
        return allocated_obj_prev_owner;
}

/*!
   \param[in] x The new value to set alloc_interval::allocated_obj_prev_owner to.
   \author lsg
 */
void alloc_interval::allocated_obj_prev_owner_set(const ptr< alloc_interval > & x)
{
        alloc_interval::allocated_obj_prev_owner = x;
}

/*!
   \returns The value of alloc_interval::start.
   \author lsg
 */
ulint alloc_interval::start_get() const
{
        return start;
}

/*!
   \param[in] x The new value to set alloc_interval::start to.
   \author lsg
 */
void alloc_interval::start_set(ulint x)
{
        alloc_interval::start = x;
}

/*!
   \returns The value of alloc_interval::end.
   \author lsg
 */
ulint alloc_interval::end_get() const
{
        return end;
}

/*!
   \param[in] x The new value to set alloc_interval::end to.
   \author lsg
 */
void alloc_interval::end_set(ulint x)
{
        alloc_interval::end = x;
}

/*!
   \returns The value of alloc_interval::instructions.
   \author lsg
 */
ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::intercode::ge_pi > > > alloc_interval::instructions_get() const
{
        return instructions;
}

/*!
   \param[in] x The new value to set alloc_interval::instructions to.
   \author lsg
 */
void alloc_interval::instructions_set(const ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::intercode::ge_pi > > > & x)
{
        alloc_interval::instructions = x;
}

/*!
   \returns The value of alloc_interval::allowed_registers.
   \author lsg
 */
ptr< ::lestes::std::set< ulint > > alloc_interval::allowed_registers_get() const
{
        return allowed_registers;
}

/*!
   \param[in] x The new value to set alloc_interval::allowed_registers to.
   \author lsg
 */
void alloc_interval::allowed_registers_set(const ptr< ::lestes::std::set< ulint > > & x)
{
        alloc_interval::allowed_registers = x;
}

/*!
   This factory method for class alloc_interval takes values of all fields as arguments.
   \author lsg
 */
ptr< alloc_interval > alloc_interval::create(ptr< ::lestes::backend_v2::intercode::ge_operand_reg > a__alloc_interval__operand,
                ptr< ::lestes::backend_v2::workers::liveness_range > a__alloc_interval__rng,
                ptr< alloc_interval > a__alloc_interval__prev,
                ptr< alloc_interval > a__alloc_interval__next,
                ptr< ::lestes::backend_v2::intercode::pi_mem_factory > a__alloc_interval__allocated_spill_place,
                ptr< ::lestes::md::registers::tm_register > a__alloc_interval__allocated_reg,
                ptr< alloc_interval > a__alloc_interval__allocated_obj_prev_owner,
                ulint a__alloc_interval__start,
                ulint a__alloc_interval__end,
                ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::intercode::ge_pi > > > a__alloc_interval__instructions,
                ptr< ::lestes::std::set< ulint > > a__alloc_interval__allowed_registers)
{
        return ptr< alloc_interval > ( new alloc_interval(a__alloc_interval__operand,
                a__alloc_interval__rng,
                a__alloc_interval__prev,
                a__alloc_interval__next,
                a__alloc_interval__allocated_spill_place,
                a__alloc_interval__allocated_reg,
                a__alloc_interval__allocated_obj_prev_owner,
                a__alloc_interval__start,
                a__alloc_interval__end,
                a__alloc_interval__instructions,
                a__alloc_interval__allowed_registers) );
}

/*!
   This factory method for class alloc_interval uses initializers.
   \author lsg
 */
ptr< alloc_interval > alloc_interval::create(ptr< ::lestes::backend_v2::intercode::ge_operand_reg > a__alloc_interval__operand,
                ptr< ::lestes::backend_v2::workers::liveness_range > a__alloc_interval__rng)
{
        return ptr< alloc_interval > ( new alloc_interval(a__alloc_interval__operand, a__alloc_interval__rng, NULL, NULL, NULL, NULL, NULL, 0, 0, ::lestes::std::vector< srp< ::lestes::backend_v2::intercode::ge_pi > > ::create(), NULL) );
}

/*!
   Generated constructor for class alloc_interval.
   \author lsg
 */
alloc_interval::alloc_interval (ptr< ::lestes::backend_v2::intercode::ge_operand_reg > a__alloc_interval__operand,
                ptr< ::lestes::backend_v2::workers::liveness_range > a__alloc_interval__rng,
                ptr< alloc_interval > a__alloc_interval__prev,
                ptr< alloc_interval > a__alloc_interval__next,
                ptr< ::lestes::backend_v2::intercode::pi_mem_factory > a__alloc_interval__allocated_spill_place,
                ptr< ::lestes::md::registers::tm_register > a__alloc_interval__allocated_reg,
                ptr< alloc_interval > a__alloc_interval__allocated_obj_prev_owner,
                ulint a__alloc_interval__start,
                ulint a__alloc_interval__end,
                ptr< ::lestes::std::vector< srp< ::lestes::backend_v2::intercode::ge_pi > > > a__alloc_interval__instructions,
                ptr< ::lestes::std::set< ulint > > a__alloc_interval__allowed_registers)
        : ::lestes::std::object(), operand(checked(a__alloc_interval__operand)), rng(checked(a__alloc_interval__rng)), prev(a__alloc_interval__prev), next(a__alloc_interval__next), allocated_spill_place(a__alloc_interval__allocated_spill_place), allocated_reg(a__alloc_interval__allocated_reg), allocated_obj_prev_owner(a__alloc_interval__allocated_obj_prev_owner), start(a__alloc_interval__start), end(a__alloc_interval__end), instructions(checked(a__alloc_interval__instructions)), allowed_registers(a__alloc_interval__allowed_registers)
{}

ptr< object::reflection_list > alloc_interval::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "operand", "ge_operand_reg" ) );
                mdl->push_back( md::create( "rng", "liveness_range" ) );
                mdl->push_back( md::create( "prev", "alloc_interval" ) );
                mdl->push_back( md::create( "next", "alloc_interval" ) );
                mdl->push_back( md::create( "allocated_spill_place", "pi_mem_factory" ) );
                mdl->push_back( md::create( "allocated_reg", "tm_register" ) );
                mdl->push_back( md::create( "allocated_obj_prev_owner", "alloc_interval" ) );
                mdl->push_back( md::create( "start", "ulint" ) );
                mdl->push_back( md::create( "end", "ulint" ) );
                mdl->push_back( md::create( "instructions", "vector&lt; srp&lt; ::lestes::backend_v2::intercode::ge_pi &gt; &gt;" ) );
                mdl->push_back( md::create( "allowed_registers", "set&lt; ulint &gt;" ) );
                reflection = reflection_list::create( ::lestes::std::object::reflection_get() );
                reflection->push_back( class_reflection::create( "alloc_interval", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > alloc_interval::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::std::object::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->operand );
        result->push_back( value_list::create() );
        result->back()->push_back( this->rng );
        result->push_back( value_list::create() );
        result->back()->push_back( this->prev );
        result->push_back( value_list::create() );
        result->back()->push_back( this->next );
        result->push_back( value_list::create() );
        result->back()->push_back( this->allocated_spill_place );
        result->push_back( value_list::create() );
        result->back()->push_back( this->allocated_reg );
        result->push_back( value_list::create() );
        result->back()->push_back( this->allocated_obj_prev_owner );
        result->push_back( value_list::create() );
        result->back()->push_back( objectize< ulint > ::create( this->start ) );
        result->push_back( value_list::create() );
        result->back()->push_back( objectize< ulint > ::create( this->end ) );
        result->push_back( value_list::create() );
        result->back()->push_back( this->instructions );
        result->push_back( value_list::create() );
        result->back()->push_back( this->allowed_registers );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void alloc_interval::gc_mark()
{
	::lestes::std::object::gc_mark();
}

// End of class alloc_interval.


// static data members follow 
ptr<object::reflection_list> alloc_int_finder::reflection = reflection;
ptr<object::reflection_list> alloc_interval::reflection = reflection;

end_package(workers);
end_package(backend_v2);
end_package(lestes);

---