lestes::md::registers::tm_register Class Reference

#include <tm_register.g.hh>

Inheritance diagram for lestes::md::registers::tm_register:

lestes::md::registers::tm_register_base lestes::std::object lestes::std::mem::keystone List of all members.

Public Member Functions

virtual ptr< reflection_listreflection_get () const
 for purposes of dumping
virtual ptr< field_list_listfield_values_get () const
 for purposes of dumping

Static Public Member Functions

static ptr< ::lestes::std::map<
tm_register_base::id_type,
srp< tm_register > > > 
id_to_instance_get ()
 The method id_to_instance_get returns the value of the field tm_register::id_to_instance.
static void id_to_instance_set (const ptr< ::lestes::std::map< tm_register_base::id_type, srp< tm_register > > > &)
 The method id_to_instance_set sets the field tm_register::id_to_instance to the given value.
static ptr< tm_registerinstance (tm_register_base::id_type id)
 Returns singleton instance for given id.
static ptr< tm_registercreate (tm_register_base::id_type a__tm_register_base__id, ulint a__tm_register_base__bitwidth, ptr< ::lestes::std::set< ::lestes::md::types::tm_data_type_base::id_type > > a__tm_register_base__compatible_types, ptr< ::lestes::std::set< tm_register_base::id_type > > a__tm_register_base__aliases, ptr< ::lestes::std::set< ulint > > a__tm_register_base__move_templates, lstring a__tm_register_base__asm_output, ulint a__tm_register_base__flags)
 First generated factory method for class tm_register.
static ptr< tm_registercreate (tm_register_base::id_type a__tm_register_base__id, ulint a__tm_register_base__bitwidth, ptr< ::lestes::std::set< ::lestes::md::types::tm_data_type_base::id_type > > a__tm_register_base__compatible_types, ptr< ::lestes::std::set< tm_register_base::id_type > > a__tm_register_base__aliases, ptr< ::lestes::std::set< ulint > > a__tm_register_base__move_templates, lstring a__tm_register_base__asm_output)
 Second generated factory method for class tm_register.

Protected Member Functions

 tm_register (tm_register_base::id_type a__tm_register_base__id, ulint a__tm_register_base__bitwidth, ptr< ::lestes::std::set< ::lestes::md::types::tm_data_type_base::id_type > > a__tm_register_base__compatible_types, ptr< ::lestes::std::set< tm_register_base::id_type > > a__tm_register_base__aliases, ptr< ::lestes::std::set< ulint > > a__tm_register_base__move_templates, lstring a__tm_register_base__asm_output, ulint a__tm_register_base__flags)
 Generated constructor for class tm_register.
virtual void gc_mark ()
 Marking routine for class tm_register.

Static Private Attributes

static ptr< ::lestes::std::map<
tm_register_base::id_type,
srp< tm_register > > > 
id_to_instance = ::lestes::std::map< tm_register_base::id_type, srp< tm_register > > ::create()
 Singleton instances.
static ptr< reflection_listreflection = reflection

Detailed Description

Definition at line 32 of file tm_register.g.hh.


Constructor & Destructor Documentation

lestes::md::registers::tm_register::tm_register ( tm_register_base::id_type  a__tm_register_base__id,
ulint  a__tm_register_base__bitwidth,
ptr< ::lestes::std::set< ::lestes::md::types::tm_data_type_base::id_type > >  a__tm_register_base__compatible_types,
ptr< ::lestes::std::set< tm_register_base::id_type > >  a__tm_register_base__aliases,
ptr< ::lestes::std::set< ulint > >  a__tm_register_base__move_templates,
lstring  a__tm_register_base__asm_output,
ulint  a__tm_register_base__flags 
) [protected]

Generated constructor for class tm_register.

Generated constructor for class tm_register.

Author:
lsg

Definition at line 80 of file tm_register.g.cc.

Referenced by create().

00087         : tm_register_base(a__tm_register_base__id,
00088                 a__tm_register_base__bitwidth,
00089                 a__tm_register_base__compatible_types,
00090                 a__tm_register_base__aliases,
00091                 a__tm_register_base__move_templates,
00092                 a__tm_register_base__asm_output,
00093                 a__tm_register_base__flags)
00094 {}


Member Function Documentation

ptr<::lestes::std::map< tm_register_base::id_type, srp< tm_register > > > lestes::md::registers::tm_register::id_to_instance_get (  )  [static]

The method id_to_instance_get returns the value of the field tm_register::id_to_instance.

Returns:
The value of tm_register::id_to_instance.
Author:
lsg

Definition at line 27 of file tm_register.g.cc.

References id_to_instance.

Referenced by instance().

00028 {
00029         return id_to_instance;
00030 }

void lestes::md::registers::tm_register::id_to_instance_set ( const ptr< ::lestes::std::map< tm_register_base::id_type, srp< tm_register > > > &  x  )  [static]

The method id_to_instance_set sets the field tm_register::id_to_instance to the given value.

Parameters:
[in] x The new value to set tm_register::id_to_instance to.
Author:
lsg

Definition at line 36 of file tm_register.g.cc.

References id_to_instance.

00037 {
00038         tm_register::id_to_instance = x;
00039 }

ptr< tm_register > lestes::md::registers::tm_register::instance ( tm_register_base::id_type  id  )  [static]

Returns singleton instance for given id.

Definition at line 21 of file tm_register.mdg.cc.

References create(), lestes::md::types::DT_BOOL, lestes::md::types::DT_COND, lestes::md::types::DT_INT_16S, lestes::md::types::DT_INT_16U, lestes::md::types::DT_INT_32S, lestes::md::types::DT_INT_32U, lestes::md::types::DT_INT_8P, lestes::md::types::DT_INT_8S, lestes::md::types::DT_INT_8U, id_to_instance_get(), lassert, lestes::md::registers::tm_register_base::move_templates, lestes::md::registers::R_AH, lestes::md::registers::R_AL, lestes::md::registers::R_AX, lestes::md::registers::R_BH, lestes::md::registers::R_BL, lestes::md::registers::R_BX, lestes::md::registers::R_CH, lestes::md::registers::R_CL, lestes::md::registers::R_COND, lestes::md::registers::R_CX, lestes::md::registers::R_DH, lestes::md::registers::R_DI, lestes::md::registers::R_DL, lestes::md::registers::R_DX, lestes::md::registers::R_EAX, lestes::md::registers::R_EBP, lestes::md::registers::R_EBX, lestes::md::registers::R_ECX, lestes::md::registers::R_EDI, lestes::md::registers::R_EDX, lestes::md::registers::R_ESI, lestes::md::registers::R_ESP, lestes::md::registers::R_SI, lestes::md::registers::R_UNDEFINED, lestes::md::registers::RF_NOSPILL, lestes::md::instructions::TEM_REGISTER_MOVE_1, lestes::md::instructions::TEM_REGISTER_MOVE_2, lestes::md::instructions::TEM_REGISTER_MOVE_3, lestes::md::instructions::TEM_REGISTER_MOVE_4, and lestes::md::instructions::TEM_REGISTER_MOVE_5.

00021                                                                  {
00022         map<tm_register_base::id_type, srp<tm_register> >::iterator existing_reg = id_to_instance_get()->find(id);
00023 
00024         if ( existing_reg != id_to_instance_get()->end() ) {
00025                 return existing_reg->second;
00026         }
00027 
00028         ptr<tm_register> new_reg = NULL;
00029         switch(id) {
00030                 case R_UNDEFINED: lassert(false); break;
00031                 case R_AL: {
00032                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00033                         dt_list->insert(DT_INT_8P);
00034                         dt_list->insert(DT_INT_8U);
00035                         dt_list->insert(DT_INT_8S);
00036                         dt_list->insert(DT_BOOL);
00037                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00038                         reg_list->insert(R_AL);
00039                         reg_list->insert(R_AX);
00040                         reg_list->insert(R_EAX);
00041                         ptr<set<ulint> > move_templates = set<ulint>::create();
00042                         move_templates->insert(TEM_REGISTER_MOVE_1);
00043                         new_reg = tm_register::create(R_AL, 8, dt_list, reg_list, move_templates, lstring("AL"),0);
00044                 } break;
00045                 case R_AH: {
00046                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00047                         dt_list->insert(DT_INT_8P);
00048                         dt_list->insert(DT_INT_8U);
00049                         dt_list->insert(DT_INT_8S);
00050                         dt_list->insert(DT_BOOL);
00051                         dt_list->insert(DT_COND);
00052                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00053                         reg_list->insert(R_AH);
00054                         reg_list->insert(R_AX);
00055                         reg_list->insert(R_EAX);
00056                         ptr<set<ulint> > move_templates = set<ulint>::create();
00057                         move_templates->insert(TEM_REGISTER_MOVE_1);
00058                         new_reg = tm_register::create(R_AH, 8, dt_list, reg_list, move_templates, lstring("AH"),0);
00059                 } break;
00060                 case R_AX: {
00061                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00062                         dt_list->insert(DT_INT_16U);
00063                         dt_list->insert(DT_INT_16S);
00064                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00065                         reg_list->insert(R_AX);
00066                         reg_list->insert(R_AH);
00067                         reg_list->insert(R_AL);
00068                         reg_list->insert(R_EAX);
00069                         ptr<set<ulint> > move_templates = set<ulint>::create();
00070                         move_templates->insert(TEM_REGISTER_MOVE_1);
00071                         new_reg = tm_register::create(R_AX, 16, dt_list, reg_list, move_templates, lstring("AX"),0);
00072                 } break;
00073                 case R_EAX: {
00074                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00075                         dt_list->insert(DT_INT_32U);
00076                         dt_list->insert(DT_INT_32S);
00077                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00078                         reg_list->insert(R_EAX);
00079                         reg_list->insert(R_AH);
00080                         reg_list->insert(R_AL);
00081                         reg_list->insert(R_AX);
00082                         ptr<set<ulint> > move_templates = set<ulint>::create();
00083                         move_templates->insert(TEM_REGISTER_MOVE_1);
00084                         new_reg = tm_register::create(R_EAX, 32, dt_list, reg_list, move_templates, lstring("EAX"),0);
00085                 } break;
00086                 case R_BL: {
00087                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00088                         dt_list->insert(DT_INT_8P);
00089                         dt_list->insert(DT_INT_8U);
00090                         dt_list->insert(DT_INT_8S);
00091                         dt_list->insert(DT_BOOL);
00092                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00093                         reg_list->insert(R_BL);
00094                         reg_list->insert(R_BX);
00095                         reg_list->insert(R_EBX);
00096                         ptr<set<ulint> > move_templates = set<ulint>::create();
00097                         move_templates->insert(TEM_REGISTER_MOVE_1);
00098                         new_reg = tm_register::create(R_BL, 8, dt_list, reg_list, move_templates, lstring("BL"),0);
00099                 } break;
00100                 case R_BH: {
00101                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00102                         dt_list->insert(DT_INT_8P);
00103                         dt_list->insert(DT_INT_8U);
00104                         dt_list->insert(DT_INT_8S);
00105                         dt_list->insert(DT_BOOL);
00106                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00107                         reg_list->insert(R_BH);
00108                         reg_list->insert(R_BX);
00109                         reg_list->insert(R_EBX);
00110                         ptr<set<ulint> > move_templates = set<ulint>::create();
00111                         move_templates->insert(TEM_REGISTER_MOVE_1);
00112                         new_reg = tm_register::create(R_BH, 8, dt_list, reg_list, move_templates, lstring("BH"),0);
00113                 } break;
00114                 case R_BX: {
00115                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00116                         dt_list->insert(DT_INT_16U);
00117                         dt_list->insert(DT_INT_16S);
00118                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00119                         reg_list->insert(R_BX);
00120                         reg_list->insert(R_BH);
00121                         reg_list->insert(R_BL);
00122                         reg_list->insert(R_EBX);
00123                         ptr<set<ulint> > move_templates = set<ulint>::create();
00124                         move_templates->insert(TEM_REGISTER_MOVE_1);
00125                         new_reg = tm_register::create(R_BX, 16, dt_list, reg_list, move_templates, lstring("BX"),0);
00126                 } break;
00127                 case R_EBX: {
00128                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00129                         dt_list->insert(DT_INT_32U);
00130                         dt_list->insert(DT_INT_32S);
00131                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00132                         reg_list->insert(R_EBX);
00133                         reg_list->insert(R_BH);
00134                         reg_list->insert(R_BL);
00135                         reg_list->insert(R_BX);
00136                         ptr<set<ulint> > move_templates = set<ulint>::create();
00137                         move_templates->insert(TEM_REGISTER_MOVE_1);
00138                         new_reg = tm_register::create(R_EBX, 32, dt_list, reg_list, move_templates, lstring("EBX"),0);
00139                 } break;
00140                 case R_CL: {
00141                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00142                         dt_list->insert(DT_INT_8P);
00143                         dt_list->insert(DT_INT_8U);
00144                         dt_list->insert(DT_INT_8S);
00145                         dt_list->insert(DT_BOOL);
00146                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00147                         reg_list->insert(R_CL);
00148                         reg_list->insert(R_CX);
00149                         reg_list->insert(R_ECX);
00150                         ptr<set<ulint> > move_templates = set<ulint>::create();
00151                         move_templates->insert(TEM_REGISTER_MOVE_1);
00152                         new_reg = tm_register::create(R_CL, 8, dt_list, reg_list, move_templates, lstring("CL"),0);
00153                 } break;
00154                 case R_CH: {
00155                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00156                         dt_list->insert(DT_INT_8P);
00157                         dt_list->insert(DT_INT_8U);
00158                         dt_list->insert(DT_INT_8S);
00159                         dt_list->insert(DT_BOOL);
00160                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00161                         reg_list->insert(R_CH);
00162                         reg_list->insert(R_CX);
00163                         reg_list->insert(R_ECX);
00164                         ptr<set<ulint> > move_templates = set<ulint>::create();
00165                         move_templates->insert(TEM_REGISTER_MOVE_1);
00166                         new_reg = tm_register::create(R_CH, 8, dt_list, reg_list, move_templates, lstring("CH"),0);
00167                 } break;
00168                 case R_CX: {
00169                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00170                         dt_list->insert(DT_INT_16U);
00171                         dt_list->insert(DT_INT_16S);
00172                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00173                         reg_list->insert(R_CX);
00174                         reg_list->insert(R_CL);
00175                         reg_list->insert(R_CH);
00176                         reg_list->insert(R_ECX);
00177                         ptr<set<ulint> > move_templates = set<ulint>::create();
00178                         move_templates->insert(TEM_REGISTER_MOVE_1);
00179                         new_reg = tm_register::create(R_CX, 16, dt_list, reg_list, move_templates, lstring("CX"),0);
00180                 } break;
00181                 case R_ECX: {
00182                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00183                         dt_list->insert(DT_INT_32U);
00184                         dt_list->insert(DT_INT_32S);
00185                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00186                         reg_list->insert(R_ECX);
00187                         reg_list->insert(R_CL);
00188                         reg_list->insert(R_CH);
00189                         reg_list->insert(R_CX);
00190                         ptr<set<ulint> > move_templates = set<ulint>::create();
00191                         move_templates->insert(TEM_REGISTER_MOVE_1);
00192                         new_reg = tm_register::create(R_ECX, 32, dt_list, reg_list, move_templates, lstring("ECX"),0);
00193                 } break;
00194                 case R_DL: {
00195                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00196                         dt_list->insert(DT_INT_8P);
00197                         dt_list->insert(DT_INT_8U);
00198                         dt_list->insert(DT_INT_8S);
00199                         dt_list->insert(DT_BOOL);
00200                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00201                         reg_list->insert(R_DL);
00202                         reg_list->insert(R_DX);
00203                         reg_list->insert(R_EDX);
00204                         ptr<set<ulint> > move_templates = set<ulint>::create();
00205                         move_templates->insert(TEM_REGISTER_MOVE_1);
00206                         new_reg = tm_register::create(R_DL, 8, dt_list, reg_list, move_templates, lstring("DL"),0);
00207                 } break;
00208                 case R_DH: {
00209                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00210                         dt_list->insert(DT_INT_8P);
00211                         dt_list->insert(DT_INT_8U);
00212                         dt_list->insert(DT_INT_8S);
00213                         dt_list->insert(DT_BOOL);
00214                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00215                         reg_list->insert(R_DH);
00216                         reg_list->insert(R_DX);
00217                         reg_list->insert(R_EDX);
00218                         ptr<set<ulint> > move_templates = set<ulint>::create();
00219                         move_templates->insert(TEM_REGISTER_MOVE_1);
00220                         new_reg = tm_register::create(R_DH, 8, dt_list, reg_list, move_templates, lstring("DL"),0);
00221                 } break;
00222                 case R_DX: {
00223                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00224                         dt_list->insert(DT_INT_16U);
00225                         dt_list->insert(DT_INT_16S);
00226                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00227                         reg_list->insert(R_DX);
00228                         reg_list->insert(R_DL);
00229                         reg_list->insert(R_DH);
00230                         reg_list->insert(R_EDX);
00231                         ptr<set<ulint> > move_templates = set<ulint>::create();
00232                         move_templates->insert(TEM_REGISTER_MOVE_1);
00233                         new_reg = tm_register::create(R_DX, 16, dt_list, reg_list, move_templates, lstring("DX"),0);
00234                 } break;
00235                 case R_EDX: {
00236                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00237                         dt_list->insert(DT_INT_32U);
00238                         dt_list->insert(DT_INT_32S);
00239                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00240                         reg_list->insert(R_EDX);
00241                         reg_list->insert(R_DL);
00242                         reg_list->insert(R_DH);
00243                         reg_list->insert(R_DX);
00244                         ptr<set<ulint> > move_templates = set<ulint>::create();
00245                         move_templates->insert(TEM_REGISTER_MOVE_1);
00246                         new_reg = tm_register::create(R_EDX, 32, dt_list, reg_list, move_templates, lstring("EDX"),0);
00247                 } break;
00248                 case R_DI: {
00249                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00250                         dt_list->insert(DT_INT_16U);
00251                         dt_list->insert(DT_INT_16S);
00252                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00253                         reg_list->insert(R_DI);
00254                         reg_list->insert(R_EDI);
00255                         ptr<set<ulint> > move_templates = set<ulint>::create();
00256                         move_templates->insert(TEM_REGISTER_MOVE_1);
00257                         new_reg = tm_register::create(R_DI, 16, dt_list, reg_list, move_templates, lstring("DI"),0);
00258                 } break;
00259                 case R_EDI: {
00260                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00261                         dt_list->insert(DT_INT_32U);
00262                         dt_list->insert(DT_INT_32S);
00263                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00264                         reg_list->insert(R_EDI);
00265                         reg_list->insert(R_DI);
00266                         ptr<set<ulint> > move_templates = set<ulint>::create();
00267                         move_templates->insert(TEM_REGISTER_MOVE_1);
00268                         new_reg = tm_register::create(R_EDI, 32, dt_list, reg_list, move_templates, lstring("EDI"),0);
00269                 } break;
00270                 case R_SI: {
00271                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00272                         dt_list->insert(DT_INT_16U);
00273                         dt_list->insert(DT_INT_16S);
00274                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00275                         reg_list->insert(R_SI);
00276                         reg_list->insert(R_ESI);
00277                         ptr<set<ulint> > move_templates = set<ulint>::create();
00278                         move_templates->insert(TEM_REGISTER_MOVE_1);
00279                         new_reg = tm_register::create(R_SI, 16, dt_list, reg_list, move_templates, lstring("SI"),0);
00280                 } break;
00281                 case R_ESI: {
00282                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00283                         dt_list->insert(DT_INT_32U);
00284                         dt_list->insert(DT_INT_32S);
00285                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00286                         reg_list->insert(R_ESI);
00287                         reg_list->insert(R_SI);
00288                         ptr<set<ulint> > move_templates = set<ulint>::create();
00289                         move_templates->insert(TEM_REGISTER_MOVE_1);
00290                         new_reg = tm_register::create(R_ESI, 32, dt_list, reg_list, move_templates, lstring("ESI"),0);
00291                 } break;
00292                 case R_COND: {
00293                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00294                         dt_list->insert(DT_COND);
00295                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00296                         reg_list->insert(R_COND);
00297                         ptr<set<ulint> > move_templates = set<ulint>::create();
00298                         move_templates->insert(TEM_REGISTER_MOVE_2);
00299                         move_templates->insert(TEM_REGISTER_MOVE_3);
00300                         move_templates->insert(TEM_REGISTER_MOVE_4);
00301                         new_reg = tm_register::create(R_COND, 8, dt_list, reg_list, move_templates, lstring(""),0);
00302                 } break;
00303                 case R_ESP: {
00304                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00305                         dt_list->insert(DT_INT_32U);
00306                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00307                         reg_list->insert(R_ESP);
00308                         ptr<set<ulint> > move_templates = set<ulint>::create();
00309                         move_templates->insert(TEM_REGISTER_MOVE_5);
00310                         new_reg = tm_register::create(R_ESP, 32, dt_list, reg_list, move_templates, lstring("ESP"),RF_NOSPILL);
00311                 } break;
00312                 case R_EBP: {
00313                         ptr<set<tm_data_type_base::id_type> > dt_list = set<tm_data_type_base::id_type>::create();
00314                         dt_list->insert(DT_INT_32U);
00315                         ptr<set<tm_register_base::id_type> > reg_list = set<tm_register_base::id_type>::create();
00316                         reg_list->insert(R_EBP);
00317                         ptr<set<ulint> > move_templates = set<ulint>::create();
00318                         move_templates->insert(TEM_REGISTER_MOVE_5);
00319                         new_reg = tm_register::create(R_EBP, 32, dt_list, reg_list, move_templates, lstring("EBP"),RF_NOSPILL);
00320                 } break;
00321 
00322                 default: lassert(false); break;
00323 
00324         }
00325 
00326         lassert(new_reg);
00327         id_to_instance_get()->insert(::std::pair<tm_register_base::id_type, srp<tm_register> >(id,new_reg));
00328         return new_reg;
00329 }

ptr< tm_register > lestes::md::registers::tm_register::create ( tm_register_base::id_type  a__tm_register_base__id,
ulint  a__tm_register_base__bitwidth,
ptr< ::lestes::std::set< ::lestes::md::types::tm_data_type_base::id_type > >  a__tm_register_base__compatible_types,
ptr< ::lestes::std::set< tm_register_base::id_type > >  a__tm_register_base__aliases,
ptr< ::lestes::std::set< ulint > >  a__tm_register_base__move_templates,
lstring  a__tm_register_base__asm_output,
ulint  a__tm_register_base__flags 
) [static]

First generated factory method for class tm_register.

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

Author:
lsg

Definition at line 45 of file tm_register.g.cc.

References tm_register().

Referenced by instance().

00052 {
00053         return ptr< tm_register > ( new tm_register(a__tm_register_base__id,
00054                 a__tm_register_base__bitwidth,
00055                 a__tm_register_base__compatible_types,
00056                 a__tm_register_base__aliases,
00057                 a__tm_register_base__move_templates,
00058                 a__tm_register_base__asm_output,
00059                 a__tm_register_base__flags) );
00060 }

ptr< tm_register > lestes::md::registers::tm_register::create ( tm_register_base::id_type  a__tm_register_base__id,
ulint  a__tm_register_base__bitwidth,
ptr< ::lestes::std::set< ::lestes::md::types::tm_data_type_base::id_type > >  a__tm_register_base__compatible_types,
ptr< ::lestes::std::set< tm_register_base::id_type > >  a__tm_register_base__aliases,
ptr< ::lestes::std::set< ulint > >  a__tm_register_base__move_templates,
lstring  a__tm_register_base__asm_output 
) [static]

Second generated factory method for class tm_register.

This factory method for class tm_register uses initializers.

Author:
lsg

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

References tm_register().

00072 {
00073         return ptr< tm_register > ( new tm_register(a__tm_register_base__id, a__tm_register_base__bitwidth, a__tm_register_base__compatible_types, a__tm_register_base__aliases, a__tm_register_base__move_templates, a__tm_register_base__asm_output, 0) );
00074 }

ptr< object::reflection_list > lestes::md::registers::tm_register::reflection_get (  )  const [virtual]

for purposes of dumping

Reimplemented from lestes::md::registers::tm_register_base.

Definition at line 96 of file tm_register.g.cc.

References lestes::std::list< T >::create(), reflection, and lestes::md::registers::tm_register_base::reflection_get().

00097 {
00098         if (!reflection) {
00099                 typedef class_reflection::field_metadata md;
00100                 typedef class_reflection::field_metadata_list mdlist;
00101                 ptr<mdlist> mdl = mdlist::create();
00102                 mdl->push_back( md::create( "id_to_instance", "map&lt; tm_register_base::id_type, srp&lt; tm_register &gt; &gt;" ) );
00103                 reflection = reflection_list::create( tm_register_base::reflection_get() );
00104                 reflection->push_back( class_reflection::create( "tm_register", mdl ) );
00105         }
00106         return reflection;
00107 }

ptr< object::field_list_list > lestes::md::registers::tm_register::field_values_get (  )  const [virtual]

for purposes of dumping

Reimplemented from lestes::md::registers::tm_register_base.

Definition at line 109 of file tm_register.g.cc.

References lestes::std::list< T >::create(), and lestes::md::registers::tm_register_base::field_values_get().

00110 {
00111         ptr < field_list_list > result = tm_register_base::field_values_get();
00112         result->push_back( value_list::create() );
00113         result->back()->push_back( this->id_to_instance );
00114         return result;
00115 }

void lestes::md::registers::tm_register::gc_mark ( void   )  [protected, virtual]

Marking routine for class tm_register.

Marking routine is used for garbage collection.

Author:
lsg

Reimplemented from lestes::md::registers::tm_register_base.

Definition at line 122 of file tm_register.g.cc.

References lestes::md::registers::tm_register_base::gc_mark().

00123 {
00124         tm_register_base::gc_mark();
00125 }


Member Data Documentation

ptr<::lestes::std::map< tm_register_base::id_type, srp< tm_register > > > lestes::md::registers::tm_register::id_to_instance = ::lestes::std::map< tm_register_base::id_type, srp< tm_register > > ::create() [static, private]

Singleton instances.

Definition at line 86 of file tm_register.g.hh.

Referenced by id_to_instance_get(), and id_to_instance_set().

ptr< object::reflection_list > lestes::md::registers::tm_register::reflection = reflection [static, private]

Reimplemented from lestes::md::registers::tm_register_base.

Definition at line 87 of file tm_register.g.hh.

Referenced by reflection_get().


The documentation for this class was generated from the following files:
Generated on Mon Feb 12 18:25:50 2007 for lestes by doxygen 1.5.1-20070107